Skip to content

Commit c8a522d

Browse files
ashleysmithTTDashleysmithTTD
authored
Merge pull request #111 from IABTechLab/ans-UID2-4273-euid-phone-number
Move phone number cstg functions to work for uid2 and euid
2 parents e862d48 + 2fec19c commit c8a522d

File tree

7 files changed

+222
-84
lines changed

7 files changed

+222
-84
lines changed

‎src/integrationTests/basic.test.ts‎

Lines changed: 28 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1048,6 +1048,8 @@ describe('SDK bootstraps itself if init has already been completed', () => {
10481048
const makeIdentity = mocks.makeIdentityV2;
10491049
const email = 'test@test.com';
10501050
const emailHash = 'lz3+Rj7IV4X1+Vr1ujkG7tstkxwk5pgkqJ6mXbpOgTs=';
1051+
const phone = '+12345678901';
1052+
const phoneHash = 'EObwtHBUqDNZR33LNSMdtt5cafsYFuGmuY4ZLenlue4=';
10511053

10521054
beforeEach(() => {
10531055
sdkWindow.__uid2 = new UID2();
@@ -1066,10 +1068,16 @@ describe('SDK bootstraps itself if init has already been completed', () => {
10661068
expect(uid2.getAdvertisingToken()).toBe(identity.advertising_token);
10671069
expect(uid2.getIdentity()).toStrictEqual(identity);
10681070
expect(async () => {
1069-
await uid2.setIdentityFromEmail(email, mocks.makeCstgOption());
1071+
await uid2.setIdentityFromEmail(email, mocks.makeUid2CstgOption());
10701072
}).not.toThrow();
10711073
expect(async () => {
1072-
uid2.setIdentityFromEmailHash(emailHash, mocks.makeCstgOption());
1074+
uid2.setIdentityFromEmailHash(emailHash, mocks.makeUid2CstgOption());
1075+
}).not.toThrow();
1076+
expect(async () => {
1077+
await uid2.setIdentityFromPhone(phone, mocks.makeUid2CstgOption());
1078+
}).not.toThrow();
1079+
expect(async () => {
1080+
uid2.setIdentityFromPhoneHash(phoneHash, mocks.makeUid2CstgOption());
10731081
}).not.toThrow();
10741082
});
10751083

@@ -1078,10 +1086,16 @@ describe('SDK bootstraps itself if init has already been completed', () => {
10781086
expect(uid2.getAdvertisingToken()).toBe(undefined);
10791087
expect(uid2.getIdentity()).toStrictEqual(null);
10801088
expect(async () => {
1081-
await uid2.setIdentityFromEmail(email, mocks.makeCstgOption());
1089+
await uid2.setIdentityFromEmail(email, mocks.makeUid2CstgOption());
1090+
}).rejects.toThrow();
1091+
expect(async () => {
1092+
await uid2.setIdentityFromEmailHash(emailHash, mocks.makeUid2CstgOption());
10821093
}).rejects.toThrow();
10831094
expect(async () => {
1084-
await uid2.setIdentityFromEmailHash(emailHash, mocks.makeCstgOption());
1095+
await uid2.setIdentityFromPhone(phone, mocks.makeUid2CstgOption());
1096+
}).rejects.toThrow();
1097+
expect(async () => {
1098+
await uid2.setIdentityFromPhoneHash(phoneHash, mocks.makeUid2CstgOption());
10851099
}).rejects.toThrow();
10861100
});
10871101
});
@@ -1090,6 +1104,8 @@ describe('Token retrieval and related public functions working without init', ()
10901104
const makeIdentity = mocks.makeIdentityV2;
10911105
const email = 'test@test.com';
10921106
const emailHash = 'lz3+Rj7IV4X1+Vr1ujkG7tstkxwk5pgkqJ6mXbpOgTs=';
1107+
const phone = '+12345678901';
1108+
const phoneHash = 'EObwtHBUqDNZR33LNSMdtt5cafsYFuGmuY4ZLenlue4=';
10931109

10941110
test('should be able to find identity set without init', async () => {
10951111
const identity = { ...makeIdentity(), refresh_from: Date.now() + 100 };
@@ -1110,10 +1126,16 @@ describe('Token retrieval and related public functions working without init', ()
11101126
expect(uid2.getIdentity()).toStrictEqual(identity);
11111127
expect(uid2.getAdvertisingTokenAsync()).resolves.toBe(identity.advertising_token);
11121128
expect(async () => {
1113-
await uid2.setIdentityFromEmail(email, mocks.makeCstgOption());
1129+
await uid2.setIdentityFromEmail(email, mocks.makeUid2CstgOption());
1130+
}).rejects.toThrow();
1131+
expect(async () => {
1132+
await uid2.setIdentityFromEmailHash(emailHash, mocks.makeUid2CstgOption());
1133+
}).rejects.toThrow();
1134+
expect(async () => {
1135+
await uid2.setIdentityFromPhone(phone, mocks.makeUid2CstgOption());
11141136
}).rejects.toThrow();
11151137
expect(async () => {
1116-
await uid2.setIdentityFromEmailHash(emailHash, mocks.makeCstgOption());
1138+
await uid2.setIdentityFromPhoneHash(phoneHash, mocks.makeUid2CstgOption());
11171139
}).rejects.toThrow();
11181140
functions.removeIdentity();
11191141
});

‎src/integrationTests/clientSideTokenGeneration.test.ts‎

Lines changed: 126 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -3,11 +3,15 @@ import { NAME_CURVE } from '../mocks';
33
import { base64ToBytes, bytesToBase64 } from '../encoding/base64';
44
import { EventType } from '../callbackManager';
55
import { sdkWindow, UID2 } from '../uid2Sdk';
6+
import { EUID } from '../euidSdk';
67

78
let uid2: UID2;
9+
let euid: EUID;
10+
let uid2OrEuid: UID2 | EUID;
811
let xhrMock: any;
912
let serverKeyPair: CryptoKeyPair;
10-
let serverPublicKey: string;
13+
let serverPublicKeyUid2: string;
14+
let serverPublicKeyEuid: string;
1115

1216
mocks.setupFakeTime();
1317

@@ -22,62 +26,128 @@ beforeAll(async () => {
2226
);
2327

2428
const serverPubKeyArray = await crypto.subtle.exportKey('spki', serverKeyPair.publicKey);
25-
serverPublicKey = `UID2-X-L-` + bytesToBase64(new Uint8Array(serverPubKeyArray));
29+
serverPublicKeyUid2 = `UID2-X-L-` + bytesToBase64(new Uint8Array(serverPubKeyArray));
30+
serverPublicKeyEuid = `EUID-X-L-` + bytesToBase64(new Uint8Array(serverPubKeyArray));
2631
});
2732

2833
beforeEach(() => {
2934
xhrMock = new mocks.XhrMock(sdkWindow);
3035
mocks.setCookieMock(sdkWindow.document);
3136
removeUid2LocalStorage();
37+
removeEuidLocalStorage();
3238
});
3339

3440
afterEach(() => {
3541
mocks.resetFakeTime();
3642
});
3743

3844
const removeUid2LocalStorage = mocks.removeUid2LocalStorage;
45+
const removeEuidLocalStorage = mocks.removeEuidLocalStorage;
3946

4047
describe('Client-side token generation Tests', () => {
4148
const scenarios = [
4249
{
4350
name: 'setIdentityFromEmail',
44-
setInvalidIdentity: () => uid2.setIdentityFromEmail('test.com', mocks.makeCstgOption()),
51+
identityType: 'uid2',
52+
setInvalidIdentity: () => uid2.setIdentityFromEmail('test.com', mocks.makeUid2CstgOption()),
4553
setIdentity: (serverPublicKey?: string) =>
46-
uid2.setIdentityFromEmail('test@example.com', mocks.makeCstgOption({ serverPublicKey })),
54+
uid2.setIdentityFromEmail(
55+
'test@example.com',
56+
mocks.makeUid2CstgOption({ serverPublicKey })
57+
),
58+
getIdentity: () => mocks.getUid2(),
4759
},
4860
{
4961
name: 'setIdentityFromEmailHash',
62+
identityType: 'uid2',
5063
setInvalidIdentity: () =>
51-
uid2.setIdentityFromEmailHash('test@example.com', mocks.makeCstgOption()),
64+
uid2.setIdentityFromEmailHash('test@example.com', mocks.makeUid2CstgOption()),
5265
setIdentity: (serverPublicKey?: string) =>
5366
uid2.setIdentityFromEmailHash(
5467
'lz3+Rj7IV4X1+Vr1ujkG7tstkxwk5pgkqJ6mXbpOgTs=',
55-
mocks.makeCstgOption({ serverPublicKey })
68+
mocks.makeUid2CstgOption({ serverPublicKey })
5669
),
70+
getIdentity: () => mocks.getUid2(),
5771
},
5872
{
5973
name: 'setIdentityFromPhone',
60-
setInvalidIdentity: () => uid2.setIdentityFromPhone('12345678910', mocks.makeCstgOption()),
74+
identityType: 'uid2',
75+
setInvalidIdentity: () =>
76+
uid2.setIdentityFromPhone('12345678910', mocks.makeUid2CstgOption()),
6177
setIdentity: (serverPublicKey?: string) =>
62-
uid2.setIdentityFromPhone('+12345678910', mocks.makeCstgOption({ serverPublicKey })),
78+
uid2.setIdentityFromPhone('+12345678910', mocks.makeUid2CstgOption({ serverPublicKey })),
79+
getIdentity: () => mocks.getUid2(),
6380
},
6481
{
6582
name: 'setIdentityFromPhoneHash',
83+
identityType: 'uid2',
6684
setInvalidIdentity: () =>
67-
uid2.setIdentityFromPhoneHash('+12345678910', mocks.makeCstgOption()),
85+
uid2.setIdentityFromPhoneHash('+12345678910', mocks.makeUid2CstgOption()),
6886
setIdentity: (serverPublicKey?: string) =>
6987
uid2.setIdentityFromPhoneHash(
7088
'kVJ+4ilhrqm3HZDDnCQy4niZknvCoM4MkoVzZrQSdJw=',
71-
mocks.makeCstgOption({ serverPublicKey })
89+
mocks.makeUid2CstgOption({ serverPublicKey })
90+
),
91+
getIdentity: () => mocks.getUid2(),
92+
},
93+
{
94+
name: 'setIdentityFromEmail',
95+
identityType: 'euid',
96+
setInvalidIdentity: () => euid.setIdentityFromEmail('test.com', mocks.makeEuidCstgOption()),
97+
setIdentity: (serverPublicKey?: string) =>
98+
euid.setIdentityFromEmail(
99+
'test@example.com',
100+
mocks.makeEuidCstgOption({ serverPublicKey })
101+
),
102+
getIdentity: () => mocks.getEuid(),
103+
},
104+
{
105+
name: 'setIdentityFromEmailHash',
106+
identityType: 'euid',
107+
setInvalidIdentity: () =>
108+
euid.setIdentityFromEmailHash('test@example.com', mocks.makeEuidCstgOption()),
109+
setIdentity: (serverPublicKey?: string) =>
110+
euid.setIdentityFromEmailHash(
111+
'lz3+Rj7IV4X1+Vr1ujkG7tstkxwk5pgkqJ6mXbpOgTs=',
112+
mocks.makeEuidCstgOption({ serverPublicKey })
113+
),
114+
getIdentity: () => mocks.getEuid(),
115+
},
116+
{
117+
name: 'setIdentityFromPhone',
118+
identityType: 'euid',
119+
setInvalidIdentity: () =>
120+
euid.setIdentityFromPhone('12345678910', mocks.makeEuidCstgOption()),
121+
setIdentity: (serverPublicKey?: string) =>
122+
euid.setIdentityFromPhone('+12345678910', mocks.makeEuidCstgOption({ serverPublicKey })),
123+
getIdentity: () => mocks.getEuid(),
124+
},
125+
{
126+
name: 'setIdentityFromPhoneHash',
127+
identityType: 'euid',
128+
setInvalidIdentity: () =>
129+
euid.setIdentityFromPhoneHash('+12345678910', mocks.makeEuidCstgOption()),
130+
setIdentity: (serverPublicKey?: string) =>
131+
euid.setIdentityFromPhoneHash(
132+
'kVJ+4ilhrqm3HZDDnCQy4niZknvCoM4MkoVzZrQSdJw=',
133+
mocks.makeEuidCstgOption({ serverPublicKey })
72134
),
135+
getIdentity: () => mocks.getEuid(),
73136
},
74137
];
75138

76139
scenarios.forEach((scenario) => {
77140
describe(scenario.name, () => {
78141
beforeEach(() => {
79-
uid2 = new UID2();
80-
uid2.init({});
142+
if (scenario.identityType === 'uid2') {
143+
uid2 = new UID2();
144+
uid2.init({});
145+
uid2OrEuid = uid2;
146+
} else if (scenario.identityType === 'euid') {
147+
euid = new EUID();
148+
euid.init({});
149+
uid2OrEuid = euid;
150+
}
81151
});
82152

83153
describe('When invalid identity is provided', () => {
@@ -107,35 +177,45 @@ describe('Client-side token generation Tests', () => {
107177
});
108178

109179
test('should invoke the callback when token is generated', (done) => {
110-
uid2.callbacks.push((eventType, payload) => {
180+
uid2OrEuid.callbacks.push((eventType, payload) => {
111181
if (eventType === EventType.IdentityUpdated) {
112182
expect(payload.identity).toEqual(cstgToken);
113183
done();
114184
}
115185
});
116-
scenario.setIdentity(serverPublicKey);
186+
scenario.setIdentity(
187+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
188+
);
117189
});
118190

119191
test('should set identity to storage', async () => {
120-
await scenario.setIdentity(serverPublicKey);
121-
expect(mocks.getUid2()).toEqual(cstgToken);
192+
await scenario.setIdentity(
193+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
194+
);
195+
expect(scenario.getIdentity()).toEqual(cstgToken);
122196
});
123197

124-
test('UID2 should be in available state', async () => {
125-
await scenario.setIdentity(serverPublicKey);
126-
(expect(uid2) as any).toBeInAvailableState(cstgToken.advertising_token);
198+
test('UID2 or EUID should be in available state', async () => {
199+
await scenario.setIdentity(
200+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
201+
);
202+
(expect(uid2OrEuid) as any).toBeInAvailableState(cstgToken.advertising_token);
127203
});
128204

129205
test('should refresh token when generated token requires a refresh', async () => {
130-
await scenario.setIdentity(serverPublicKey);
206+
await scenario.setIdentity(
207+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
208+
);
131209
const refreshedToken = {
132210
...mocks.makeIdentityV2(),
133211
advertising_token: 'refreshed_token',
134212
};
135213
jest.setSystemTime(refreshFrom);
136214
jest.runOnlyPendingTimers();
137215
xhrMock.sendIdentityInEncodedResponse(refreshedToken, cstgToken.refresh_response_key);
138-
expect(await uid2!.getAdvertisingTokenAsync()).toBe(refreshedToken.advertising_token);
216+
expect(await uid2OrEuid!.getAdvertisingTokenAsync()).toBe(
217+
refreshedToken.advertising_token
218+
);
139219
});
140220
});
141221

@@ -152,16 +232,20 @@ describe('Client-side token generation Tests', () => {
152232
});
153233
});
154234
test('should not set identity', async () => {
155-
await expect(scenario.setIdentity(serverPublicKey)).rejects.toEqual(
156-
'Client error: Here is a client error'
157-
);
158-
expect(mocks.getUid2()).toBeNull();
235+
await expect(
236+
scenario.setIdentity(
237+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
238+
)
239+
).rejects.toEqual('Client error: Here is a client error');
240+
expect(scenario.getIdentity()).toBeNull();
159241
});
160242
test('should be in unavailable state', async () => {
161-
await expect(scenario.setIdentity(serverPublicKey)).rejects.toEqual(
162-
'Client error: Here is a client error'
163-
);
164-
(expect(uid2) as any).toBeInUnavailableState();
243+
await expect(
244+
scenario.setIdentity(
245+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
246+
)
247+
).rejects.toEqual('Client error: Here is a client error');
248+
(expect(uid2OrEuid) as any).toBeInUnavailableState();
165249
});
166250
});
167251

@@ -178,28 +262,34 @@ describe('Client-side token generation Tests', () => {
178262
);
179263
});
180264
});
181-
test('UID2 should be in optout state', async () => {
182-
await scenario.setIdentity(serverPublicKey);
183-
(expect(uid2) as any).toBeInOptoutState();
265+
test('UID2 or EUID should be in optout state', async () => {
266+
await scenario.setIdentity(
267+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
268+
);
269+
(expect(uid2OrEuid) as any).toBeInOptoutState();
184270
});
185271

186272
test('The callback should be called with no identity', (done) => {
187-
uid2.callbacks.push((eventType, payload) => {
273+
uid2OrEuid.callbacks.push((eventType, payload) => {
188274
if (eventType === EventType.IdentityUpdated) {
189275
expect(payload.identity).toBeNull();
190276
done();
191277
}
192278
});
193-
scenario.setIdentity(serverPublicKey);
279+
scenario.setIdentity(
280+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
281+
);
194282
});
195283

196284
test('The callback should be called with an optout event', (done) => {
197-
uid2.callbacks.push((eventType, payload) => {
285+
uid2OrEuid.callbacks.push((eventType, payload) => {
198286
if (eventType === EventType.OptoutReceived) {
199287
done();
200288
}
201289
});
202-
scenario.setIdentity(serverPublicKey);
290+
scenario.setIdentity(
291+
scenario.identityType === 'uid2' ? serverPublicKeyUid2 : serverPublicKeyEuid
292+
);
203293
});
204294
});
205295
});

0 commit comments

Comments
 (0)