| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| (function () { |
| 'use strict'; |
| |
| describe('EntitySerializer', function () { |
| var serializer; |
| beforeEach(module('app.services.entity.serializer', 'dateHelper')); |
| |
| |
| beforeEach(inject(function(EntitySerializer, DateHelper) { |
| serializer = EntitySerializer; |
| })); |
| |
| describe('deserialize feed', function() { |
| |
| it('Should copy the general information', function() { |
| |
| var feedModel = { |
| feed: { |
| _xmlns: "uri:falcon:feed:0.1", |
| _name: 'FeedName', |
| _description: 'Feed Description' |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.name).toBe(feedModel.feed._name); |
| expect(feed.description).toBe(feedModel.feed._description); |
| expect(feed.xmlns).toBe(undefined); |
| }); |
| |
| it('Should copy tags', function() { |
| |
| var feedModel = { |
| feed: { |
| tags: 'owner=USMarketing,classification=Secure' |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.tags[0].key).toBe('owner'); |
| expect(feed.tags[0].value).toBe('USMarketing'); |
| expect(feed.tags[1].key).toBe('classification'); |
| expect(feed.tags[1].value).toBe('Secure'); |
| }); |
| |
| it('Should copy groups', function() { |
| |
| var feedModel = { |
| feed: { |
| groups: 'churnAnalysisDataPipeline,Group2,Group3' |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.groups).toBe(feedModel.feed.groups); |
| }); |
| |
| it('Should copy ACL', function() { |
| var feedModel = { |
| feed: { |
| ACL: {_owner: 'ambari-qa', _group: 'users', _permission: '0755' } |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.ACL.owner).toBe(feedModel.feed.ACL._owner); |
| expect(feed.ACL.group).toBe(feedModel.feed.ACL._group); |
| expect(feed.ACL.permission).toBe(feedModel.feed.ACL._permission); |
| }); |
| |
| it('Should copy Schema', function() { |
| var feedModel = { |
| feed: { |
| schema: {_location: '/location', _provider: 'provider'} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.schema.location).toBe(feedModel.feed.schema._location); |
| expect(feed.schema.provider).toBe(feedModel.feed.schema._provider); |
| }); |
| |
| it('Should copy frequency', function() { |
| var feedModel = { |
| feed: { |
| frequency: 'hours(20)' |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.frequency.unit).toBe('hours'); |
| expect(feed.frequency.quantity).toBe('20'); |
| }); |
| |
| it('Should copy late arrival', function() { |
| var feedModel = { |
| feed: { |
| "late-arrival": {"_cut-off": 'days(10)'} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.lateArrival.active).toBe(true); |
| expect(feed.lateArrival.cutOff.unit).toBe('days'); |
| expect(feed.lateArrival.cutOff.quantity).toBe('10'); |
| }); |
| |
| it('Should not copy late arrival when is not present', function() { |
| var feedModel = { |
| feed: {} |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.lateArrival.active).toBe(true); |
| expect(feed.lateArrival.cutOff.unit).toBe('hours'); |
| expect(feed.lateArrival.cutOff.quantity).toBe(4); |
| }); |
| |
| it('Should copy availabilityFlag', function() { |
| var feedModel = { |
| feed: { |
| availabilityFlag: 'Available' |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.availabilityFlag).toBe(feedModel.feed.availabilityFlag); |
| }); |
| |
| it('Should not copy availabilityFlag if not present in the xml', function() { |
| var feedModel = { |
| feed: {} |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.availabilityFlag).toBe("_success"); |
| }); |
| |
| it('Should copy custom properties', function() { |
| var feedModel = { |
| feed: { |
| properties: {property: [ |
| {_name: 'Prop1', _value: 'Value1'}, |
| {_name: 'Prop2', _value: 'Value2'} |
| ]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.customProperties.length).toBe(3); |
| expect(feed.customProperties[1].key).toBe('Prop1'); |
| expect(feed.customProperties[1].value).toBe('Value1'); |
| expect(feed.customProperties[2].key).toBe('Prop2'); |
| expect(feed.customProperties[2].value).toBe('Value2'); |
| }); |
| |
| it('Should not copy falcon properties into the custom properties', function() { |
| var feedModel = { |
| feed: { |
| properties: {property: [ |
| {_name: 'queueName', _value: 'QueueName'}, |
| {_name: 'Prop1', _value: 'Value1'} |
| ]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.customProperties.length).toBe(2); |
| expect(feed.customProperties[0].key).toBe(null); |
| expect(feed.customProperties[0].value).toBe(null); |
| expect(feed.customProperties[1].key).toBe('Prop1'); |
| expect(feed.customProperties[1].value).toBe('Value1'); |
| }); |
| |
| it('Should copy queueName properties into properties', function() { |
| var feedModel = { |
| feed: { |
| properties: {property: [ |
| {_name: 'queueName', _value: 'QueueName'}, |
| {_name: 'Prop1', _value: 'Value1'} |
| ]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.properties.length).toBe(5); |
| expect(feed.properties[0].key).toBe('queueName'); |
| expect(feed.properties[0].value).toBe('QueueName'); |
| }); |
| |
| it('Should leave the default properties if no properties appear on the xml and copy the new ones', function() { |
| var feedModel = { |
| feed: { |
| properties: { |
| property: [ |
| {_name: 'jobPriority', _value: 'MEDIUM'} |
| ] |
| } |
| } |
| }; |
| |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.properties.length).toBe(5); |
| |
| expect(feed.properties[0].key).toBe('queueName'); |
| expect(feed.properties[0].value).toBe('default'); |
| expect(feed.properties[1].key).toBe('jobPriority'); |
| expect(feed.properties[1].value).toBe('MEDIUM'); |
| }); |
| |
| it('Should copy file system locations', function() { |
| var feedModel = { |
| feed: { |
| locations: {location: [ |
| {_type: 'data', _path: '/none1'}, |
| {_type: 'stats', _path: '/none2'} |
| ]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| var locations = feed.storage.fileSystem.locations; |
| |
| expect(locations.length).toBe(2); |
| expect(locations[0].type).toBe('data'); |
| expect(locations[0].path).toBe('/none1'); |
| expect(locations[1].type).toBe('stats'); |
| expect(locations[1].path).toBe('/none2'); |
| }); |
| |
| it('Should not copy file system locations if they are not defined and keep the defaults', function() { |
| var feedModel = { |
| feed: { |
| dataTransferType: 'hdfs', |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.storage.fileSystem.locations).toBe(null); |
| }); |
| |
| it('Should not copy catalog uri if not present', function() { |
| var feedModel = { |
| feed: { |
| dataTransferType: 'hive', |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.storage.catalog.catalogTable.uri).toBe(null); |
| }); |
| |
| it('Should copy cluster name and type', function() { |
| var feedModel = { |
| feed: { |
| clusters: { |
| cluster: [{ |
| _name: 'ClusterOne', |
| _type: 'target' |
| }] |
| } |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.clusters.length).toBe(1); |
| expect(feed.clusters[0].name).toBe('ClusterOne'); |
| expect(feed.clusters[0].type).toBe('target'); |
| }); |
| |
| it('Should copy clusters and select the first source cluster', function() { |
| var feedModel = { |
| feed: { |
| clusters: { |
| cluster: [ |
| {_name: 'ClusterOne', _type: 'target'}, |
| {_name: 'ClusterTwo', _type: 'source'}, |
| {_name: 'ClusterThree', _type: 'target'}, |
| {_name: 'ClusterFour', _type: 'source'} |
| ] |
| } |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.clusters[0].selected).toBe(false); |
| expect(feed.clusters[1].selected).toBe(true); |
| expect(feed.clusters[2].selected).toBe(false); |
| expect(feed.clusters[3].selected).toBe(false); |
| |
| }); |
| |
| xit('Should copy validity', function() { |
| var feedModel = { |
| feed: { |
| clusters: {cluster: [{_name: 'ClusterOne', _type: 'target', |
| validity: { |
| _start: '2014-02-28T01:20Z', |
| _end: '2016-03-31T04:30Z' |
| } |
| }]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.clusters[0].validity.start.date).toEqual(new Date(2014, 2, 28,0,0)); |
| expect(feed.clusters[0].validity.start.time).toEqual(newUtcTime(1, 20)); |
| expect(feed.clusters[0].validity.end.date).toEqual(newUtcDate(2016, 3, 31)); |
| expect(feed.clusters[0].validity.end.time).toEqual(newUtcTime(4, 30)); |
| |
| }); |
| |
| it('Should copy retention', function() { |
| var feedModel = { |
| feed: { |
| clusters: {cluster: [{_name: 'ClusterOne', _type: 'target', |
| retention: { |
| _limit: 'weeks(4)', |
| _action: 'delete' |
| } |
| }]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.clusters[0].retention.quantity).toBe('4'); |
| expect(feed.clusters[0].retention.unit).toBe('weeks'); |
| expect(feed.clusters[0].retention.action).toBe('delete'); |
| }); |
| |
| it('Should copy clusters locations', function() { |
| var feedModel = { |
| feed: { |
| dataTransferType: 'hdfs', |
| clusters: {cluster: [{_name: 'ClusterOne', _type: 'target', |
| locations: { |
| location: [ |
| {_type: 'data', _path: '/path1'}, |
| {_type: 'stats', _path: '/path2'} |
| ]} |
| }]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| var locations = feed.clusters[0].storage.fileSystem.locations; |
| |
| expect(locations.length).toBe(2); |
| expect(locations[0].type).toBe('data'); |
| expect(locations[0].path).toBe('/path1'); |
| expect(locations[1].type).toBe('stats'); |
| expect(locations[1].path).toBe('/path2'); |
| }); |
| |
| it('filesystem should be inactive if there are no locations', function() { |
| var feedModel = { |
| feed: { |
| dataTransferType: 'hdfs', |
| clusters: {cluster: [{_name: 'ClusterOne', _type: 'target', |
| locations: { |
| location: []} |
| }]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| var locations = feed.clusters[0].storage.fileSystem.locations; |
| expect(locations.length).toBe(0); |
| }); |
| |
| it('Should copy catalog uri', function() { |
| var feedModel = { |
| feed: { |
| clusters: {cluster: [{_name: 'ClusterOne', _type: 'target', |
| table: { |
| _uri : 'table:uri' |
| } |
| }]} |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| var catalogStorage = feed.clusters[0].storage.catalog; |
| expect(catalogStorage.catalogTable.uri).toBe('table:uri'); |
| }); |
| |
| it('Should copy timezone', function() { |
| var feedModel = { |
| feed: { |
| timezone: 'GMT+03:50' |
| } |
| }; |
| |
| var feed = serializer.preDeserialize(feedModel, 'feed'); |
| |
| expect(feed.timezone).toBe('GMT+03:50'); |
| }); |
| |
| }); |
| |
| describe('serialize feed into xml', function() { |
| |
| it('Should transform the basic properties', function () { |
| var feed = { |
| name: 'FeedName', |
| description: 'Feed Description', |
| groups: 'a,b,c' |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName' description='Feed Description'>" + |
| "<groups>a,b,c</groups>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should transform tags properly', function () { |
| var feed = {name: 'FeedName', |
| tags: [{key: 'key1', value: 'value1'}, {key: 'key2', value: 'value2'}, {key: null, value: 'value3'}] |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<tags>key1=value1,key2=value2</tags>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| //it('Should transform ACL properly', function () { |
| // var feed = {name: 'FeedName', |
| // ACL: {owner: 'ambari-qa', group: 'users', permission: '0755'} |
| // }; |
| // |
| // var xml = serializer.serialize(feed, 'feed'); |
| // |
| // expect(xml).toBe( |
| // "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| // "<ACL owner='ambari-qa' group='users' permission='0755'/>" + |
| // "</feed>" |
| // ); |
| // |
| //}); |
| |
| it('Should add an ACL element even though the properties are empty', function () { |
| var feed = {name: 'FeedName', |
| ACL: {owner: null, group: null, permission: null} |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<ACL/>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should transform schema properly', function () { |
| var feed = {name: 'FeedName', |
| schema: {location: '/location', provider: 'none'} |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<schema location='/location' provider='none'/>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should add the schema element even though the properties are empty', function () { |
| var feed = {name: 'FeedName', |
| schema: {location: null, provider: null} |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<schema/>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should transform frequency properly', function () { |
| var feed = {name: 'FeedName', |
| frequency: {quantity: 4, unit: 'weeks'} |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<frequency>weeks(4)</frequency>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should transform late arrival properly when defined', function () { |
| var feed = {name: 'FeedName', |
| lateArrival: {active: true, cutOff: {quantity: 22, unit: 'hours'}} |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<late-arrival cut-off='hours(22)'/>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should not transform late arrival properly when quantity is not defined', function () { |
| var feed = {name: 'FeedName', |
| lateArrival: {active: false, cutOff: {quantity: null, unit: 'hours'}} |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'/>" |
| ); |
| |
| }); |
| |
| it('Should transform availability flag', function () { |
| var feed = {name: 'FeedName', |
| availabilityFlag: 'Available' |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<availabilityFlag>Available</availabilityFlag>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should transform timezone', function () { |
| var feed = {name: 'FeedName', |
| timezone: 'GMT+1:00' |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<timezone>GMT+1:00</timezone>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| //it('Should transform queueName, jobPriority and timeout and custom properties', function () { |
| // var feed = {name: 'FeedName', |
| // properties: [ |
| // {key: 'queueName', value: 'Queue'}, |
| // {key: 'jobPriority', value: 'HIGH'}, |
| // {key: 'timeout', value: {quantity: 7, unit: 'weeks'}} |
| // ], |
| // customProperties: [ |
| // {key: 'custom1', value: 'value1'}, |
| // {key: 'custom2', value: 'value2'} |
| // ] |
| // }; |
| // |
| // var xml = serializer.serialize(feed, 'feed'); |
| // |
| // expect(xml).toBe( |
| // "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| // "<properties>" + |
| // "<property name='queueName' value='Queue'></property>" + |
| // "<property name='jobPriority' value='HIGH'></property>" + |
| // "<property name='timeout' value='weeks(7)'></property>" + |
| // "<property name='custom1' value='value1'></property>" + |
| // "<property name='custom2' value='value2'></property>" + |
| // "</properties>" + |
| // "</feed>" |
| // ); |
| // |
| //}); |
| |
| it('Should transform not add queueName nor timeout if they were not defined', function () { |
| var feed = {name: 'FeedName', |
| properties: [ |
| {key: 'queueName', value: null}, |
| {key: 'jobPriority', value: 'HIGH'}, |
| {key: 'timeout', value: {quantity: 2, unit: 'months'}} |
| ] |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<properties>" + |
| "<property name='jobPriority' value='HIGH'></property>" + |
| "<property name='timeout' value='months(2)'></property>" + |
| "</properties>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should transform locations properly if file system storage is active', function () { |
| var feed = {name: 'FeedName', |
| dataTransferType: 'hdfs', |
| storage: { |
| fileSystem: { |
| active: true, |
| locations: [ |
| {type: 'data', path: '/none1'}, |
| {type: 'stats', path: '/none2'} |
| ] |
| } |
| } |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<locations>" + |
| "<location type='data' path='/none1'></location>" + |
| "<location type='stats' path='/none2'></location>" + |
| "</locations>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should not transform locations properly if file system storage is not active', function () { |
| var feed = {name: 'FeedName', |
| storage: { |
| fileSystem: { |
| active: false, |
| locations: [ |
| {type: 'data', path: '/none1'}, |
| {type: 'stats', path: '/none2'} |
| ] |
| } |
| } |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'/>" |
| ); |
| |
| }); |
| |
| it('Should transform catalog properly if catalog storage is active', function () { |
| var feed = {name: 'FeedName', |
| dataTransferType: 'hive', |
| storage: { |
| catalog: { |
| active: true, |
| catalogTable: {uri: '/none'} |
| } |
| } |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<table uri='/none'/>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| it('Should not transform catalog if catalog storage is not active', function () { |
| var feed = {name: 'FeedName', |
| storage: { |
| catalog: { |
| active: false, |
| catalogTable: {uri: '/none'} |
| } |
| } |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'/>" |
| ); |
| |
| }); |
| |
| xit('Should transform clusters', function () { |
| var feed = {name: 'FeedName', |
| storage: { |
| fileSystem: {active: true, locations: [ |
| {type: 'data', path: '/masterpath'} |
| ]}, |
| catalog: {active: true, catalogTable: {uri: '/masteruri'}} |
| }, |
| clusters: [ |
| { |
| name: 'primaryCluster', |
| type: 'source', |
| validity: {start: {date: newUtcDate(2014, 2, 28), time: newUtcTime(0,0)}, end: {date: newUtcDate(2016, 4, 1), time: newUtcTime(0,0)}}, |
| retention: {quantity: 2, unit: 'hours', action: 'delete'}, |
| storage: { |
| fileSystem: { |
| active: true, |
| locations: [ |
| {type: 'data', path: '/none1'}, |
| {type: 'stats', path: '/none2'} |
| ] |
| }, |
| catalog: { |
| active: false, |
| catalogTable: {uri: '/primaryuri'} |
| } |
| } |
| }, |
| { |
| name: 'secondaryCluster', |
| type: 'target', |
| validity: {start: {date: newUtcDate(2015, 2, 28), time: newUtcTime(0,0)}, end: {date: newUtcDate(2017, 4, 1), time: newUtcTime(0,0)}}, |
| retention: {quantity: 5, unit: 'weeks', action: 'archive'}, |
| storage: { |
| fileSystem: { |
| active: true, |
| locations: [ |
| {type: 'data', path: '/none4'}, |
| {type: 'stats', path: '/none5'} |
| ] |
| }, |
| catalog: { |
| active: true, |
| catalogTable: {uri: '/secondaryuri'} |
| } |
| } |
| } |
| ] |
| }; |
| |
| var xml = serializer.serialize(feed, 'feed'); |
| |
| expect(xml).toBe( |
| "<feed xmlns='uri:falcon:feed:0.1' name='FeedName'>" + |
| "<clusters>" + |
| "<cluster name='primaryCluster' type='source'>" + |
| "<validity start='2014-02-28T00:00Z' end='2016-04-01T00:00Z'/>" + |
| "<retention limit='hours(2)' action='delete'/>" + |
| "<locations>" + |
| "<location type='data' path='/none1'></location>" + |
| "<location type='stats' path='/none2'></location>" + |
| "</locations>" + |
| "<table uri='/primaryuri'/>" + |
| "</cluster>" + |
| "<cluster name='secondaryCluster' type='target'>" + |
| "<validity start='2015-02-28T00:00Z' end='2017-04-01T00:00Z'/>" + |
| "<retention limit='weeks(5)' action='archive'/>" + |
| "<locations>" + |
| "<location type='data' path='/none4'></location>" + |
| "<location type='stats' path='/none5'></location>" + |
| "</locations>" + |
| "<table uri='/secondaryuri'/>" + |
| "</cluster>" + |
| "</clusters>" + |
| "<locations>" + |
| "<location type='data' path='/masterpath'></location>" + |
| "</locations>" + |
| "<table uri='/masteruri'/>" + |
| "</feed>" |
| ); |
| |
| }); |
| |
| }); |
| |
| describe('deserialize process', function() { |
| |
| it('Should copy the general information', function() { |
| |
| var processModel = { |
| process: { |
| _xmlns: "uri:falcon:process:0.1", |
| _name: 'ProcessName' |
| } |
| }; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.name).toBe(processModel.process._name); |
| expect(process.xmlns).toBe(undefined); |
| }); |
| |
| it('Should copy tags', function() { |
| |
| var processModel = { |
| process: { |
| tags: 'owner=USMarketing,classification=Secure' |
| } |
| }; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.tags[0].key).toBe('owner'); |
| expect(process.tags[0].value).toBe('USMarketing'); |
| expect(process.tags[1].key).toBe('classification'); |
| expect(process.tags[1].value).toBe('Secure'); |
| }); |
| |
| it('Should copy workflow', function() { |
| |
| var processModel = { |
| process: {_xmlns: "uri:falcon:process:0.1", _name: 'ProcessName', |
| workflow: { |
| _name: 'emailCleanseWorkflow', |
| _version: '5.0', |
| _engine: 'pig', |
| _path: '/user/ambari-qa/falcon/demo/apps/pig/id.pig' |
| } |
| } |
| }; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.workflow.name).toBe(processModel.process.workflow._name); |
| expect(process.workflow.version).toBe(processModel.process.workflow._version); |
| expect(process.workflow.engine).toBe(processModel.process.workflow._engine); |
| expect(process.workflow.path).toBe(processModel.process.workflow._path); |
| |
| }); |
| |
| it('Should copy timezone', function() { |
| |
| var processModel = { |
| process: {_xmlns: "uri:falcon:process:0.1", _name: 'ProcessName', |
| timezone: 'GMT+1:00' |
| } |
| }; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.timezone).toBe(processModel.process.timezone); |
| }); |
| |
| it('Should copy frequency', function() { |
| var processModel = {process: { |
| frequency: 'hours(20)' |
| }}; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.frequency.unit).toBe('hours'); |
| expect(process.frequency.quantity).toBe('20'); |
| |
| }); |
| |
| it('Should copy parallel', function() { |
| var processModel = { process: { |
| parallel: 3 |
| }}; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.parallel).toBe(processModel.process.parallel); |
| |
| }); |
| |
| it('Should copy order', function() { |
| var processModel = { process: { |
| order: 'LIFO' |
| }}; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.order).toBe(processModel.process.order); |
| |
| }); |
| |
| it('Should copy retry', function() { |
| var processModel = { process: { |
| retry: { |
| _policy: 'periodic', _attempts: '3', _delay: 'minutes(15)' |
| } |
| }}; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.retry.policy).toBe(processModel.process.retry._policy); |
| expect(process.retry.attempts).toBe(processModel.process.retry._attempts); |
| expect(process.retry.delay.quantity).toBe('15'); |
| expect(process.retry.delay.unit).toBe('minutes'); |
| |
| }); |
| |
| xit('Should copy clusters', function() { |
| var processModel = { |
| process: { |
| clusters: {cluster: [{_name: 'ClusterOne', |
| validity: { |
| _start: '2014-02-28T01:20Z', |
| _end: '2016-03-31T04:30Z' |
| } |
| }]} |
| } |
| }; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.clusters[0].validity.start.date).toEqual(newUtcDate(2014, 2, 28)); |
| expect(process.clusters[0].validity.start.time).toEqual(newUtcTime(1, 20)); |
| expect(process.clusters[0].validity.end.date).toEqual(newUtcDate(2016, 3, 31)); |
| expect(process.clusters[0].validity.end.time).toEqual(newUtcTime(4, 30)); |
| |
| }); |
| |
| it('Should copy inputs', function() { |
| var processModel = { |
| process: { |
| inputs: {input: [ |
| {_name: 'input', _feed: 'rawEmailFeed', _start: 'now(0,0)', _end: 'now(0,0)' } |
| ]} |
| } |
| }; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.inputs[0].name).toEqual('input'); |
| expect(process.inputs[0].feed).toEqual('rawEmailFeed'); |
| expect(process.inputs[0].start).toEqual('now(0,0)'); |
| expect(process.inputs[0].end).toEqual('now(0,0)'); |
| }); |
| |
| it('Should copy outputs', function() { |
| var processModel = { |
| process: { |
| outputs: {output: [ |
| {_name: 'output', _feed: 'cleansedEmailFeed', _instance: 'now(0,0)' } |
| ]} |
| } |
| }; |
| |
| var process = serializer.preDeserialize(processModel, 'process'); |
| |
| expect(process.outputs[0].name).toEqual('output'); |
| expect(process.outputs[0].feed).toEqual('cleansedEmailFeed'); |
| expect(process.outputs[0].outputInstance).toEqual('now(0,0)'); |
| }); |
| |
| }); |
| |
| describe('serialize process into xml', function() { |
| |
| it('Should transform the basic properties', function () { |
| var process = { |
| name: 'ProcessName' |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'/>" |
| ); |
| }); |
| |
| it('Should transform tags properly', function () { |
| var process = {name: 'ProcessName', |
| tags: [{key: 'key1', value: 'value1'}, {key: 'key2', value: 'value2'}, {key: null, value: 'value3'}] |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<tags>key1=value1,key2=value2</tags>" + |
| "</process>" |
| ); |
| }); |
| |
| it('Should transform workflow properly', function () { |
| var process = {name: 'ProcessName', |
| workflow: { |
| name: 'emailCleanseWorkflow', |
| engine: 'pig', |
| version: '5.0', |
| path: '/user/ambari-qa/falcon/demo/apps/pig/id.pig' |
| } |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<workflow name='emailCleanseWorkflow' version='5.0' engine='pig' path='/user/ambari-qa/falcon/demo/apps/pig/id.pig'/>" + |
| "</process>" |
| ); |
| }); |
| |
| it('Should transform timezone', function () { |
| var process = {name: 'ProcessName', |
| timezone: 'GMT+1:00' |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<timezone>GMT+1:00</timezone>" + |
| "</process>" |
| ); |
| |
| }); |
| |
| it('Should transform frequency properly', function () { |
| var process = {name: 'ProcessName', |
| frequency: {quantity: 4, unit: 'weeks'} |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<frequency>weeks(4)</frequency>" + |
| "</process>" |
| ); |
| |
| }); |
| |
| it('Should transform parallel properly', function () { |
| var process = {name: 'ProcessName', |
| parallel: 11 |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<parallel>11</parallel>" + |
| "</process>" |
| ); |
| |
| }); |
| |
| it('Should transform order properly', function () { |
| var process = {name: 'ProcessName', |
| order: 'LIFO' |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<order>LIFO</order>" + |
| "</process>" |
| ); |
| |
| }); |
| |
| it('Should transform retry properly', function () { |
| var process = {name: 'ProcessName', |
| retry: { |
| policy: 'periodic', |
| delay: {quantity: 15, unit: 'minutes'}, |
| attempts: 3 |
| } |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<retry policy='periodic' delay='minutes(15)' attempts='3'/>" + |
| "</process>" |
| ); |
| }); |
| |
| xit('Should transform clusters', function () { |
| |
| var process = {name: 'ProcessName', |
| clusters: [ |
| { |
| name: 'primaryCluster', |
| validity: {start: {date: newUtcDate(2014, 2, 28), time: newUtcTime(0,0)}, end: {date: newUtcDate(2016, 4, 1), time: newUtcTime(0,0)}} |
| }, |
| { |
| name: 'secondaryCluster', |
| validity: {start: {date: newUtcDate(2015, 2, 28), time: newUtcTime(0,0)}, end: {date: newUtcDate(2017, 4, 1), time: newUtcTime(0,0)}} |
| } |
| ] |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<clusters>" + |
| "<cluster name='primaryCluster'>" + |
| "<validity start='2014-02-28T00:00Z' end='2016-04-01T00:00Z'/>" + |
| "</cluster>" + |
| "<cluster name='secondaryCluster'>" + |
| "<validity start='2015-02-28T00:00Z' end='2017-04-01T00:00Z'/>" + |
| "</cluster>" + |
| "</clusters>" + |
| "</process>" |
| ); |
| |
| }); |
| |
| it('Should transform inputs', function () { |
| |
| var process = {name: 'ProcessName', |
| inputs: [ |
| { name: 'input', feed: 'rawEmailFeed', start: 'now(0,0)', end: 'now(0,0)' } |
| ] |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<inputs>" + |
| "<input name='input' feed='rawEmailFeed' start='now(0,0)' end='now(0,0)'>" + |
| "</input>" + |
| "</inputs>" + |
| "</process>" |
| ); |
| |
| }); |
| |
| it('Should transform outputs', function () { |
| |
| var process = {name: 'ProcessName', |
| outputs: [ |
| { name: 'output', feed: 'cleansedEmailFeed', outputInstance: 'now(0,0)'} |
| ] |
| }; |
| |
| var xml = serializer.serialize(process, 'process'); |
| |
| expect(xml).toBe( |
| "<process xmlns='uri:falcon:process:0.1' name='ProcessName'>" + |
| "<outputs>" + |
| "<output name='output' feed='cleansedEmailFeed' instance='now(0,0)'>" + |
| "</output>" + |
| "</outputs>" + |
| "</process>" |
| ); |
| |
| }); |
| |
| }); |
| |
| function newUtcDate(year, month, day) { |
| return new Date(Date.UTC(year, month, day)) |
| } |
| |
| function newUtcTime(hours, minutes) { |
| return new Date(Date.UTC(1900, 1, 1, hours, minutes, 0)); |
| } |
| |
| }); |
| })(); |
