oa-jira
Version:
Octet Agile's JIRA connectivity project.
241 lines (205 loc) • 9.57 kB
JavaScript
const Change = require('../../../../src/model/classes/change.class');
describe('Check [Change] class.', () => {
const mockSrcToJson = { toJSON: () => 'SOURCE TO JSON' };
const mockTgtToJson = { toJSON: () => 'TARGET TO JSON' };
const cases = {
nominal: [
[{ name: ' complexity ', source: 'source', target: 'target' }],
[{ name: ' summary ', target: 'target' }],
[{ name: ' updated ', source: 'source' }]
],
invalid: [
['A [name] is mandatory and cannot be falsy.', { source: 'a' }],
['A [name] MUST be a [string].', { name: 2, source: 'a' }],
['A [name] equals to [prohibited] is prohibited.', { name: ' prohibited ', source: 'a' }]
]
};
describe('Check constructor.', () => {
it('should reject error when given nothing.', () => {
expect(() => new Change()).toThrow();
});
it.each(cases.nominal)('should resolve a new instance when init with [%p]', given => {
expect(new Change(given)).toBeInstanceOf(Change);
});
it.each(cases.invalid)('should reject [%p] when create from [%p]', (error, given) => {
expect(() => new Change(given)).toThrow(error);
});
});
describe('Check getters.', () => {
describe('Check [name] getter.', () => {
it.each(cases.nominal)('should return the given trimmed name when init with [%p]', given => {
expect(new Change(given).getName()).toBe(given.name.trim());
});
});
describe('Check [source] getter.', () => {
it.each(cases.nominal)('should return the given source when init with [%p]', given => {
expect(new Change(given).getSource()).toBe(given.source);
});
});
describe('Check [target] getter.', () => {
it.each(cases.nominal)('should return the given target when init with [%p]', given => {
expect(new Change(given).getTarget()).toBe(given.target);
});
});
});
describe('Check utilities.', () => {
describe('Check [to string] utility.', () => {
it.each(cases.nominal)('should return expected string representation when init with [%p]', given => {
expect(`${new Change(given)}`).toEqual(`Change[${given.name.trim()} : ${given.source} ==> ${given.target}]`);
});
});
describe('Check [to JSON] utility.', () => {
it.each([['project'], ['resolution'], ['sprint'], ['status'], ['type']])(
'should return toJson result when change name is [%p] when unit flag is missing',
given => {
expect(new Change({ name: given, source: mockSrcToJson, target: mockTgtToJson }).toJSON()).toEqual({
name: given,
source: 'SOURCE TO JSON',
target: 'TARGET TO JSON'
});
}
);
it.each([['project'], ['resolution'], ['sprint'], ['status'], ['type']])(
'should return toJson result when change name is [%p] when unit flag is set to true',
given => {
expect(
new Change({ name: given, source: mockSrcToJson, target: mockTgtToJson }).toJSON({ unit: true })
).toEqual({
name: given,
source: 'SOURCE TO JSON',
target: 'TARGET TO JSON'
});
}
);
it.each([['project'], ['resolution'], ['sprint'], ['status'], ['type']])(
'should return toJson result when change name is [%p] when unit flag is set to false',
given => {
expect(
new Change({ name: given, source: mockSrcToJson, target: mockTgtToJson }).toJSON({ unit: false })
).toEqual({ source: 'SOURCE TO JSON', target: 'TARGET TO JSON' });
}
);
it('should return array of toJson result when change name is [versions] when unit flag is missing', () => {
expect(
new Change({
name: 'versions',
source: [mockSrcToJson, mockTgtToJson],
target: [mockTgtToJson, mockSrcToJson]
}).toJSON()
).toEqual({
name: 'versions',
source: ['SOURCE TO JSON', 'TARGET TO JSON'],
target: ['TARGET TO JSON', 'SOURCE TO JSON']
});
});
it('should return array of toJson result when change name is [versions] when unit flag is set to true', () => {
expect(
new Change({
name: 'versions',
source: [mockSrcToJson, mockTgtToJson],
target: [mockTgtToJson, mockSrcToJson]
}).toJSON({ unit: true })
).toEqual({
name: 'versions',
source: ['SOURCE TO JSON', 'TARGET TO JSON'],
target: ['TARGET TO JSON', 'SOURCE TO JSON']
});
});
it('should return array of toJson result when change name is [versions] when unit flag is set to false', () => {
expect(
new Change({
name: 'versions',
source: [mockSrcToJson, mockTgtToJson],
target: [mockTgtToJson, mockSrcToJson]
}).toJSON({ unit: false })
).toEqual({ source: ['SOURCE TO JSON', 'TARGET TO JSON'], target: ['TARGET TO JSON', 'SOURCE TO JSON'] });
});
});
});
describe('Check static utilities.', () => {
describe('Check [create] static utility.', () => {
it('should resolve undefined when nothing is given.', () => {
expect(Change.create()).resolves.toBeUndefined();
});
it('should resolve undefined when source & target are falsy.', () => {
expect(Change.create({ name: 'complexity' })).resolves.toBeUndefined();
});
it.each(cases.invalid)('should reject [%p] when create from [%p]', (expected, given) => {
expect(Change.create(given)).rejects.toThrow(expected);
});
it.each(cases.nominal)('should resolve new instance when given is [%p].', async given => {
expect((await Change.create(given)).toJSON()).toEqual(new Change(given).toJSON());
});
});
describe('Check [check] static utility.', () => {
it('should throw when given is falsy.', () => {
expect(() => Change.check()).toThrow('A [change] is mandatory and cannot be falsy.');
});
it('should throw when given does not implements expected class.', () => {
expect(() => Change.check(2)).toThrow('A [change] MUST implements [Change].');
});
it.each(cases.nominal)('should return given when given is initialised with [%p].', given => {
const instance = new Change(given);
expect(Change.check(instance)).toBe(instance);
});
});
describe('Check [resolve] static utility.', () => {
it('should reject when given is falsy.', () => {
expect(Change.resolve()).rejects.toThrow('A [change] is mandatory and cannot be falsy.');
});
it('should reject when given does not implements expected class.', () => {
expect(Change.resolve(2)).rejects.toThrow('A [change] MUST implements [Change].');
});
it.each(cases.nominal)('should resolve given when given is initialised with [%p].', given => {
const instance = new Change(given);
expect(Change.resolve(instance)).resolves.toBe(instance);
});
});
describe('Check [check bulk] static utility.', () => {
it('should throw when given is missing.', () => {
expect(() => Change.checkBulk()).toThrow('A [bulk of changes] MUST be a [array].');
});
it('should throw when given is not an array.', () => {
expect(() => Change.checkBulk('Kaboom !')).toThrow('A [bulk of changes] MUST be a [array].');
});
it('should reject when given is an array wich contains invalid.', () => {
expect(() => Change.checkBulk([2])).toThrow('A [change] MUST implements [Change].');
});
it('should resolve given when given is an array of changes.', () => {
const changes = [
new Change({
name: 'versions',
source: [mockSrcToJson, mockTgtToJson],
target: [mockTgtToJson, mockSrcToJson]
}),
new Change({ name: 'complexity', source: 3, target: 8 }),
new Change({ name: 'project', source: mockSrcToJson, target: mockTgtToJson })
];
expect(Change.checkBulk(changes)).toEqual(changes);
});
});
describe('Check [resolve bulk] static utility.', () => {
it('should reject when given is missing.', () => {
expect(Change.resolveBulk()).rejects.toThrow('A [bulk of changes] MUST be a [array].');
});
it('should reject when given is not an array.', () => {
expect(Change.resolveBulk('Kaboom !')).rejects.toThrow('A [bulk of changes] MUST be a [array].');
});
it('should reject when given is an array wich contains invalid.', () => {
expect(Change.resolveBulk([2])).rejects.toThrow('A [change] MUST implements [Change].');
});
it('should resolve given when given is an array of changes.', () => {
const changes = [
new Change({
name: 'versions',
source: [mockSrcToJson, mockTgtToJson],
target: [mockTgtToJson, mockSrcToJson]
}),
new Change({ name: 'complexity', source: 3, target: 8 }),
new Change({ name: 'project', source: mockSrcToJson, target: mockTgtToJson })
];
expect(Change.resolveBulk(changes)).resolves.toEqual(changes);
});
});
});
});