Skip to content

Commit 48f6aed

Browse files
sanex3339sanex3339
committed
tests refactoring: templates tests
1 parent 3e97d2a commit 48f6aed

File tree

2 files changed

+115
-69
lines changed

2 files changed

+115
-69
lines changed

‎test/functional-tests/templates/custom-nodes/domain-lock-nodes/DomainLockNodeTemplate.spec.ts

Lines changed: 72 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ import { CryptUtils } from '../../../../../src/utils/CryptUtils';
1313
* @returns {Function}
1414
*/
1515
function getFunctionFromTemplate (templateData: any, callsControllerFunctionName: string, currentDomain: string) {
16-
let domainLockTemplate: string = format(DomainLockNodeTemplate(), templateData);
16+
const domainLockTemplate: string = format(DomainLockNodeTemplate(), templateData);
1717

1818
return Function(`
1919
document = {
@@ -33,57 +33,80 @@ function getFunctionFromTemplate (templateData: any, callsControllerFunctionName
3333
}
3434

3535
describe('DomainLockNodeTemplate (): string', () => {
36-
let domainsString: string,
37-
currentDomain: string,
38-
hiddenDomainsString: string,
39-
diff: string,
40-
singleNodeCallControllerFunctionName: string = 'callsController';
41-
42-
it('should correctly runs code inside template if current domain matches with `domainsString`', () => {
43-
domainsString = ['www.example.com'].join(';');
44-
currentDomain = 'www.example.com';
45-
[
46-
hiddenDomainsString,
47-
diff
48-
] = CryptUtils.hideString(domainsString, domainsString.length * 3);
49-
50-
assert.doesNotThrow(() => getFunctionFromTemplate({
51-
domainLockFunctionName: 'domainLockFunction',
52-
diff: diff,
53-
domains: hiddenDomainsString,
54-
singleNodeCallControllerFunctionName
55-
}, singleNodeCallControllerFunctionName, currentDomain));
36+
const singleNodeCallControllerFunctionName: string = 'callsController';
37+
38+
describe('variant #1: current domain matches with `domainsString`', () => {
39+
const domainsString: string = ['www.example.com'].join(';');
40+
const currentDomain: string = 'www.example.com';
41+
42+
let testFunc: () => void;
43+
44+
before(() => {
45+
const [
46+
hiddenDomainsString,
47+
diff
48+
] = CryptUtils.hideString(domainsString, domainsString.length * 3);
49+
50+
testFunc = () => getFunctionFromTemplate({
51+
domainLockFunctionName: 'domainLockFunction',
52+
diff: diff,
53+
domains: hiddenDomainsString,
54+
singleNodeCallControllerFunctionName
55+
}, singleNodeCallControllerFunctionName, currentDomain);
56+
});
57+
58+
it('should correctly runs code inside template', () => {
59+
assert.doesNotThrow(testFunc);
60+
});
5661
});
5762

58-
it('should correctly runs code inside template if current domain matches with base domain of `domainsString` item', () => {
59-
domainsString = ['www.test.com', '.example.com'].join(';');
60-
currentDomain = 'subdomain.example.com';
61-
[
62-
hiddenDomainsString,
63-
diff
64-
] = CryptUtils.hideString(domainsString, domainsString.length * 3);
65-
66-
assert.doesNotThrow(() => getFunctionFromTemplate({
67-
domainLockFunctionName: 'domainLockFunction',
68-
diff: diff,
69-
domains: hiddenDomainsString,
70-
singleNodeCallControllerFunctionName
71-
}, singleNodeCallControllerFunctionName, currentDomain));
63+
describe('variant #2: urrent domain matches with base domain of `domainsString` item', () => {
64+
const domainsString: string = ['www.test.com', '.example.com'].join(';');
65+
const currentDomain: string = 'subdomain.example.com';
66+
67+
let testFunc: () => void;
68+
69+
before(() => {
70+
const [
71+
hiddenDomainsString,
72+
diff
73+
] = CryptUtils.hideString(domainsString, domainsString.length * 3);
74+
75+
testFunc = () => getFunctionFromTemplate({
76+
domainLockFunctionName: 'domainLockFunction',
77+
diff: diff,
78+
domains: hiddenDomainsString,
79+
singleNodeCallControllerFunctionName
80+
}, singleNodeCallControllerFunctionName, currentDomain);
81+
});
82+
83+
it('should correctly runs code inside template', () => {
84+
assert.doesNotThrow(testFunc);
85+
});
7286
});
7387

74-
it('should throw an error if current domain doesn\'t match with `domainsString`', () => {
75-
domainsString = ['www.example.com'].join(';');
76-
currentDomain = 'www.test.com';
77-
[
78-
hiddenDomainsString,
79-
diff
80-
] = CryptUtils.hideString(domainsString, domainsString.length * 3);
81-
82-
assert.throws(() => getFunctionFromTemplate({
83-
domainLockFunctionName: 'domainLockFunction',
84-
diff: diff,
85-
domains: hiddenDomainsString,
86-
singleNodeCallControllerFunctionName
87-
}, singleNodeCallControllerFunctionName, currentDomain));
88+
describe('variant #3: current domain doesn\'t match with `domainsString`', () => {
89+
const domainsString: string = ['www.example.com'].join(';');
90+
const currentDomain: string = 'www.test.com';
91+
92+
let testFunc: () => void;
93+
94+
before(() => {
95+
const [
96+
hiddenDomainsString,
97+
diff
98+
] = CryptUtils.hideString(domainsString, domainsString.length * 3);
99+
100+
testFunc = () => getFunctionFromTemplate({
101+
domainLockFunctionName: 'domainLockFunction',
102+
diff: diff,
103+
domains: hiddenDomainsString,
104+
singleNodeCallControllerFunctionName
105+
}, singleNodeCallControllerFunctionName, currentDomain);
106+
});
107+
108+
it('should throw an error', () => {
109+
assert.throws(testFunc);
110+
});
88111
});
89112
});

‎test/functional-tests/templates/custom-nodes/string-array-nodes/StringArrayCallsWrapperNodeTemplate.spec.ts

Lines changed: 43 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ function getFunctionFromTemplateBase64Encoding (
2323
stringArrayCallsWrapperName: string,
2424
index: string
2525
) {
26-
let stringArrayCallsWrapperTemplate: string = format(StringArrayCallsWrapperTemplate(), templateData);
26+
const stringArrayCallsWrapperTemplate: string = format(StringArrayCallsWrapperTemplate(), templateData);
2727

2828
return Function(`
2929
var ${stringArrayName} = ['${CryptUtils.btoa('test1')}'];
@@ -49,7 +49,7 @@ function getFunctionFromTemplateRc4Encoding (
4949
index: string,
5050
key: string
5151
) {
52-
let stringArrayCallsWrapperTemplate: string = format(StringArrayCallsWrapperTemplate(), templateData);
52+
const stringArrayCallsWrapperTemplate: string = format(StringArrayCallsWrapperTemplate(), templateData);
5353

5454
return Function(`
5555
var ${stringArrayName} = ['${CryptUtils.btoa(CryptUtils.rc4('test1', key))}'];
@@ -61,33 +61,56 @@ function getFunctionFromTemplateRc4Encoding (
6161
}
6262

6363
describe('StringArrayCallsWrapperNodeTemplate (): string', () => {
64-
let stringArrayName: string = 'stringArrayName',
65-
stringArrayCallsWrapperName: string = 'stringArrayCallsWrapperName',
66-
atobDecodeNodeTemplate: string = format(StringArrayBase64DecodeNodeTemplate(), {
64+
const stringArrayName: string = 'stringArrayName';
65+
const stringArrayCallsWrapperName: string = 'stringArrayCallsWrapperName';
66+
67+
describe('variant #1: `base64` encoding', () => {
68+
const atobDecodeNodeTemplate: string = format(StringArrayBase64DecodeNodeTemplate(), {
6769
atobPolyfill: AtobTemplate(),
6870
selfDefendingCode: '',
6971
stringArrayCallsWrapperName
70-
}),
71-
rc4DecodeNodeTemplate: string = format(StringArrayRc4DecodeNodeTemplate(), {
72+
});
73+
const index: string = '0x0';
74+
const expectedDecodedValue: string = 'test1';
75+
76+
let decodedValue: string;
77+
78+
before(() => {
79+
decodedValue = getFunctionFromTemplateBase64Encoding({
80+
decodeNodeTemplate: atobDecodeNodeTemplate,
81+
stringArrayCallsWrapperName,
82+
stringArrayName
83+
}, stringArrayName, stringArrayCallsWrapperName, index);
84+
});
85+
86+
it('should correctly return decoded value', () => {
87+
assert.deepEqual(decodedValue, expectedDecodedValue);
88+
});
89+
});
90+
91+
describe('variant #2: `rc4` encoding', () => {
92+
const rc4DecodeNodeTemplate: string = format(StringArrayRc4DecodeNodeTemplate(), {
7293
atobPolyfill: AtobTemplate(),
7394
rc4Polyfill: Rc4Template(),
7495
selfDefendingCode: '',
7596
stringArrayCallsWrapperName
7697
});
98+
const index: string = '0x0';
99+
const key: string = 'key';
100+
const expectedDecodedValue: string = 'test1';
77101

78-
it('should correctly returns decoded value with base64 encoding', () => {
79-
assert.deepEqual(getFunctionFromTemplateBase64Encoding({
80-
decodeNodeTemplate: atobDecodeNodeTemplate,
81-
stringArrayCallsWrapperName,
82-
stringArrayName
83-
}, stringArrayName, stringArrayCallsWrapperName, '0x0'), 'test1');
84-
});
102+
let decodedValue: string;
85103

86-
it('should correctly returns decoded value with rc4 encoding', () => {
87-
assert.deepEqual(getFunctionFromTemplateRc4Encoding({
88-
decodeNodeTemplate: rc4DecodeNodeTemplate,
89-
stringArrayCallsWrapperName,
90-
stringArrayName
91-
}, stringArrayName, stringArrayCallsWrapperName, '0x0', 'key'), 'test1');
104+
before(() => {
105+
decodedValue = getFunctionFromTemplateRc4Encoding({
106+
decodeNodeTemplate: rc4DecodeNodeTemplate,
107+
stringArrayCallsWrapperName,
108+
stringArrayName
109+
}, stringArrayName, stringArrayCallsWrapperName, index, key);
110+
});
111+
112+
it('should correctly return decoded value', () => {
113+
assert.deepEqual(decodedValue, expectedDecodedValue);
114+
});
92115
});
93116
});

0 commit comments

Comments
 (0)