nmode's Git Repositories - signal-cli/blob - lib/src/test/java/org/asamk/signal/manager/storage/recipients/MergeRecipientHelperTest.java

   1 package org.asamk.signal.manager.storage.recipients;
   2
   3 import org.junit.jupiter.params.ParameterizedTest;
   4 import org.junit.jupiter.params.provider.Arguments;
   5 import org.junit.jupiter.params.provider.MethodSource;
   6 import org.whispersystems.signalservice.api.push.PNI;
   7 import org.whispersystems.signalservice.api.push.ServiceId;
   8
   9 import java.util.Arrays;
  10 import java.util.HashSet;
  11 import java.util.Set;
  12 import java.util.UUID;
  13 import java.util.stream.Collectors;
  14 import java.util.stream.Stream;
  15
  16 import static org.junit.jupiter.api.Assertions.assertEquals;
  17
  18 class MergeRecipientHelperTest {
  19
  20     static final ServiceId SERVICE_ID_A = ServiceId.from(UUID.randomUUID());
  21     static final ServiceId SERVICE_ID_B = ServiceId.from(UUID.randomUUID());
  22     static final ServiceId SERVICE_ID_C = ServiceId.from(UUID.randomUUID());
  23     static final PNI PNI_A = PNI.from(UUID.randomUUID());
  24     static final PNI PNI_B = PNI.from(UUID.randomUUID());
  25     static final PNI PNI_C = PNI.from(UUID.randomUUID());
  26     static final String NUMBER_A = "+AAA";
  27     static final String NUMBER_B = "+BBB";
  28     static final String NUMBER_C = "+CCC";
  29
  30     static final PartialAddresses ADDR_A = new PartialAddresses(SERVICE_ID_A, PNI_A, NUMBER_A);
  31     static final PartialAddresses ADDR_B = new PartialAddresses(SERVICE_ID_B, PNI_B, NUMBER_B);
  32
  33     static T[] testInstancesNone = new T[]{
  34             // 1
  35             new T(Set.of(), ADDR_A.FULL, Set.of(rec(1000000, ADDR_A.FULL))),
  36             new T(Set.of(), ADDR_A.ACI_NUM, Set.of(rec(1000000, ADDR_A.ACI_NUM))),
  37             new T(Set.of(), ADDR_A.ACI_PNI, Set.of(rec(1000000, ADDR_A.ACI_PNI))),
  38             new T(Set.of(), ADDR_A.PNI_S_NUM, Set.of(rec(1000000, ADDR_A.PNI_S_NUM))),
  39             new T(Set.of(), ADDR_A.PNI_NUM, Set.of(rec(1000000, ADDR_A.PNI_NUM))),
  40     };
  41
  42     static T[] testInstancesSingle = new T[]{
  43             // 1
  44             new T(Set.of(rec(1, ADDR_A.FULL)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  45             new T(Set.of(rec(1, ADDR_A.ACI)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  46             new T(Set.of(rec(1, ADDR_A.PNI)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  47             new T(Set.of(rec(1, ADDR_A.PNI_S)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  48             new T(Set.of(rec(1, ADDR_A.NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  49             new T(Set.of(rec(1, ADDR_A.ACI_NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  50             new T(Set.of(rec(1, ADDR_A.PNI_NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  51             new T(Set.of(rec(1, ADDR_A.PNI_S_NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  52             new T(Set.of(rec(1, ADDR_A.ACI_PNI)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
  53
  54             // 10
  55             new T(Set.of(rec(1, ADDR_A.FULL)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.FULL))),
  56             new T(Set.of(rec(1, ADDR_A.ACI)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.ACI_NUM))),
  57             new T(Set.of(rec(1, ADDR_A.PNI)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.PNI), rec(1000000, ADDR_A.ACI_NUM))),
  58             new T(Set.of(rec(1, ADDR_A.PNI_S)),
  59                     ADDR_A.ACI_NUM,
  60                     Set.of(rec(1, ADDR_A.PNI_S), rec(1000000, ADDR_A.ACI_NUM))),
  61             new T(Set.of(rec(1, ADDR_A.NUM)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.ACI_NUM))),
  62             new T(Set.of(rec(1, ADDR_A.ACI_NUM)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.ACI_NUM))),
  63             new T(Set.of(rec(1, ADDR_A.PNI_NUM)),
  64                     ADDR_A.ACI_NUM,
  65                     Set.of(rec(1, ADDR_A.PNI), rec(1000000, ADDR_A.ACI_NUM))),
  66             new T(Set.of(rec(1, ADDR_A.PNI_S_NUM)),
  67                     ADDR_A.ACI_NUM,
  68                     Set.of(rec(1, ADDR_A.PNI_S), rec(1000000, ADDR_A.ACI_NUM))),
  69             new T(Set.of(rec(1, ADDR_A.ACI_PNI)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.FULL))),
  70
  71             // 19
  72             new T(Set.of(rec(1, ADDR_A.FULL)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.FULL))),
  73             new T(Set.of(rec(1, ADDR_A.ACI)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.ACI), rec(1000000, ADDR_A.PNI_NUM))),
  74             new T(Set.of(rec(1, ADDR_A.PNI)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
  75             new T(Set.of(rec(1, ADDR_A.PNI_S)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
  76             new T(Set.of(rec(1, ADDR_A.NUM)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
  77             new T(Set.of(rec(1, ADDR_A.ACI_NUM)),
  78                     ADDR_A.PNI_NUM,
  79                     Set.of(rec(1, ADDR_A.ACI), rec(1000000, ADDR_A.PNI_NUM))),
  80             new T(Set.of(rec(1, ADDR_A.PNI_NUM)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
  81             new T(Set.of(rec(1, ADDR_A.PNI_S_NUM)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
  82             new T(Set.of(rec(1, ADDR_A.ACI_PNI)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.FULL))),
  83
  84             // 28
  85             new T(Set.of(rec(1, ADDR_A.FULL)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.FULL))),
  86             new T(Set.of(rec(1, ADDR_A.ACI)),
  87                     ADDR_A.PNI_S_NUM,
  88                     Set.of(rec(1, ADDR_A.ACI), rec(1000000, ADDR_A.PNI_S_NUM))),
  89             new T(Set.of(rec(1, ADDR_A.PNI)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
  90             new T(Set.of(rec(1, ADDR_A.PNI_S)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.PNI_S_NUM))),
  91             new T(Set.of(rec(1, ADDR_A.NUM)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.PNI_S_NUM))),
  92             new T(Set.of(rec(1, ADDR_A.ACI_NUM)),
  93                     ADDR_A.PNI_S_NUM,
  94                     Set.of(rec(1, ADDR_A.ACI), rec(1000000, ADDR_A.PNI_S_NUM))),
  95             new T(Set.of(rec(1, ADDR_A.PNI_NUM)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
  96             new T(Set.of(rec(1, ADDR_A.PNI_S_NUM)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.PNI_S_NUM))),
  97             new T(Set.of(rec(1, ADDR_A.ACI_PNI)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.FULL))),
  98
  99             // 37
 100             new T(Set.of(rec(1, ADDR_A.FULL)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.FULL))),
 101             new T(Set.of(rec(1, ADDR_A.ACI)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.ACI_PNI))),
 102             new T(Set.of(rec(1, ADDR_A.PNI)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.ACI_PNI))),
 103             new T(Set.of(rec(1, ADDR_A.PNI_S)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.ACI_PNI))),
 104             new T(Set.of(rec(1, ADDR_A.NUM)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.NUM), rec(1000000, ADDR_A.ACI_PNI))),
 105             new T(Set.of(rec(1, ADDR_A.ACI_NUM)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.FULL))),
 106             new T(Set.of(rec(1, ADDR_A.PNI_NUM)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.FULL))),
 107             new T(Set.of(rec(1, ADDR_A.PNI_S_NUM)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.FULL))),
 108             new T(Set.of(rec(1, ADDR_A.ACI_PNI)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.ACI_PNI))),
 109
 110             new T(Set.of(rec(1, ADDR_A.FULL)), ADDR_B.FULL, Set.of(rec(1, ADDR_A.FULL), rec(1000000, ADDR_B.FULL))),
 111     };
 112
 113     static T[] testInstancesTwo = new T[]{
 114             // 1
 115             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
 116             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
 117             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
 118             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
 119             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S_NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
 120             new T(Set.of(rec(1, ADDR_A.PNI), rec(2, ADDR_A.NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
 121             new T(Set.of(rec(1, ADDR_A.PNI), rec(2, ADDR_A.ACI_NUM)), ADDR_A.FULL, Set.of(rec(2, ADDR_A.FULL))),
 122             new T(Set.of(rec(1, ADDR_A.PNI_S), rec(2, ADDR_A.NUM)), ADDR_A.FULL, Set.of(rec(1, ADDR_A.FULL))),
 123             new T(Set.of(rec(1, ADDR_A.PNI_S), rec(2, ADDR_A.ACI_NUM)), ADDR_A.FULL, Set.of(rec(2, ADDR_A.FULL))),
 124             new T(Set.of(rec(1, ADDR_A.NUM), rec(2, ADDR_A.PNI_S)), ADDR_A.FULL, Set.of(rec(2, ADDR_A.FULL))),
 125             new T(Set.of(rec(1, ADDR_A.NUM), rec(2, ADDR_A.ACI_PNI)), ADDR_A.FULL, Set.of(rec(2, ADDR_A.FULL))),
 126
 127             // 12
 128             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.NUM)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.ACI_NUM))),
 129             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM)), ADDR_A.ACI_NUM, Set.of(rec(1, ADDR_A.FULL))),
 130             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S_NUM)),
 131                     ADDR_A.ACI_NUM,
 132                     Set.of(rec(1, ADDR_A.ACI_NUM), rec(2, ADDR_A.PNI_S))),
 133             new T(Set.of(rec(1, ADDR_A.NUM), rec(2, ADDR_A.ACI_PNI)), ADDR_A.ACI_NUM, Set.of(rec(2, ADDR_A.FULL))),
 134
 135             // 16
 136             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM)),
 137                     ADDR_A.PNI_NUM,
 138                     Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM))),
 139             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S_NUM)),
 140                     ADDR_A.PNI_NUM,
 141                     Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM))),
 142             new T(Set.of(rec(1, ADDR_A.PNI), rec(2, ADDR_A.NUM)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
 143             new T(Set.of(rec(1, ADDR_A.PNI), rec(2, ADDR_A.ACI_NUM)),
 144                     ADDR_A.PNI_NUM,
 145                     Set.of(rec(1, ADDR_A.PNI_NUM), rec(2, ADDR_A.ACI))),
 146             new T(Set.of(rec(1, ADDR_A.PNI_S), rec(2, ADDR_A.NUM)), ADDR_A.PNI_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
 147             new T(Set.of(rec(1, ADDR_A.PNI_S), rec(2, ADDR_A.ACI_NUM)),
 148                     ADDR_A.PNI_NUM,
 149                     Set.of(rec(1, ADDR_A.PNI_NUM), rec(2, ADDR_A.ACI))),
 150             new T(Set.of(rec(1, ADDR_A.NUM), rec(2, ADDR_A.PNI_S)), ADDR_A.PNI_NUM, Set.of(rec(2, ADDR_A.PNI_NUM))),
 151             new T(Set.of(rec(1, ADDR_A.NUM), rec(2, ADDR_A.ACI_PNI)), ADDR_A.PNI_NUM, Set.of(rec(2, ADDR_A.FULL))),
 152
 153             // 24
 154             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM)),
 155                     ADDR_A.PNI_S_NUM,
 156                     Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM))),
 157             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S_NUM)),
 158                     ADDR_A.PNI_S_NUM,
 159                     Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S_NUM))),
 160             new T(Set.of(rec(1, ADDR_A.PNI), rec(2, ADDR_A.NUM)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.PNI_NUM))),
 161             new T(Set.of(rec(1, ADDR_A.PNI), rec(2, ADDR_A.ACI_NUM)),
 162                     ADDR_A.PNI_S_NUM,
 163                     Set.of(rec(1, ADDR_A.PNI_NUM), rec(2, ADDR_A.ACI))),
 164             new T(Set.of(rec(1, ADDR_A.PNI_S), rec(2, ADDR_A.NUM)), ADDR_A.PNI_S_NUM, Set.of(rec(1, ADDR_A.PNI_S_NUM))),
 165             new T(Set.of(rec(1, ADDR_A.PNI_S), rec(2, ADDR_A.ACI_NUM)),
 166                     ADDR_A.PNI_S_NUM,
 167                     Set.of(rec(1, ADDR_A.PNI_S_NUM), rec(2, ADDR_A.ACI))),
 168             new T(Set.of(rec(1, ADDR_A.NUM), rec(2, ADDR_A.PNI_S)), ADDR_A.PNI_S_NUM, Set.of(rec(2, ADDR_A.PNI_S_NUM))),
 169             new T(Set.of(rec(1, ADDR_A.NUM), rec(2, ADDR_A.ACI_PNI)), ADDR_A.PNI_S_NUM, Set.of(rec(2, ADDR_A.FULL))),
 170
 171             // 32
 172             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.ACI_PNI))),
 173             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.ACI_PNI))),
 174             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_NUM)), ADDR_A.ACI_PNI, Set.of(rec(1, ADDR_A.FULL))),
 175             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI_S_NUM)),
 176                     ADDR_A.ACI_PNI,
 177                     Set.of(rec(1, ADDR_A.ACI_PNI), rec(2, ADDR_A.NUM))),
 178             new T(Set.of(rec(1, ADDR_A.PNI), rec(2, ADDR_A.ACI_NUM)), ADDR_A.ACI_PNI, Set.of(rec(2, ADDR_A.FULL))),
 179             new T(Set.of(rec(1, ADDR_A.PNI_S), rec(2, ADDR_A.ACI_NUM)), ADDR_A.ACI_PNI, Set.of(rec(2, ADDR_A.FULL))),
 180     };
 181
 182     static T[] testInstancesThree = new T[]{
 183             // 1
 184             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI), rec(3, ADDR_A.NUM)),
 185                     ADDR_A.FULL,
 186                     Set.of(rec(1, ADDR_A.FULL))),
 187             new T(Set.of(rec(1, ADDR_A.ACI.withIdentifiersFrom(ADDR_B.PNI)), rec(2, ADDR_A.PNI), rec(3, ADDR_A.NUM)),
 188                     ADDR_A.FULL,
 189                     Set.of(rec(1, ADDR_A.FULL))),
 190             new T(Set.of(rec(1, ADDR_A.ACI.withIdentifiersFrom(ADDR_B.NUM)), rec(2, ADDR_A.PNI), rec(3, ADDR_A.NUM)),
 191                     ADDR_A.FULL,
 192                     Set.of(rec(1, ADDR_A.FULL))),
 193             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI), rec(3, ADDR_A.NUM.withIdentifiersFrom(ADDR_B.ACI))),
 194                     ADDR_A.FULL,
 195                     Set.of(rec(1, ADDR_A.FULL), rec(3, ADDR_B.ACI))),
 196             new T(Set.of(rec(1, ADDR_A.ACI), rec(2, ADDR_A.PNI.withIdentifiersFrom(ADDR_B.ACI)), rec(3, ADDR_A.NUM)),
 197                     ADDR_A.FULL,
 198                     Set.of(rec(1, ADDR_A.FULL), rec(2, ADDR_B.ACI))),
 199     };
 200
 201     @ParameterizedTest
 202     @MethodSource
 203     void resolveRecipientTrustedLocked_NoneExisting(T test) throws Exception {
 204         final var testStore = new TestStore(test.input);
 205         MergeRecipientHelper.resolveRecipientTrustedLocked(testStore, test.request);
 206         assertEquals(test.output, testStore.getRecipients());
 207     }
 208
 209     private static Stream<Arguments> resolveRecipientTrustedLocked_NoneExisting() {
 210         return Arrays.stream(testInstancesNone).map(Arguments::of);
 211     }
 212
 213     @ParameterizedTest
 214     @MethodSource
 215     void resolveRecipientTrustedLocked_SingleExisting(T test) throws Exception {
 216         final var testStore = new TestStore(test.input);
 217         MergeRecipientHelper.resolveRecipientTrustedLocked(testStore, test.request);
 218         assertEquals(test.output, testStore.getRecipients());
 219     }
 220
 221     private static Stream<Arguments> resolveRecipientTrustedLocked_SingleExisting() {
 222         return Arrays.stream(testInstancesSingle).map(Arguments::of);
 223     }
 224
 225     @ParameterizedTest
 226     @MethodSource
 227     void resolveRecipientTrustedLocked_TwoExisting(T test) throws Exception {
 228         final var testStore = new TestStore(test.input);
 229         MergeRecipientHelper.resolveRecipientTrustedLocked(testStore, test.request);
 230         assertEquals(test.output, testStore.getRecipients());
 231     }
 232
 233     private static Stream<Arguments> resolveRecipientTrustedLocked_TwoExisting() {
 234         return Arrays.stream(testInstancesTwo).map(Arguments::of);
 235     }
 236
 237     @ParameterizedTest
 238     @MethodSource
 239     void resolveRecipientTrustedLocked_ThreeExisting(T test) throws Exception {
 240         final var testStore = new TestStore(test.input);
 241         MergeRecipientHelper.resolveRecipientTrustedLocked(testStore, test.request);
 242         assertEquals(test.output, testStore.getRecipients());
 243     }
 244
 245     private static Stream<Arguments> resolveRecipientTrustedLocked_ThreeExisting() {
 246         return Arrays.stream(testInstancesThree).map(Arguments::of);
 247     }
 248
 249     private static RecipientWithAddress rec(long recipientId, RecipientAddress address) {
 250         return new RecipientWithAddress(new RecipientId(recipientId, null), address);
 251     }
 252
 253     record T(
 254             Set<RecipientWithAddress> input, RecipientAddress request, Set<RecipientWithAddress> output
 255     ) {
 256
 257         @Override
 258         public String toString() {
 259             return "T{#input=%s, request=%s_%s_%s, #output=%s}".formatted(input.size(),
 260                     request.serviceId().isPresent() ? "SVI" : "",
 261                     request.pni().isPresent() ? "PNI" : "",
 262                     request.number().isPresent() ? "NUM" : "",
 263                     output.size());
 264         }
 265     }
 266
 267     static class TestStore implements MergeRecipientHelper.Store {
 268
 269         final Set<RecipientWithAddress> recipients;
 270         long nextRecipientId = 1000000;
 271
 272         TestStore(final Set<RecipientWithAddress> recipients) {
 273             this.recipients = new HashSet<>(recipients);
 274         }
 275
 276         public Set<RecipientWithAddress> getRecipients() {
 277             return recipients;
 278         }
 279
 280         @Override
 281         public Set<RecipientWithAddress> findAllByAddress(final RecipientAddress address) {
 282             return recipients.stream().filter(r -> r.address().matches(address)).collect(Collectors.toSet());
 283         }
 284
 285         @Override
 286         public RecipientId addNewRecipient(final RecipientAddress address) {
 287             final var recipientId = new RecipientId(nextRecipientId++, null);
 288             recipients.add(new RecipientWithAddress(recipientId, address));
 289             return recipientId;
 290         }
 291
 292         @Override
 293         public void updateRecipientAddress(
 294                 final RecipientId recipientId, final RecipientAddress address
 295         ) {
 296             recipients.removeIf(r -> r.id().equals(recipientId));
 297             recipients.add(new RecipientWithAddress(recipientId, address));
 298         }
 299
 300         @Override
 301         public void removeRecipientAddress(final RecipientId recipientId) {
 302             recipients.removeIf(r -> r.id().equals(recipientId));
 303         }
 304     }
 305
 306     private record PartialAddresses(
 307             RecipientAddress FULL,
 308             RecipientAddress ACI,
 309             RecipientAddress PNI,
 310             RecipientAddress PNI_S,
 311             RecipientAddress NUM,
 312             RecipientAddress ACI_NUM,
 313             RecipientAddress PNI_NUM,
 314             RecipientAddress PNI_S_NUM,
 315             RecipientAddress ACI_PNI
 316     ) {
 317
 318         PartialAddresses(ServiceId serviceId, PNI pni, String number) {
 319             this(new RecipientAddress(serviceId, pni, number),
 320                     new RecipientAddress(serviceId, null, null),
 321                     new RecipientAddress(null, pni, null),
 322                     new RecipientAddress(ServiceId.from(pni.uuid()), null, null),
 323                     new RecipientAddress(null, null, number),
 324                     new RecipientAddress(serviceId, null, number),
 325                     new RecipientAddress(null, pni, number),
 326                     new RecipientAddress(ServiceId.from(pni.uuid()), null, number),
 327                     new RecipientAddress(serviceId, pni, null));
 328         }
 329     }
 330 }