@pixwel/pixwel-sdk 1.1.0

package/test/parse.spec.ts

@@ -0,0 +1,927 @@
+import * as parse from '../lib/parse';
+// import * as api   from '../common/api';
+
+import {
+  merge,
+  filter,
+  whereEq
+} from 'ramda';
+
+import {
+  each,
+  resolve
+} from 'bluebird';
+
+describe('parse', () => {
+  const input = (data: Object) => merge({
+    api:   mockApi,
+    parts: [],
+    tags:  [],
+    types: [],
+    territories: []
+  }, data) as parse.Input;
+
+  var mockApi: any;
+
+  beforeEach(() => {
+    mockApi = jasmine.createSpyObj('api', ['read', 'update']);
+    spyOn(api, 'create').and.returnValue(mockApi);
+  });
+
+  describe('.project()', () => {
+    var parts = [
+      'PROJECT-A',
+      'ASSET-ONE'
+    ];
+
+    it('matches a Project by `filePrefix` and removes first part', done => {
+      mockApi.read.and.callFake(() => resolve([{
+        _id: 'projectA',
+        filePrefix: 'PROJECT-A'
+      }]));
+
+      parse.project(input({parts}))
+        .then(result => {
+          expect(mockApi.read).toHaveBeenCalledWith('projects', {
+            filePrefix: 'PROJECT-A'
+          });
+
+          expect(result.project).toEqual({_id: 'projectA'});
+          expect(result.parts).toEqual(['ASSET-ONE']);
+        })
+        .finally(done);
+    });
+  });
+
+  describe('.type()', () => {
+    var types = [{
+      name: 'greetings'
+    }, {
+      name: 'dubbing-refs',
+      file: 'DUB-REF'
+    }];
+
+    it('matches a Type by `name`', () => {
+      var parts = [
+        'GREETINGS',
+        'TEST-GREETING'
+      ];
+
+      var result = parse.type(input({parts, types}))
+      expect(result.asset).toEqual({type: 'greetings'});
+      expect(result.parts).toEqual(['TEST-GREETING']);
+    });
+
+    it('matches a Type by `file`', () => {
+      var parts = [
+        'DUB-REF',
+        'TEST-DUBBING-REFERENCE'
+      ];
+
+      var result = parse.type(input({parts, types}))
+      expect(result.asset).toEqual({type: 'dubbing-refs'});
+      expect(result.parts).toEqual(['TEST-DUBBING-REFERENCE']);
+    });
+  });
+
+  describe('.trailer()', () => {
+    it('does nothing if next filename part is `TR`', () => {
+      expect(parse.trailer(input({parts: ['TR']}))).toBeUndefined();
+    });
+
+    it('does nothing when next filename part does not match convention', () => {
+      expect(parse.trailer(input({parts: ['FOO']}))).toBeUndefined();
+    });
+
+    it('handles domestic, international and generic trailer types', () => {
+      var tests = [{
+        part: 'DTR-A',
+        name: 'Domestic Trailer A',
+        slug: 'domestic-trailer-a',
+        type: 'trailer.us'
+      }, {
+        part: 'DTR-A-CRE-TEST-ONE',
+        name: 'Domestic Trailer A - Test One',
+        slug: 'domestic-trailer-a-test-one',
+        type: 'trailer.us.cre'
+      }, {
+        part: 'ITR-1',
+        name: `Int'l Trailer 1`,
+        slug: 'int-l-trailer-1',
+        type: 'trailer.intl'
+      }, {
+        part: 'ITR-1-CRE-TEST-TWO',
+        name: `Int'l Trailer 1 - Test Two`,
+        slug: 'int-l-trailer-1-test-two',
+        type: 'trailer.intl.cre'
+      }, {
+        part: 'TR-TEST',
+        name: 'Test Trailer',
+        slug: 'test-trailer',
+        type: 'trailer'
+      }, {
+        part: 'TR-TEST-CRE-GENERIC-TEST-THREE',
+        name: 'Test Trailer - Generic Test Three',
+        slug: 'test-trailer-generic-test-three',
+        type: 'trailer.cre'
+      }];
+
+      tests.forEach(test => {
+        var parts = [test.part, 'TAG-TWO'];
+        var result = parse.trailer(input({parts}));
+
+        expect(result.parts).toEqual(['TAG-TWO']);
+        expect(result.asset.name).toEqual(test.name);
+        expect(result.asset.slug).toEqual(test.slug);
+        expect(result.asset.type).toEqual(test.type);
+      });
+    });
+  });
+
+  describe('.nonTrailer()', () => {
+    it('does nothing for `trailer` asset types', () => {
+      var types = ['trailer', 'trailer.intl', 'trailer.us'];
+
+      types.forEach(type => {
+        var result = parse.nonTrailer(input({asset: {type}}));
+        expect(result).toBeUndefined();
+      });
+    });
+
+    it('extracts asset name and slug', () => {
+      var parts = [
+        'HELLO-WORLD',
+        'PREVIEW'
+      ];
+
+      var asset = {};
+
+      var result = parse.nonTrailer(input({parts, asset}));
+      expect(result.parts).toEqual(['PREVIEW']);
+      expect(result.asset).toEqual({
+        name: 'Hello World',
+        slug: 'hello-world'
+      });
+    });
+
+    it('it normalizes `intl` to `int\'l`', () => {
+      var parts = [
+        'HELLO-WORLD-INTL',
+        'PREVIEW'
+      ];
+
+      var asset = {};
+
+      var result = parse.nonTrailer(input({parts, asset}));
+      expect(result.asset).toEqual({
+        name: `Hello World Int'l`,
+        slug: 'hello-world-int-l'
+      });
+    });
+
+    it('normalizes a domestic Asset Type to International', () => {
+      var parts = [
+        'HELLO-WORLD-INTL',
+        'PREVIEW'
+      ];
+
+      var asset = {
+        type: 'tv-spot.us'
+      };
+
+      var result = parse.nonTrailer(input({parts, asset}));
+      expect(result.asset).toEqual({
+        name: `Hello World Int'l`,
+        slug: 'hello-world-int-l',
+        type: 'tv-spot.intl'
+      });
+    });
+
+    it('extracts length from Asset Name', () => {
+      var parts = [
+        'HELLO-WORLD-30',
+        'PREVIEW'
+      ];
+
+      var asset = {
+        type: 'tv-spot.us'
+      };
+
+      var result = parse.nonTrailer(input({parts, asset}));
+      expect(result.asset).toEqual({
+        name:   `Hello World 30`,
+        slug:   'hello-world-30',
+        type:   'tv-spot.us',
+        length: 30
+      });
+    });
+  });
+
+  describe('.locale()', () => {
+    var territories = [{
+      languages: [{code: 'ENG'}],
+      countries: [{code: 'AU'}]
+    }, {
+      languages: [{code: 'PFR'}],
+      countries: [{code: 'FR'}]
+    }, {
+      languages: [{code: 'BPO'}],
+      countries: [{code: 'BR'}]
+    }, {
+      languages: [{code: 'LIT'}],
+      countries: [{code: 'LT'}]
+    }, {
+      languages: [{code: 'ENG'}],
+      countries: [{code: 'US'}]
+    }];
+
+    it('does nothing if part does not match', () => {
+      var tests = [
+        ['TEST'],
+        ['SOME-OTHER-TAG', 'ANOTHER'],
+        ['ENG-TEST'],
+        ['GB']
+      ];
+
+      tests.forEach(parts => {
+        var result = parse.locale(input({parts, territories}));
+        expect(result).toBeUndefined();
+      });
+    });
+
+    it('determines country and `*.intl` type for dual-language codes', () => {
+      var tests = [{
+        parts:    ['ARA-PFR'],
+        language: 'ARA-PFR',
+        country:  'LB'
+      }, {
+        parts:    ['PFR-ARA'],
+        language: 'ARA-PFR',
+        country:  'LB'
+      }];
+
+      tests.forEach(test => {
+        var result = parse.locale(input({
+          parts: test.parts,
+          asset: {
+            type: 'tv-spot.us'
+          }
+        }));
+
+        expect(result.file.country).toEqual(test.country);
+        expect(result.file.language).toEqual(test.language);
+        expect(result.asset.type).toEqual('tv-spot.intl');
+      });
+    });
+
+    it('corrects `BZP` to `BPO` and `LTH` to `LIT`', () => {
+      var tests = [{
+        parts:    ['BZP'],
+        language: 'BPO'
+      }, {
+        parts:    ['LTH'],
+        language: 'LIT'
+      }];
+
+      tests.forEach(test => {
+        var result = parse.locale(input({
+          territories,
+          asset: {},
+          parts: test.parts
+        }));
+
+        expect(result.file.language).toEqual(test.language);
+      });
+    });
+
+    it('sets `SUB` and `DUB` tags', () => {
+      var tests = [{
+        parts:    ['PFR-DUB'],
+        language: 'PFR',
+        tags:     ['dub']
+      }, {
+        parts:    ['ENG-SUB'],
+        language: 'ENG',
+        tags:     ['sub']
+      }];
+
+      tests.forEach(test => {
+        var result = parse.locale(input({
+          territories,
+          asset: {},
+          parts: test.parts
+        }));
+
+        expect(result.file.language).toEqual(test.language);
+        expect(result.file.tags).toEqual(test.tags);
+      });
+    });
+
+    it('ignores languages which do not exist in `territories`', () => {
+      expect(parse.locale(input({territories, parts: ['FOO']}))).toBeUndefined();
+    });
+
+    it('defaults country to `WW` if country does not exist', () => {
+      var tests = [{
+        parts:    ['ENG-AU'],
+        language: 'ENG',
+        country:  'AU'
+      }, {
+        parts:    ['PFR'],
+        language: 'PFR',
+        country:  'WW'
+      }, {
+        parts:    ['PFR-FR'],
+        language: 'PFR',
+        country:  'FR'
+      }, {
+        parts:    ['ENG'],
+        language: 'ENG',
+        country:  'WW'
+      }, {
+        parts:    ['ENG-FOO'],
+        language: 'ENG',
+        country:  'WW'
+      }];
+
+      tests.forEach(test => {
+        var result = parse.locale(input({
+          territories,
+          asset: {},
+          parts: test.parts
+        }));
+
+        expect(result.file.language).toEqual(test.language);
+        expect(result.file.country).toEqual(test.country);
+      });
+    });
+
+    it('normalizes a domestic asset type to `*.intl` if country is not `US`', () => {
+      var asset = {
+        type: 'tv-spot.us'
+      };
+
+      var tests = [{
+        parts: ['ENG-US'],
+        type:  'tv-spot.us'
+      }, {
+        parts: ['ENG'],
+        type: 'tv-spot.intl'
+      }, {
+        parts: ['PFR'],
+        type: 'tv-spot.intl'
+      }];
+
+      tests.forEach(test => {
+        var result = parse.locale(input({
+          territories,
+          asset,
+          parts: test.parts
+        }));
+
+        expect(result.asset.type).toBe(test.type);
+      });
+    });
+  });
+
+  describe('.tags()', () => {
+    var tags = [{
+      name: 'mp3',
+      extension: 'MP3'
+    }, {
+      name: 'prores',
+      aliases: ['ProRes']
+    }, {
+      name: 'hd'
+    }, {
+      name: 'txtl',
+      aliases: ['TXTL', 'txtl1']
+    }, {
+      name: '480p',
+      set: ['h264', '848x480', 'online']
+    }];
+
+    it('uses file extension to append initial tags', () => {
+      var tests = [{
+        ext:  'mp3',
+        prev: [],
+        tags: ['mp3']
+      }, {
+        ext:  'mp3',
+        prev: ['dub'],
+        tags: ['dub', 'mp3']
+      }, {
+        ext:  'mp4',
+        prev: [],
+        tags: []
+      }, {
+        ext: 'mp4',
+        prev: ['sub'],
+        tags: ['sub']
+      }];
+
+      tests.forEach((test, index) => {
+        var result = parse.tags(input({
+          tags,
+          parts: [],
+          asset: {},
+          file: {
+            tags: test.prev,
+            ext:  test.ext
+          }
+        }));
+
+        expect(result.file.tags).toEqual(test.tags);
+      });
+    });
+
+    it('appends `broadcast` tag to Radio Spots', () => {
+      var types = ['radio-spot.us', 'radio-spot.intl'];
+
+      types.forEach(type => {
+        var result = parse.tags(input({
+          tags,
+          parts: [],
+          asset: {type},
+          file: {
+            ext: 'mp3'
+          }
+        }));
+
+        expect(result.file.tags).toEqual(['mp3', 'broadcast']);
+      });
+
+      var result = parse.tags(input({
+        tags,
+        parts: [],
+        asset: 'radio-spot.us',
+        file: {
+          tags: ['broadcast'],
+          ext:  'mp3'
+        }
+      }));
+
+      expect(result.file.tags).toEqual(['broadcast', 'mp3']);
+    });
+
+    it('uses remaining unique file parts that exist as tags', () => {
+      var parts = [
+        'PRORES',
+        'PRORES',
+        'FOO',
+        'HD',
+        'TXTL',
+        'TXTL1'
+      ];
+
+      var result = parse.tags(input({
+        tags,
+        parts,
+        asset: {},
+        file: {
+          ext: 'mov'
+        }
+      }));
+
+      expect(result.parts).toEqual(['FOO']);
+      expect(result.file.tags).toEqual(['prores', 'hd', 'txtl']);
+    });
+
+    it('expands a single tag to a set', () => {
+      var result = parse.tags(input({
+        tags,
+        parts: ['FOO', 'prores', '480p'],
+        asset: {},
+        file: {
+          ext: 'mov'
+        }
+      }));
+
+      expect(result.parts).toEqual(['FOO']);
+      expect(result.file.tags).toEqual(['prores', 'h264', '848x480', 'online']);
+    });
+  });
+
+  describe('.defaultTextTag()', () => {
+    var tags = [{
+      name: 'txtd',
+      type: 'Text'
+    }, {
+      name: 'txtl',
+      type: 'Text'
+    }, {
+      name: 'flattened',
+      type: 'Text'
+    }, {
+      name: 'layered',
+      type: 'Text'
+    }];
+
+    var types = [{
+      name: 'tv-spot.intl',
+      category: 'av'
+    }, {
+      name: 'magazines',
+      category: 'print'
+    }];
+
+    it('does nothing if no text tags are defined', () => {
+      var result = parse.defaultTextTag(input({
+        types,
+        tags:  [],
+        asset: {},
+        file:  {}
+      }));
+
+      expect(result).toBeUndefined();
+    });
+
+    it('does nothing if text tags are already present', () => {
+      var tests = [{
+        tags: ['foo', 'txtd']
+      }, {
+        tags: ['foo', 'flattened']
+      }];
+
+      tests.forEach(test => {
+        var result = parse.defaultTextTag(input({
+          tags,
+          types,
+          file: {
+            tags: test.tags
+          }
+        }));
+
+        expect(result).toBeUndefined();
+      });
+    });
+
+    it('appends the default text tag based on asset type', () => {
+      var tests = [{
+        type: 'tv-spot.intl',
+        prev: ['foo'],
+        tags: ['foo', 'txtd']
+      }, {
+        type: 'magazines',
+        prev: ['foo'],
+        tags: ['foo', 'flattened']
+      }];
+
+      tests.forEach(test => {
+        var result = parse.defaultTextTag(input({
+          tags,
+          types,
+          asset: {
+            type: test.type
+          },
+          file: {
+            tags: test.prev
+          }
+        }));
+
+        expect(result.file.tags).toEqual(test.tags);
+      });
+    });
+  });
+
+  describe('.runningTime()', () => {
+    it('does nothing if a matching tag is not found', () => {
+      var result = parse.runningTime(input({
+        parts: ['FOO', 'BAR']
+      }));
+
+      expect(result).toBeUndefined();
+    });
+
+    it('extracts running time', () => {
+      var tests = [{
+        prev: ['FOO', '30', 'BAR'],
+        parts: ['FOO', 'BAR'],
+        length: 30
+      }, {
+        prev: ['FOO', '1hr', 'BAR'],
+        parts: ['FOO', 'BAR'],
+        length: 3600
+      }, {
+        prev: ['FOO', '1hr30min', 'BAR'],
+        parts: ['FOO', 'BAR'],
+        length: 5400
+      }, {
+        prev: ['FOO', '1hr30min12sec', 'BAR'],
+        parts: ['FOO', 'BAR'],
+        length: 5412
+      }];
+
+      tests.forEach(test => {
+        var result = parse.runningTime(input({
+          parts: test.prev
+        }));
+
+        expect(result.asset.length).toEqual(test.length);
+        expect(result.parts).toEqual(test.parts);
+      });
+    });
+  });
+
+  describe('.version()', () => {
+    it('does nothing when last part is not `PREVIEW` or `OFFLINE`', () => {
+      var result = parse.version(input({
+        parts: ['FOO', 'BAR']
+      }));
+
+      expect(result).toEqual({
+        parts: ['FOO', 'BAR']
+      });
+    });
+
+    it('does nothing if tag is just `REV`', () => {
+      var result = parse.version(input({
+        parts: ['FOO', 'REV', 'BAR', 'PREVIEW']
+      }));
+
+      expect(result).toEqual({
+        parts: ['FOO', 'REV', 'BAR', 'PREVIEW']
+      });
+    });
+
+    it('formats version label accordingly', () => {
+      var result = parse.version(input({
+        parts: ['FOO', 'REV-NEW-VERSION', 'BAR', 'PREVIEW']
+      }));
+
+      expect(result.preview).toBe(true);
+      expect(result.version).toBe('New Version');
+    });
+  });
+
+  describe('.mediaType()', () => {
+    it('does nothing for an unrecognized extension', () => {
+      var result = parse.mediaType(input({
+        file: {
+          ext: 'foo'
+        }
+      }));
+
+      expect(result).toBeUndefined();
+    });
+
+    it('determines media type by file extension', () => {
+      var tests = [{
+        ext: 'txt',
+        type: 'document'
+      }, {
+        ext: 'mov',
+        type: 'video'
+      }, {
+        ext: 'jpg',
+        type: 'image'
+      }];
+
+      tests.forEach(test => {
+        var result = parse.mediaType(input({
+          file: {
+            ext: test.ext
+          }
+        }));
+
+        expect(result).toEqual({
+          asset: {
+            mediaType: test.type
+          }
+        });
+      });
+    });
+  });
+
+  describe('.asset()', () => {
+    it('does nothing if project ID could not be determined previously', () => {
+      parse.asset(input({
+        project: {
+          _id: undefined
+        },
+        asset: {
+          slug: 'test-asset-slug'
+        }
+      }));
+
+      expect(mockApi.read).not.toHaveBeenCalled();
+    });
+
+    it('attempts to matches by project and slug', done => {
+      mockApi.read.and.callFake(() => resolve([{
+        _id: 'test-asset-id',
+        slug: 'test-asset-slug'
+      }]));
+
+      parse
+        .asset(input({
+          project: {
+            _id: 'test-project-id'
+          },
+          asset: {
+            slug: 'test-asset-slug'
+          }
+        }))
+        .then(result => {
+          expect(mockApi.read).toHaveBeenCalledWith('assets', {
+            project: 'test-project-id',
+            slug:    'test-asset-slug'
+          });
+
+          expect(result).toEqual({
+            asset: {
+              _id: 'test-asset-id'
+            }
+          });
+        })
+        .finally(done);
+    });
+  });
+
+  describe('.default()', () => {
+    var input = {
+      ingest:  'test-ingest',
+      source:  'http: //test.com/path/to/test_FILE.mov',
+      token:   'test-token',
+      apiRoot: 'http://test.com/api',
+      skipScratchPreview: false
+    };
+
+    var mocks = {
+      tags: 'mockTags',
+      assettypes: 'mockAssetTypes',
+      territories: 'mockTerritories'
+    };
+
+    beforeEach(() => {
+      for (let parser in parse) {
+        if (parser === 'default') {
+          continue;
+        }
+        spyOn(<any> parse, parser);
+      }
+
+      mockApi.read.and.callFake((path: string) => resolve(mocks[path]));
+    });
+
+    it('configures API according to job parameters', done => {
+      parse.default(input)
+        .then(() => {
+          expect(api.create).toHaveBeenCalledWith('http://test.com/api', 'test-token');
+        })
+        .finally(done);
+    });
+
+    it('calls each parser with API instance and initial data', done => {
+      parse.default(input)
+        .then(() => {
+          for (let parser in parse) {
+            if (parser === 'default') {
+              continue;
+            }
+
+            expect(parse[parser]).toHaveBeenCalledWith({
+              territories: mocks.territories,
+              api:   mockApi,
+              tags:  mocks.tags,
+              types: mocks.assettypes,
+              parts: ['test', 'FILE'],
+              file: {
+                ext: 'mov'
+              }
+            });
+          }
+        })
+        .finally(done);
+    });
+
+    it('merges the result of parser into the data that is given to the next', done => {
+      (parse.type as jasmine.Spy).and.returnValue({
+        asset: {
+          type: 'trailer.intl'
+        }
+      });
+
+      (parse.runningTime as jasmine.Spy).and.returnValue({
+        asset: {
+          length: 30
+        }
+      });
+
+      parse.default(input)
+        .then(() => {
+          expect(parse.trailer).toHaveBeenCalledWith({
+              territories: mocks.territories,
+              api:   mockApi,
+              tags:  mocks.tags,
+              types: mocks.assettypes,
+              parts: ['test', 'FILE'],
+              file: {
+                ext: 'mov'
+              },
+              asset: {
+                type: 'trailer.intl'
+              }
+          });
+
+          expect(parse.version).toHaveBeenCalledWith({
+              territories: mocks.territories,
+              api:   mockApi,
+              tags:  mocks.tags,
+              types: mocks.assettypes,
+              parts: ['test', 'FILE'],
+              asset: {
+                type: 'trailer.intl',
+                length: 30
+              },
+              file: {
+                ext: 'mov'
+              }
+          });
+        })
+        .finally(done);
+    });
+
+    it('returns the merged result of all parsers with initial data omitted', done => {
+      (parse.project as jasmine.Spy).and.returnValue({
+        project: {
+          _id: 'test-project'
+        }
+      });
+
+      (parse.type as jasmine.Spy).and.returnValue({
+        asset: {
+          type: 'trailer.intl'
+        }
+      });
+
+      (parse.runningTime as jasmine.Spy).and.returnValue({
+        asset: {
+          length: 30
+        }
+      });
+
+      parse.default(input)
+        .then((result: any) => {
+          expect(result).toEqual({
+            project: {
+              _id: 'test-project'
+            },
+            asset: {
+              type: 'trailer.intl',
+              length: 30
+            },
+            file: {
+              ext: 'mov'
+            }
+          });
+        })
+        .finally(done);
+    });
+
+    it('updates the ingest document with filename metadata', done => {
+      parse.default(input)
+        .then(() => {
+          expect(mockApi.update).toHaveBeenCalledWith('ingests/test-ingest', {
+            filename: {
+              file: {
+                ext: 'mov'
+              }
+            }
+          });
+        })
+        .finally(done);
+    });
+  });
+
+  describe('integration tests', () => {
+    var suite = require('./parse.integration');
+
+    beforeEach(() => {
+      mockApi.read.and.callFake((path: string, params?: Object) => {
+        var data = suite.mocks[path];
+        var response = params ? filter(whereEq(params), data) : data;
+
+        return resolve(response);
+      });
+    });
+
+    suite.tests.forEach((test: any) => {
+      it(`parses '${test.filename}'`, done => {
+        var input = {
+          ingest:  'test-ingest',
+          source:  `http: //test.com/path/to/${test.filename}`,
+          token:   'test-token',
+          apiRoot: 'http://test.com/api',
+          skipScratchPreview: false
+        };
+
+        parse.default(input)
+          .then((result: any) => {
+            expect(result).toEqual(test.result);
+          })
+          .finally(done);
+      });
+    });
+  });
+});