private void migrate(ObjectType objectType) {
    log.info("Migrating {}", objectType);

    var sourceAccountName = dataMigrationProperties.getSourceAccountName();
    var targetAccountName = dataMigrationProperties.getTargetAccountName();

    var sourceObjectKeys =
        sourceStorageService.listObjectKeys(sourceAccountName, objectType).stream()
            .map(sourceObjectKey -> (String) sourceObjectKey.get("id"))
            .collect(Collectors.toList());

    var targetObjectKeys =
        targetStorageService.listObjectKeys(targetAccountName, objectType).stream()
            .map(sourceObjectKey -> (String) sourceObjectKey.get("id"))
            .collect(Collectors.toList());

    var objectKeysToMigrate =
        sourceObjectKeys.stream()
            .filter(
                sourceObjectKey ->
                    targetObjectKeys.stream()
                        .filter(targetObjectKey -> Objects.equals(targetObjectKey, sourceObjectKey))
                        .findFirst()
                        .map(
                            object -> {
                              log.warn(
                                  "Object for objectType: {}, key: {} already exists",
                                  objectType,
                                  sourceObjectKey);
                              return object;
                            })
                        .isEmpty())
            .collect(Collectors.toList());

    if (objectKeysToMigrate.isEmpty()) {
      log.info(
          "No objects to migrate for objectType: {}, sourceObjectCount: {}, targetObjectCount: {}",
          objectType,
          sourceObjectKeys.size(),
          targetObjectKeys.size());
      return;
    }

    var errors = new ConcurrentLinkedQueue<String>();

    for (var objectKey : objectKeysToMigrate) {
      executorService.submit(
          () -> {
            try {
              var object =
                  sourceStorageService.loadObject(sourceAccountName, objectType, objectKey);
              targetStorageService.storeObject(targetAccountName, objectType, objectKey, object);
            } catch (Exception e) {
              errors.add(String.format("[objectType: %s, objectKey: %s]", objectType, objectKey));
            }
          });
    }

    if (!errors.isEmpty()) {
      log.error("Unable to migrate objects for {}", String.join(",", errors));
    }
  }
@Test
  public void testMigrateWhenCollisions() {
    var testCanaryConfig = createTestCanaryConfig();

    when(sourceStorageService.listObjectKeys(testSourceAccountName, ObjectType.CANARY_CONFIG))
        .thenReturn(List.of(Map.of("id", testCanaryConfig.getId())));

    when(targetStorageService.listObjectKeys(testTargetAccountName, ObjectType.CANARY_CONFIG))
        .thenReturn(List.of(Map.of("id", testCanaryConfig.getId())));

    storageDataMigrator.migrate();

    verify(sourceStorageService, never())
        .loadObject(testSourceAccountName, ObjectType.CANARY_CONFIG, testCanaryConfig.getId());

    verify(targetStorageService, never())
        .storeObject(
            testTargetAccountName,
            ObjectType.CANARY_CONFIG,
            testCanaryConfig.getId(),
            testCanaryConfig);
  }