add tests and fixes constants

Author: Maya Shavin

packages/url/__tests__/customFunction.test.ts

@@ -0,0 +1,11 @@
+import { customFunction } from '../lib/transformers/customFunc'
+
+describe('customFunc', () => {
+  it('should return empty string if there is no type or source', () => {
+    expect(customFunction({ source: '', type: 'remote' })).toBe('')
+  });
+
+  it('should return formatted custome Function', () => {
+    expect(customFunction({ type: 'remote', source: 'my_example'})).toBe('fn_remote:my_example')
+  });
+});

packages/url/__tests__/index.test.ts

@@ -1,4 +1,7 @@
-import { buildUrl, buildVideoUrl, getConfig, setConfig } from '../lib/index'
+import { buildImageUrl, buildUrl, buildVideoUrl, extractPublicId, getConfig, RESOURCE_TYPES, setConfig, Transformer } from '../lib/index'
+import { RESOURCE_TYPES as OriginalResourceTypes, STORAGE_TYPES as OriginalStorageTypes, ROTATION_MODES as OriginalRotationModes, STORAGE_TYPES, ROTATION_MODES } from '../lib/constants'
+import { extractPublicId as originalExtractPublicId } from '../lib/url'
+import { transform, toTransformationStr } from '../lib/transformers'
 
 describe('General tests', () => {
   it('configurations', () => {
@@ -12,6 +15,13 @@ describe('General tests', () => {
   })
 
   describe('buildUrl()', () => {
+    it('should return default transformation', () => {
+      expect(buildUrl('example', {
+        cloud: {
+          cloudName: 'demo'
+        }
+      })).toBe('https://res.cloudinary.com/demo/image/upload/q_auto,f_auto/example')
+    });
     it('should return right url with configurations', () => {
       setConfig({
         cloudName: 'm'
@@ -48,6 +58,24 @@ describe('General tests', () => {
         cloudName: 'm'
       })
     });
+})
+
+  describe('buildVideoUrl()', () => {
+    it('should return url with default config when no cloud', () => {
+      setConfig({
+        cloudName: 'demo'
+      })
+
+      expect(buildVideoUrl('example', { transformations: {} })).toBe('https://res.cloudinary.com/demo/video/upload/q_auto,f_auto/example')
+    });
+
+    it('should return url with default config', () => {
+      setConfig({
+        cloudName: 'demo'
+      })
+
+      expect(buildVideoUrl('example', {})).toBe('https://res.cloudinary.com/demo/video/upload/q_auto,f_auto/example')
+    });
 
     it('should return right url format for video', () => {
       expect(buildVideoUrl('example', {
@@ -63,5 +91,61 @@ describe('General tests', () => {
       })).toEqual('https://res.cloudinary.com/demo/video/upload/c_scale,w_200,q_auto,f_auto/example') 
 
     })
-  })
+  });
+
+  describe('buildImageUrl()', () => {
+    
+    it('should return url with default config when no cloud', () => {
+      setConfig({
+        cloudName: 'demo'
+      })
+
+      expect(buildImageUrl('example', { transformations: {} })).toBe('https://res.cloudinary.com/demo/image/upload/q_auto,f_auto/example')
+    });
+    it('should return url with default config', () => {
+      setConfig({
+        cloudName: 'demo'
+      })
+
+      expect(buildImageUrl('example', {})).toBe('https://res.cloudinary.com/demo/image/upload/q_auto,f_auto/example')
+    });
+
+    it('should return url with cloud config', () => {
+
+      expect(buildImageUrl('example', {
+        cloud: {
+          cloudName: 'demo'
+        },
+        transformations: {
+          rotate: 10,
+        }
+      })).toBe('https://res.cloudinary.com/demo/image/upload/q_auto,a_10,f_auto/example')
+    });
+  });
+
+  describe('exports', () => {
+    it('should export resourceTypes', () => {
+      expect(RESOURCE_TYPES).toEqual(OriginalResourceTypes)
+    });
+
+    it('should export extractPublicId', () => {
+      expect(extractPublicId).toEqual(extractPublicId)
+    });
+
+    it('should export STORAGE_TYPES', () => {
+      expect(STORAGE_TYPES).toEqual(OriginalStorageTypes)
+    });
+
+    it('should export ROTATION_MODES', () => {
+      expect(ROTATION_MODES).toEqual(OriginalRotationModes)
+    });
+
+    it('should export transform', () => {
+      expect(Transformer.transform).toEqual(transform)
+    });
+
+    it('should export toTransformationStr', () => {
+      expect(Transformer.toString).toEqual(toTransformationStr)
+    });
+  });
 })

packages/url/__tests__/transformers.test.ts

@@ -5,6 +5,8 @@ import { position } from '../lib/transformers/position'
 import { effect } from '../lib/transformers/effect'
 import { flags } from '../lib/transformers/flags'
 import { convert } from '../lib/transformers/expression'
+import { TransformerVideoOption } from '../lib/types/CldOptions'
+import { Brightness } from '../lib/constants/effects'
 
 describe('Modifiers', () => {
   describe('transform()', () => {
@@ -73,6 +75,26 @@ describe('Modifiers', () => {
         ['bo_1px_dashed_#fff', 'e_pixelate']
       ])
     })
+
+    it('should transform video url', () => {
+      const options:TransformerVideoOption = {
+        audioCodec: 'aac',
+        colorSpace: 'srgb',
+        effect: {
+          name: Brightness.Auto,
+          value: 50
+        },
+        flags: ['animated', 'waveform'],
+        gravity: 'auto'
+      }
+      expect(transform(options)).toEqual([
+        'ac_aac',
+        'cs_srgb',
+        'g_auto',
+        'e_auto_brightness:50',
+        'fl_animated:waveform'
+      ])
+    });
   })
 
   describe('getBorder()', () => {
@@ -237,6 +259,14 @@ describe('border', () => {
   it('should return options', () => {
     expect(border({ color: 'blue', width: 10 })).toEqual('bo_10px_solid_blue')
   })
+
+  it('should return empty string', () => {
+    expect(border({ width: '' })).toBe('')
+  });
+
+  it('should return converted expression', () => {
+    expect(border({ width: 'initialWidth + 3 / 10' })).toBe('bo_iw_add_3_div_10_solid_black')
+  });
 })
 
 describe('position', () => {
@@ -288,19 +318,19 @@ describe('effect', () => {
 
 describe('flags', () => {
   it('should return empty string for empty string', () => {
-    expect(flags('')).toBe('')
+    expect(flags()).toBe('')
   });
 
   it('should return empty string for empty array', () => {
     expect(flags([])).toBe('')
   });
 
   it('should return legal string for none-empty string', () => {
-    expect(flags('cutter')).toBe('fl_cutter')
+    expect(flags('awebp')).toBe('fl_awebp')
   });
 
   it('should return legal string for non-empty array', () => {
-    expect(flags(['cutter', 'hello'])).toBe('fl_cutter:hello')
+    expect(flags(['awebp', 'any_format'])).toBe('fl_awebp:any_format')
   });
 })
 

packages/url/__tests__/url.test.ts

@@ -1,4 +1,5 @@
-import { url, getPrefix, getPathToAsset, getVersion, getSignature, extractPublicId } from '../lib/url'
+import { SEO_TYPES, STORAGE_TYPES } from '../lib/constants'
+import { url, getPrefix, getPathToAsset, getVersion, getSignature, extractPublicId, getSubDomain, getResourceType } from '../lib/url'
 
 describe('Url', () => {
   describe('getPrefix()', () => {
@@ -119,6 +120,11 @@ describe('Url', () => {
   })
 
   describe('url()', () => {
+    it('should throw error if no cloudname', () => {
+      expect(() => {
+        url('123')
+      }).toThrow('cloudName is required!')
+    });
     it('should return delivery url', () => {
       expect(url('example', {
         cloudName: 'demo',
@@ -207,4 +213,58 @@ describe('Url', () => {
       expect(extractPublicId('example')).toEqual('example')
     })
   })
+
+  describe('getSubDomain', () => {
+    it('should return empty string if no cname', () => {
+      expect(getSubDomain('abc', {})).toBe('res')
+    });
+
+    it('should return res subdomain if cdnSubdomain but no cname', () => {
+      expect(getSubDomain('abe', { cdnSubdomain: true })).toBe('res-abe')
+    });
+
+    it('should return a subdomain if cname', () => {
+      expect(getSubDomain('abe', { cname: 'a', cdnSubdomain: true })).toBe('aabe.')
+    });
+  });
+
+  describe('getResourceType', () => {
+    it('should return shortern root path', () => {
+      expect(getResourceType({
+        shortern: true,
+        useRootPath: true
+      })).toBe('iu')
+    });
+
+    it('should return empty string if not shortern but use root path', () => {
+      expect(getResourceType({
+        shortern: false,
+        useRootPath: true
+      })).toBe('')
+    });
+
+    it('should throw error if use root path for not supported type', () => {
+      expect(() => {
+        getResourceType({
+          storageType: STORAGE_TYPES.AUTHENTICATED,
+          useRootPath: true
+        })
+      }).toThrow('Root path only supported for image/upload')
+    });
+
+    it('should return url suffix', () => {
+      expect(getResourceType({
+        urlSuffix: 'h'
+      })).toBe(SEO_TYPES["image/upload"])
+    });
+
+    it('should throw error if not found seo', () => {
+      expect(() => {
+        getResourceType({
+          storageType: STORAGE_TYPES.FACEBOOK,
+          urlSuffix: 'h'
+        })
+      }).toThrow(`URL Suffix only supported for ${Object.keys(SEO_TYPES).join(', ')}`)
+    });
+  });
 })

packages/url/__tests__/variables.test.ts

@@ -41,6 +41,24 @@ describe('computeVariable()', () => {
 
     expect(computeVariable(variable)).toBe('$small_!breadth!_to_f')
   });
+
+  it('should return empty string if no expression', () => {
+    expect(computeVariable({
+      name: 'small',
+      value: {
+        expression: ''
+      }
+    })).toBe('')
+  });
+
+  it('should return mapped expression from array', () => {
+    expect(computeVariable({
+      name: 'small',
+      value: {
+        expression: ['a', 'b']
+      }
+    })).toBe('$small_!a:b!')
+  });
 });
 
 describe('variables()', () => {
@@ -76,5 +94,5 @@ describe('variables()', () => {
       }
     }]
     expect(variables(input)).toBe('$small_!breadth!_to_f,$big_2_mul_$small')
-  })
+  })  
 });

packages/url/__tests__/video.test.ts

@@ -0,0 +1,60 @@
+import { fps } from "../lib/transformers/video/fps";
+import { offset } from "../lib/transformers/video/offset";
+
+describe('Video transformation', () => {
+  describe('fps()', () => {
+    it('should map the fps accordingly', () => {
+      expect(fps(90)).toBe('fps_90')
+    });
+
+    it('should return empty if there is no input', () => {
+      expect(fps()).toBe('')
+    });
+
+    it('should map fps with min', () => {
+      expect(fps({
+        min: 90
+      })).toBe('fps_90')
+    });
+
+    it('should map fps with max and min', () => {
+      expect(fps({
+        min: 90,
+        max: 100
+      })).toBe('fps_90-100')
+    });
+  });
+
+  describe('offset()', () => {
+    it('should return empty string when no input', () => {
+      expect(offset()).toBe('')
+    });
+
+    it('should return start offset', () => {
+      expect(offset({
+        start: 10
+      })).toBe('so_10')
+    });
+
+    it('should return start offset', () => {
+      expect(offset({
+        end: 10
+      })).toBe('eo_10')
+    });
+
+    it('should return start, end offset', () => {
+      expect(offset({
+        start: 10,
+        end: 10
+      })).toBe('so_10,eo_10')
+    });
+
+    it('should return start, end offset and duration', () => {
+      expect(offset({
+        start: 10,
+        end: 10,
+        duration: "70"
+      })).toBe('so_10,eo_10,du_70')
+    });
+  });
+});