Skip to content

Commit 4476ee1

Browse files
sunnywusunnywu
committed
- Renamed RawUidResponse to IdentityMapResponseItem, MapRequest to IdentityMapRequestItem
- Renamed IUIDOperatorService.mapHashedDiiIdentity to mapHashedDii
1 parent ea0b247 commit 4476ee1

File tree

8 files changed

+73
-73
lines changed

8 files changed

+73
-73
lines changed

‎src/main/java/com/uid2/operator/model/MapRequest.java renamed to ‎src/main/java/com/uid2/operator/model/IdentityMapRequestItem.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,12 +4,12 @@
44

55
import java.time.Instant;
66

7-
public final class MapRequest {
7+
public final class IdentityMapRequestItem {
88
public final HashedDiiIdentity hashedDiiIdentity;
99
public final OptoutCheckPolicy optoutCheckPolicy;
1010
public final Instant asOf;
1111

12-
public MapRequest(
12+
public IdentityMapRequestItem(
1313
HashedDiiIdentity hashedDiiIdentity,
1414
OptoutCheckPolicy optoutCheckPolicy,
1515
Instant asOf) {

‎src/main/java/com/uid2/operator/model/RawUidResponse.java renamed to ‎src/main/java/com/uid2/operator/model/IdentityMapResponseItem.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
package com.uid2.operator.model;
22

33
// Contains the computed raw UID and its bucket ID from identity/map request
4-
public class RawUidResponse {
5-
public static final RawUidResponse OptoutIdentity = new RawUidResponse(new byte[33], "");
4+
public class IdentityMapResponseItem {
5+
public static final IdentityMapResponseItem OptoutIdentity = new IdentityMapResponseItem(new byte[33], "");
66
// The raw UID is also known as Advertising Id (historically)
77
public final byte[] rawUid;
88
public final String bucketId;
99

10-
public RawUidResponse(byte[] rawUid, String bucketId) {
10+
public IdentityMapResponseItem(byte[] rawUid, String bucketId) {
1111
this.rawUid = rawUid;
1212
this.bucketId = bucketId;
1313
}

‎src/main/java/com/uid2/operator/service/IUIDOperatorService.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,10 +16,10 @@ public interface IUIDOperatorService {
1616

1717
TokenRefreshResponse refreshIdentity(TokenRefreshRequest input);
1818

19-
RawUidResponse mapHashedDiiIdentity(MapRequest request);
19+
IdentityMapResponseItem mapHashedDii(IdentityMapRequestItem request);
2020

2121
@Deprecated
22-
RawUidResponse map(HashedDiiIdentity hashedDiiIdentity, Instant asOf);
22+
IdentityMapResponseItem map(HashedDiiIdentity hashedDiiIdentity, Instant asOf);
2323

2424
List<SaltEntry> getModifiedBuckets(Instant sinceTimestamp);
2525

‎src/main/java/com/uid2/operator/service/UIDOperatorService.java

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -161,18 +161,18 @@ public TokenRefreshResponse refreshIdentity(TokenRefreshRequest input) {
161161
}
162162

163163
@Override
164-
public RawUidResponse mapHashedDiiIdentity(MapRequest request) {
164+
public IdentityMapResponseItem mapHashedDii(IdentityMapRequestItem request) {
165165
final FirstLevelHashIdentity firstLevelHashIdentity = getFirstLevelHashIdentity(request.hashedDiiIdentity,
166166
request.asOf);
167167
if (request.shouldCheckOptOut() && getGlobalOptOutResult(firstLevelHashIdentity, false).isOptedOut()) {
168-
return RawUidResponse.OptoutIdentity;
168+
return IdentityMapResponseItem.OptoutIdentity;
169169
} else {
170170
return generateRawUid(firstLevelHashIdentity, request.asOf);
171171
}
172172
}
173173

174174
@Override
175-
public RawUidResponse map(HashedDiiIdentity diiIdentity, Instant asOf) {
175+
public IdentityMapResponseItem map(HashedDiiIdentity diiIdentity, Instant asOf) {
176176
final FirstLevelHashIdentity firstLevelHashIdentity = getFirstLevelHashIdentity(diiIdentity, asOf);
177177
return generateRawUid(firstLevelHashIdentity, asOf);
178178
}
@@ -195,9 +195,9 @@ private ISaltProvider.ISaltSnapshot getSaltProviderSnapshot(Instant asOf) {
195195
@Override
196196
public void invalidateTokensAsync(HashedDiiIdentity diiIdentity, Instant asOf, Handler<AsyncResult<Instant>> handler) {
197197
final FirstLevelHashIdentity firstLevelHashIdentity = getFirstLevelHashIdentity(diiIdentity, asOf);
198-
final RawUidResponse rawUidResponse = generateRawUid(firstLevelHashIdentity, asOf);
198+
final IdentityMapResponseItem identityMapResponseItem = generateRawUid(firstLevelHashIdentity, asOf);
199199

200-
this.optOutStore.addEntry(firstLevelHashIdentity, rawUidResponse.rawUid, r -> {
200+
this.optOutStore.addEntry(firstLevelHashIdentity, identityMapResponseItem.rawUid, r -> {
201201
if (r.succeeded()) {
202202
handler.handle(Future.succeededFuture(r.result()));
203203
} else {
@@ -209,10 +209,10 @@ public void invalidateTokensAsync(HashedDiiIdentity diiIdentity, Instant asOf, H
209209
@Override
210210
public boolean advertisingTokenMatches(String advertisingToken, HashedDiiIdentity diiIdentity, Instant asOf) {
211211
final FirstLevelHashIdentity firstLevelHashIdentity = getFirstLevelHashIdentity(diiIdentity, asOf);
212-
final RawUidResponse rawUidResponse = generateRawUid(firstLevelHashIdentity, asOf);
212+
final IdentityMapResponseItem identityMapResponseItem = generateRawUid(firstLevelHashIdentity, asOf);
213213

214214
final AdvertisingTokenRequest token = this.encoder.decodeAdvertisingToken(advertisingToken);
215-
return Arrays.equals(rawUidResponse.rawUid, token.rawUidIdentity.rawUid);
215+
return Arrays.equals(identityMapResponseItem.rawUid, token.rawUidIdentity.rawUid);
216216
}
217217

218218
@Override
@@ -239,10 +239,10 @@ private byte[] getFirstLevelHash(byte[] identityHash, Instant asOf) {
239239
return TokenUtils.getFirstLevelHash(identityHash, getSaltProviderSnapshot(asOf).getFirstLevelSalt());
240240
}
241241

242-
private RawUidResponse generateRawUid(FirstLevelHashIdentity firstLevelHashIdentity, Instant asOf) {
242+
private IdentityMapResponseItem generateRawUid(FirstLevelHashIdentity firstLevelHashIdentity, Instant asOf) {
243243
final SaltEntry rotatingSalt = getSaltProviderSnapshot(asOf).getRotatingSalt(firstLevelHashIdentity.firstLevelHash);
244244

245-
return new RawUidResponse(
245+
return new IdentityMapResponseItem(
246246
this.identityV3Enabled
247247
? TokenUtils.getRawUidV3(firstLevelHashIdentity.identityScope,
248248
firstLevelHashIdentity.identityType, firstLevelHashIdentity.firstLevelHash, rotatingSalt.getSalt())
@@ -254,10 +254,10 @@ private TokenGenerateResponse generateIdentity(SourcePublisher sourcePublisher,
254254
FirstLevelHashIdentity firstLevelHashIdentity, PrivacyBits privacyBits) {
255255
final Instant nowUtc = EncodingUtils.NowUTCMillis(this.clock);
256256

257-
final RawUidResponse rawUidResponse = generateRawUid(firstLevelHashIdentity, nowUtc);
257+
final IdentityMapResponseItem identityMapResponseItem = generateRawUid(firstLevelHashIdentity, nowUtc);
258258
final RawUidIdentity rawUidIdentity = new RawUidIdentity(firstLevelHashIdentity.identityScope,
259259
firstLevelHashIdentity.identityType,
260-
rawUidResponse.rawUid);
260+
identityMapResponseItem.rawUid);
261261

262262
return this.encoder.encodeIntoIdentityResponse(
263263
this.createAdvertisingTokenRequest(sourcePublisher, rawUidIdentity, nowUtc, privacyBits,

‎src/main/java/com/uid2/operator/vertx/UIDOperatorVerticle.java

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1237,11 +1237,11 @@ private void handleIdentityMapV1(RoutingContext rc) {
12371237
}
12381238
try {
12391239
final Instant now = Instant.now();
1240-
final RawUidResponse rawUidResponse = this.idService.map(input.toHashedDiiIdentity(this.identityScope), now);
1240+
final IdentityMapResponseItem identityMapResponseItem = this.idService.map(input.toHashedDiiIdentity(this.identityScope), now);
12411241
final JsonObject jsonObject = new JsonObject();
12421242
jsonObject.put("identifier", input.getProvided());
1243-
jsonObject.put("advertising_id", EncodingUtils.toBase64String(rawUidResponse.rawUid));
1244-
jsonObject.put("bucket_id", rawUidResponse.bucketId);
1243+
jsonObject.put("advertising_id", EncodingUtils.toBase64String(identityMapResponseItem.rawUid));
1244+
jsonObject.put("bucket_id", identityMapResponseItem.bucketId);
12451245
ResponseUtil.Success(rc, jsonObject);
12461246
} catch (Exception e) {
12471247
ResponseUtil.Error(ResponseStatus.UnknownError, 500, rc, "Unknown State", e);
@@ -1254,8 +1254,8 @@ private void handleIdentityMap(RoutingContext rc) {
12541254
try {
12551255
if (isTokenInputValid(input, rc)) {
12561256
final Instant now = Instant.now();
1257-
final RawUidResponse rawUidResponse = this.idService.map(input.toHashedDiiIdentity(this.identityScope), now);
1258-
rc.response().end(EncodingUtils.toBase64String(rawUidResponse.rawUid));
1257+
final IdentityMapResponseItem identityMapResponseItem = this.idService.map(input.toHashedDiiIdentity(this.identityScope), now);
1258+
rc.response().end(EncodingUtils.toBase64String(identityMapResponseItem.rawUid));
12591259
}
12601260
} catch (Exception ex) {
12611261
LOGGER.error("Unexpected error while mapping identity", ex);
@@ -1450,13 +1450,13 @@ private JsonObject handleIdentityMapCommon(RoutingContext rc, InputUtil.InputVal
14501450
for (int i = 0; i < count; ++i) {
14511451
final InputUtil.InputVal input = inputList[i];
14521452
if (input != null && input.isValid()) {
1453-
final RawUidResponse rawUidResponse = idService.mapHashedDiiIdentity(
1454-
new MapRequest(
1453+
final IdentityMapResponseItem identityMapResponseItem = idService.mapHashedDii(
1454+
new IdentityMapRequestItem(
14551455
input.toHashedDiiIdentity(this.identityScope),
14561456
OptoutCheckPolicy.respectOptOut(),
14571457
now));
14581458

1459-
if (rawUidResponse.isOptedOut()) {
1459+
if (identityMapResponseItem.isOptedOut()) {
14601460
final JsonObject resp = new JsonObject();
14611461
resp.put("identifier", input.getProvided());
14621462
resp.put("reason", "optout");
@@ -1465,8 +1465,8 @@ private JsonObject handleIdentityMapCommon(RoutingContext rc, InputUtil.InputVal
14651465
} else {
14661466
final JsonObject resp = new JsonObject();
14671467
resp.put("identifier", input.getProvided());
1468-
resp.put("advertising_id", EncodingUtils.toBase64String(rawUidResponse.rawUid));
1469-
resp.put("bucket_id", rawUidResponse.bucketId);
1468+
resp.put("advertising_id", EncodingUtils.toBase64String(identityMapResponseItem.rawUid));
1469+
resp.put("bucket_id", identityMapResponseItem.bucketId);
14701470
mapped.add(resp);
14711471
}
14721472
} else {

‎src/test/java/com/uid2/operator/UIDOperatorServiceTest.java

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -348,12 +348,12 @@ public void testIdentityMapForOptOutUser(IdentityType type, String identity, Ide
348348
final HashedDiiIdentity hashedDiiIdentity = createHashedDiiIdentity(identity, scope, type);
349349
final Instant now = Instant.now();
350350

351-
final MapRequest mapRequestForceMap = new MapRequest(
351+
final IdentityMapRequestItem mapRequestForceIdentityMapItem = new IdentityMapRequestItem(
352352
hashedDiiIdentity,
353353
OptoutCheckPolicy.DoNotRespect,
354354
now);
355355

356-
final MapRequest mapRequestRespectOptOut = new MapRequest(
356+
final IdentityMapRequestItem identityMapRequestItemRespectOptOut = new IdentityMapRequestItem(
357357
hashedDiiIdentity,
358358
OptoutCheckPolicy.RespectOptOut,
359359
now);
@@ -362,27 +362,27 @@ public void testIdentityMapForOptOutUser(IdentityType type, String identity, Ide
362362
when(optOutStore.getLatestEntry(any(FirstLevelHashIdentity.class)))
363363
.thenReturn(Instant.now().minus(1, ChronoUnit.HOURS));
364364

365-
final RawUidResponse rawUidResponse;
366-
final RawUidResponse rawUidResponseShouldBeOptOut;
365+
final IdentityMapResponseItem identityMapResponseItem;
366+
final IdentityMapResponseItem identityMapResponseItemShouldBeOptOut;
367367
if (scope == IdentityScope.UID2) {
368368
verify(shutdownHandler, atLeastOnce()).handleSaltRetrievalResponse(false);
369369
verify(shutdownHandler, never()).handleSaltRetrievalResponse(true);
370-
rawUidResponse = uid2Service.mapHashedDiiIdentity(mapRequestForceMap);
370+
identityMapResponseItem = uid2Service.mapHashedDii(mapRequestForceIdentityMapItem);
371371
reset(shutdownHandler);
372-
rawUidResponseShouldBeOptOut = uid2Service.mapHashedDiiIdentity(mapRequestRespectOptOut);
372+
identityMapResponseItemShouldBeOptOut = uid2Service.mapHashedDii(identityMapRequestItemRespectOptOut);
373373
} else {
374374
verify(shutdownHandler, atLeastOnce()).handleSaltRetrievalResponse(false);
375375
verify(shutdownHandler, never()).handleSaltRetrievalResponse(true);
376-
rawUidResponse = euidService.mapHashedDiiIdentity(mapRequestForceMap);
376+
identityMapResponseItem = euidService.mapHashedDii(mapRequestForceIdentityMapItem);
377377
reset(shutdownHandler);
378-
rawUidResponseShouldBeOptOut = euidService.mapHashedDiiIdentity(mapRequestRespectOptOut);
378+
identityMapResponseItemShouldBeOptOut = euidService.mapHashedDii(identityMapRequestItemRespectOptOut);
379379
}
380380
verify(shutdownHandler, atLeastOnce()).handleSaltRetrievalResponse(false);
381381
verify(shutdownHandler, never()).handleSaltRetrievalResponse(true);
382-
assertNotNull(rawUidResponse);
383-
assertFalse(rawUidResponse.isOptedOut());
384-
assertNotNull(rawUidResponseShouldBeOptOut);
385-
assertTrue(rawUidResponseShouldBeOptOut.isOptedOut());
382+
assertNotNull(identityMapResponseItem);
383+
assertFalse(identityMapResponseItem.isOptedOut());
384+
assertNotNull(identityMapResponseItemShouldBeOptOut);
385+
assertTrue(identityMapResponseItemShouldBeOptOut.isOptedOut());
386386
}
387387

388388
private enum TestIdentityInputType {
@@ -461,25 +461,25 @@ void testSpecialIdentityOptOutTokenGenerate(TestIdentityInputType type, String i
461461
void testSpecialIdentityOptOutIdentityMap(TestIdentityInputType type, String id, IdentityScope scope) {
462462
InputUtil.InputVal inputVal = generateInputVal(type, id);
463463

464-
final MapRequest mapRequestRespectOptOut = new MapRequest(
464+
final IdentityMapRequestItem identityMapRequestItemRespectOptOut = new IdentityMapRequestItem(
465465
inputVal.toHashedDiiIdentity(scope),
466466
OptoutCheckPolicy.RespectOptOut,
467467
now);
468468

469469
// identity has no optout record, ensure map still returns optout
470470
when(this.optOutStore.getLatestEntry(any())).thenReturn(null);
471471

472-
final RawUidResponse rawUidResponse;
472+
final IdentityMapResponseItem identityMapResponseItem;
473473
if(scope == IdentityScope.EUID) {
474-
rawUidResponse = euidService.mapHashedDiiIdentity(mapRequestRespectOptOut);
474+
identityMapResponseItem = euidService.mapHashedDii(identityMapRequestItemRespectOptOut);
475475
}
476476
else {
477-
rawUidResponse = uid2Service.mapHashedDiiIdentity(mapRequestRespectOptOut);
477+
identityMapResponseItem = uid2Service.mapHashedDii(identityMapRequestItemRespectOptOut);
478478
}
479479
verify(shutdownHandler, atLeastOnce()).handleSaltRetrievalResponse(false);
480480
verify(shutdownHandler, never()).handleSaltRetrievalResponse(true);
481-
assertNotNull(rawUidResponse);
482-
assertTrue(rawUidResponse.isOptedOut());
481+
assertNotNull(identityMapResponseItem);
482+
assertTrue(identityMapResponseItem.isOptedOut());
483483
}
484484

485485
@ParameterizedTest
@@ -575,25 +575,25 @@ void testSpecialIdentityRefreshOptOutGenerate(TestIdentityInputType type, String
575575
void testSpecialIdentityRefreshOptOutIdentityMap(TestIdentityInputType type, String id, IdentityScope scope) {
576576
InputUtil.InputVal inputVal = generateInputVal(type, id);
577577

578-
final MapRequest mapRequestRespectOptOut = new MapRequest(
578+
final IdentityMapRequestItem identityMapRequestItemRespectOptOut = new IdentityMapRequestItem(
579579
inputVal.toHashedDiiIdentity(scope),
580580
OptoutCheckPolicy.RespectOptOut,
581581
now);
582582

583583
// all identities have optout records, ensure refresh-optout identities still map
584584
when(this.optOutStore.getLatestEntry(any())).thenReturn(Instant.now());
585585

586-
final RawUidResponse rawUidResponse;
586+
final IdentityMapResponseItem identityMapResponseItem;
587587
if(scope == IdentityScope.EUID) {
588-
rawUidResponse = euidService.mapHashedDiiIdentity(mapRequestRespectOptOut);
588+
identityMapResponseItem = euidService.mapHashedDii(identityMapRequestItemRespectOptOut);
589589
}
590590
else {
591-
rawUidResponse = uid2Service.mapHashedDiiIdentity(mapRequestRespectOptOut);
591+
identityMapResponseItem = uid2Service.mapHashedDii(identityMapRequestItemRespectOptOut);
592592
}
593593
verify(shutdownHandler, atLeastOnce()).handleSaltRetrievalResponse(false);
594594
verify(shutdownHandler, never()).handleSaltRetrievalResponse(true);
595-
assertNotNull(rawUidResponse);
596-
assertFalse(rawUidResponse.isOptedOut());
595+
assertNotNull(identityMapResponseItem);
596+
assertFalse(identityMapResponseItem.isOptedOut());
597597
}
598598

599599
@ParameterizedTest
@@ -646,25 +646,25 @@ void testSpecialIdentityValidateGenerate(TestIdentityInputType type, String id,
646646
void testSpecialIdentityValidateIdentityMap(TestIdentityInputType type, String id, IdentityScope scope) {
647647
InputUtil.InputVal inputVal = generateInputVal(type, id);
648648

649-
final MapRequest mapRequestRespectOptOut = new MapRequest(
649+
final IdentityMapRequestItem identityMapRequestItemRespectOptOut = new IdentityMapRequestItem(
650650
inputVal.toHashedDiiIdentity(scope),
651651
OptoutCheckPolicy.RespectOptOut,
652652
now);
653653

654654
// all identities have optout records, ensure validate identities still get mapped
655655
when(this.optOutStore.getLatestEntry(any())).thenReturn(Instant.now());
656656

657-
final RawUidResponse rawUidResponse;
657+
final IdentityMapResponseItem identityMapResponseItem;
658658
if(scope == IdentityScope.EUID) {
659-
rawUidResponse = euidService.mapHashedDiiIdentity(mapRequestRespectOptOut);
659+
identityMapResponseItem = euidService.mapHashedDii(identityMapRequestItemRespectOptOut);
660660
}
661661
else {
662-
rawUidResponse = uid2Service.mapHashedDiiIdentity(mapRequestRespectOptOut);
662+
identityMapResponseItem = uid2Service.mapHashedDii(identityMapRequestItemRespectOptOut);
663663
}
664664
verify(shutdownHandler, atLeastOnce()).handleSaltRetrievalResponse(false);
665665
verify(shutdownHandler, never()).handleSaltRetrievalResponse(true);
666-
assertNotNull(rawUidResponse);
667-
assertFalse(rawUidResponse.isOptedOut());
666+
assertNotNull(identityMapResponseItem);
667+
assertFalse(identityMapResponseItem.isOptedOut());
668668
}
669669

670670
@ParameterizedTest
@@ -768,22 +768,22 @@ void testExpiredSaltsNotifiesShutdownHandler(TestIdentityInputType type, String
768768
assertNotNull(refreshResponse.getIdentityResponse());
769769
assertNotEquals(TokenRefreshResponse.Optout, refreshResponse);
770770

771-
final MapRequest mapRequest = new MapRequest(
771+
final IdentityMapRequestItem identityMapRequestItem = new IdentityMapRequestItem(
772772
inputVal.toHashedDiiIdentity(scope),
773773
OptoutCheckPolicy.RespectOptOut,
774774
now);
775-
final RawUidResponse rawUidResponse;
775+
final IdentityMapResponseItem identityMapResponseItem;
776776
reset(shutdownHandler);
777777
if(scope == IdentityScope.EUID) {
778-
rawUidResponse = euidService.mapHashedDiiIdentity(mapRequest);
778+
identityMapResponseItem = euidService.mapHashedDii(identityMapRequestItem);
779779
}
780780
else {
781-
rawUidResponse = uid2Service.mapHashedDiiIdentity(mapRequest);
781+
identityMapResponseItem = uid2Service.mapHashedDii(identityMapRequestItem);
782782
}
783783
verify(shutdownHandler, atLeastOnce()).handleSaltRetrievalResponse(true);
784784
verify(shutdownHandler, never()).handleSaltRetrievalResponse(false);
785-
assertNotNull(rawUidResponse);
786-
assertFalse(rawUidResponse.isOptedOut());
785+
assertNotNull(identityMapResponseItem);
786+
assertFalse(identityMapResponseItem.isOptedOut());
787787

788788
}
789789
}

0 commit comments

Comments
 (0)