1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
import { AWScreenUtils } from "lib/AWScreenUtils.jsm";
import { GlobalOverrider } from "test/unit/utils";
import { ASRouter } from "lib/ASRouter.jsm";
describe("AWScreenUtils", () => {
let sandbox;
let globals;
beforeEach(() => {
globals = new GlobalOverrider();
globals.set({
ASRouter,
ASRouterTargeting: {
Environment: {},
},
});
sandbox = sinon.createSandbox();
});
afterEach(() => {
sandbox.restore();
globals.restore();
});
describe("removeScreens", () => {
it("should run callback function once for each array element", async () => {
const callback = sandbox.stub().resolves(false);
const arr = ["foo", "bar"];
await AWScreenUtils.removeScreens(arr, callback);
assert.calledTwice(callback);
});
it("should remove screen when passed function evaluates true", async () => {
const callback = sandbox.stub().resolves(true);
const arr = ["foo", "bar"];
await AWScreenUtils.removeScreens(arr, callback);
assert.deepEqual(arr, []);
});
});
describe("evaluateScreenTargeting", () => {
it("should return the eval result if the eval succeeds", async () => {
const evalStub = sandbox.stub(ASRouter, "evaluateExpression").resolves({
evaluationStatus: {
success: true,
result: false,
},
});
const result = await AWScreenUtils.evaluateScreenTargeting(
"test expression"
);
assert.calledOnce(evalStub);
assert.equal(result, false);
});
it("should return true if the targeting eval fails", async () => {
const evalStub = sandbox.stub(ASRouter, "evaluateExpression").resolves({
evaluationStatus: {
success: false,
result: false,
},
});
const result = await AWScreenUtils.evaluateScreenTargeting(
"test expression"
);
assert.calledOnce(evalStub);
assert.equal(result, true);
});
});
describe("evaluateTargetingAndRemoveScreens", () => {
it("should manipulate an array of screens", async () => {
const screens = [
{
id: "first",
targeting: true,
},
{
id: "second",
targeting: false,
},
];
const expectedScreens = [
{
id: "first",
targeting: true,
},
];
sandbox.stub(ASRouter, "evaluateExpression").callsFake(targeting => {
return {
evaluationStatus: {
success: true,
result: targeting.expression,
},
};
});
const evaluatedStrings =
await AWScreenUtils.evaluateTargetingAndRemoveScreens(screens);
assert.deepEqual(evaluatedStrings, expectedScreens);
});
it("should not remove screens with no targeting", async () => {
const screens = [
{
id: "first",
},
{
id: "second",
targeting: false,
},
];
const expectedScreens = [
{
id: "first",
},
];
sandbox
.stub(AWScreenUtils, "evaluateScreenTargeting")
.callsFake(targeting => {
if (targeting === undefined) {
return true;
}
return targeting;
});
const evaluatedStrings =
await AWScreenUtils.evaluateTargetingAndRemoveScreens(screens);
assert.deepEqual(evaluatedStrings, expectedScreens);
});
});
describe("addScreenImpression", () => {
it("Should call addScreenImpression with provided screen ID", () => {
const addScreenImpressionStub = sandbox.stub(
ASRouter,
"addScreenImpression"
);
const testScreen = { id: "test" };
AWScreenUtils.addScreenImpression(testScreen);
assert.calledOnce(addScreenImpressionStub);
assert.equal(addScreenImpressionStub.firstCall.args[0].id, testScreen.id);
});
});
});
|
