> updateActions) {
if (this.errorCallback != null) {
this.errorCallback.accept(exception, Optional.ofNullable(newResourceDraft),
Optional.ofNullable(oldResource), updateActions);
@@ -125,7 +127,6 @@ public void applyErrorCallback(@Nonnull final SyncException exception, @Nullable
}
/**
- *
* @param syncException {@link Throwable} instance to supply as first param to the {@code errorCallback} function.
* @see #applyErrorCallback(SyncException exception, Object oldResource, Object newResource, List updateActions)
*/
@@ -134,7 +135,6 @@ public void applyErrorCallback(@Nonnull final SyncException syncException) {
}
/**
- *
* @param errorMessage the error message to supply as part of first param to the {@code errorCallback} function.
* @see #applyErrorCallback(SyncException exception, Object oldResource, Object newResource, List updateActions)
*/
@@ -148,9 +148,10 @@ public void applyErrorCallback(@Nonnull final String errorMessage) {
* batches and then processed. It allows to reduce the query size for fetching all resources processed in one
* batch.
* E.g. value of 30 means that 30 entries from input list would be accumulated and one API call will be performed
- * for fetching entries responding to them. Then comparision and sync are performed.
+ * for fetching entries responding to them. Then comparison and sync are performed.
*
* This batch size is set to 30 by default.
+ *
* @return option that indicates capacity of batch of resources to process.
*/
public int getBatchSize() {
@@ -164,8 +165,8 @@ public int getBatchSize() {
* generated list of update actions to produce a resultant list after the filter function has been applied.
*
* @return the {@code beforeUpdateCallback} {@link TriFunction}<{@link List}<{@link UpdateAction}<
- * {@code U}>>, {@code V}, {@code U}, {@link List}<{@link UpdateAction}<{@code U}>>>
- * function set to {@code this} {@link BaseSyncOptions}.
+ * {@code U}>>, {@code V}, {@code U}, {@link List}<{@link UpdateAction}<{@code U}>>>
+ * function set to {@code this} {@link BaseSyncOptions}.
*/
@Nullable
public TriFunction>, V, U, List>> getBeforeUpdateCallback() {
@@ -179,7 +180,7 @@ public TriFunction>, V, U, List>> getBefore
* function has been applied.
*
* @return the {@code beforeUpdateCallback} {@link Function}<{@code V}, {@link Optional}<{@code V}>>
- * function set to {@code this} {@link BaseSyncOptions}.
+ * function set to {@code this} {@link BaseSyncOptions}.
*/
@Nullable
public Function getBeforeCreateCallback() {
@@ -193,13 +194,13 @@ public Function getBeforeCreateCallback() {
* is null or {@code updateActions} is empty, this method does nothing to the supplied list of {@code updateActions}
* and returns the same list. If the result of the callback is null, an empty list is returned.
*
- * @param updateActions the list of update actions to apply the {@code beforeUpdateCallback} function on.
+ * @param updateActions the list of update actions to apply the {@code beforeUpdateCallback} function on.
* @param newResourceDraft the new resource draft that is being compared to the old resource.
- * @param oldResource the old resource that is being compared to the new draft.
+ * @param oldResource the old resource that is being compared to the new draft.
* @return a list of update actions after applying the {@code beforeUpdateCallback} function on. If the
- * {@code beforeUpdateCallback} function is null or {@code updateActions} is empty, the supplied list of
- * {@code updateActions} is returned as is. If the return of the callback is null, an empty list is
- * returned.
+ * {@code beforeUpdateCallback} function is null or {@code updateActions} is empty, the supplied list of
+ * {@code updateActions} is returned as is. If the return of the callback is null, an empty list is
+ * returned.
*/
@Nonnull
public List> applyBeforeUpdateCallback(@Nonnull final List> updateActions,
@@ -224,12 +225,12 @@ public List> applyBeforeUpdateCallback(@Nonnull final List applyBeforeCreateCallback(@Nonnull final V newResourceDraft) {
return ofNullable(
- beforeCreateCallback != null ? beforeCreateCallback.apply(newResourceDraft) : newResourceDraft);
+ beforeCreateCallback != null ? beforeCreateCallback.apply(newResourceDraft) : newResourceDraft);
}
}
diff --git a/src/main/java/com/commercetools/sync/commons/utils/AssetsUpdateActionUtils.java b/src/main/java/com/commercetools/sync/commons/utils/AssetsUpdateActionUtils.java
index 96ec13c504..bb59e8a1a8 100644
--- a/src/main/java/com/commercetools/sync/commons/utils/AssetsUpdateActionUtils.java
+++ b/src/main/java/com/commercetools/sync/commons/utils/AssetsUpdateActionUtils.java
@@ -150,7 +150,6 @@ private static List> buildAssetsUpdateAc
// It is important to have a changeAssetOrder action before an addAsset action, since changeAssetOrder requires
// asset ids for sorting them, and new assets don't have ids yet since they are generated
// by CTP after an asset is created. Therefore, the order of update actions must be:
- // removeAsset → changeAssetOrder → addAsset
//1. Remove or compare if matching.
final List> updateActions =
diff --git a/src/main/java/com/commercetools/sync/customobjects/CustomObjectSync.java b/src/main/java/com/commercetools/sync/customobjects/CustomObjectSync.java
new file mode 100644
index 0000000000..39e526ad21
--- /dev/null
+++ b/src/main/java/com/commercetools/sync/customobjects/CustomObjectSync.java
@@ -0,0 +1,342 @@
+package com.commercetools.sync.customobjects;
+
+import com.commercetools.sync.commons.BaseSync;
+import com.commercetools.sync.commons.exceptions.SyncException;
+import com.commercetools.sync.customobjects.helpers.CustomObjectCompositeIdentifier;
+import com.commercetools.sync.customobjects.helpers.CustomObjectSyncStatistics;
+import com.commercetools.sync.customobjects.utils.CustomObjectSyncUtils;
+import com.commercetools.sync.services.CustomObjectService;
+import com.commercetools.sync.services.impl.CustomObjectServiceImpl;
+import com.fasterxml.jackson.databind.JsonNode;
+import io.sphere.sdk.customobjects.CustomObject;
+import io.sphere.sdk.customobjects.CustomObjectDraft;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+
+import static com.commercetools.sync.commons.utils.SyncUtils.batchElements;
+import static java.lang.String.format;
+import static java.util.Optional.ofNullable;
+import static java.util.concurrent.CompletableFuture.completedFuture;
+import static java.util.function.Function.identity;
+import static java.util.stream.Collectors.toMap;
+import static java.util.stream.Collectors.toSet;
+
+/**
+ * This class syncs custom object drafts with the corresponding custom objects in the CTP project.
+ */
+public class CustomObjectSync extends BaseSync,
+ CustomObjectSyncStatistics, CustomObjectSyncOptions> {
+
+ private static final String CTP_CUSTOM_OBJECT_FETCH_FAILED =
+ "Failed to fetch existing custom objects with keys: '%s'.";
+ private static final String CTP_CUSTOM_OBJECT_UPDATE_FAILED =
+ "Failed to update custom object with key: '%s'. Reason: %s";
+ private static final String CTP_CUSTOM_OBJECT_CREATE_FAILED =
+ "Failed to create custom object with key: '%s'. Reason: %s";
+ private static final String CUSTOM_OBJECT_DRAFT_IS_NULL = "Failed to process null custom object draft.";
+
+ private final CustomObjectService customObjectService;
+
+ public CustomObjectSync(@Nonnull final CustomObjectSyncOptions syncOptions) {
+ this(syncOptions, new CustomObjectServiceImpl(syncOptions));
+ }
+
+ /**
+ * Takes a {@link CustomObjectSyncOptions} and a {@link CustomObjectService} instances to instantiate
+ * a new {@link CustomObjectSync} instance that could be used to sync customObject drafts in the CTP project
+ * specified in the injected {@link CustomObjectSyncOptions} instance.
+ *
+ * NOTE: This constructor is mainly to be used for tests where the services can be mocked and passed to.
+ *
+ * @param syncOptions the container of all the options of the sync process including the CTP project
+ * client and/or configuration and other sync-specific options.
+ * @param customObjectService the custom object service which is responsible for fetching/caching the
+ */
+ CustomObjectSync(
+ @Nonnull final CustomObjectSyncOptions syncOptions,
+ @Nonnull final CustomObjectService customObjectService) {
+
+ super(new CustomObjectSyncStatistics(), syncOptions);
+ this.customObjectService = customObjectService;
+ }
+
+ /**
+ * Iterates through the whole {@code customObjectDrafts} list and accumulates its valid drafts to batches.
+ * Every batch is then processed by {@link CustomObjectSync#processBatch(List)}.
+ *
+ *
Inherited doc:
+ * {@inheritDoc}
+ *
+ * @param customObjectDrafts {@link List} of {@link CustomObjectDraft}'s that would be synced into CTP project.
+ * @return {@link CompletionStage} with {@link CustomObjectSyncStatistics} holding statistics of all sync
+ * processes performed by this sync instance.
+ */
+ protected CompletionStage process(
+ @Nonnull final List> customObjectDrafts) {
+ final List>> batches = batchElements(
+ customObjectDrafts, syncOptions.getBatchSize());
+ return syncBatches(batches, CompletableFuture.completedFuture(statistics));
+ }
+
+ /**
+ * This method first creates a new {@link Set} of valid {@link CustomObjectDraft} elements. For more on the rules of
+ * validation, check: {@link CustomObjectSync#validateDraft(CustomObjectDraft)}. Using the resulting set of
+ * {@code validCustomObjectDrafts}, the matching custom objects in the target CTP project are fetched then the
+ * method {@link CustomObjectSync#syncBatch(Set, Set)} is called to perform the sync (update or create
+ * requests accordingly) on the target project.
+ *
+ * In case of error during of fetching of existing custom objects, the error callback will be triggered.
+ * And the sync process would stop for the given batch.
+ *
+ *
+ * @param batch batch of drafts that need to be synced
+ * @return a {@link CompletionStage} containing an instance
+ * of {@link CustomObjectSyncStatistics} which contains information about the result of syncing the supplied
+ * batch to the target project.
+ */
+ protected CompletionStage processBatch(
+ @Nonnull final List> batch) {
+
+ final Set> validCustomObjectDrafts = batch.stream().filter(
+ this::validateDraft).collect(toSet());
+
+ if (validCustomObjectDrafts.isEmpty()) {
+ statistics.incrementProcessed(batch.size());
+ return completedFuture(statistics);
+ } else {
+ final Set identifiers = validCustomObjectDrafts.stream().map(
+ CustomObjectCompositeIdentifier::of).collect(toSet());
+
+ return customObjectService
+ .fetchMatchingCustomObjects(identifiers)
+ .handle(ImmutablePair::new)
+ .thenCompose(fetchResponse -> {
+ final Set> fetchedCustomObjects = fetchResponse.getKey();
+ final Throwable exception = fetchResponse.getValue();
+
+ if (exception != null) {
+ final String errorMessage = format(CTP_CUSTOM_OBJECT_FETCH_FAILED, identifiers);
+ handleError(errorMessage, exception, identifiers.size());
+ return CompletableFuture.completedFuture(null);
+ } else {
+ return syncBatch(fetchedCustomObjects, validCustomObjectDrafts);
+ }
+ })
+ .thenApply(ignored -> {
+ statistics.incrementProcessed(batch.size());
+ return statistics;
+ });
+ }
+ }
+
+ /**
+ * Checks if a draft is empty for further processing. If so, then returns {@code true}. Otherwise handles an error
+ * and returns {@code false}. A valid draft is a {@link CustomObjectDraft} object that is not {@code null}.
+ *
+ * @param draft nullable draft
+ * @return boolean that indicate if given {@code draft} is valid for sync
+ */
+ private boolean validateDraft(@Nullable final CustomObjectDraft draft) {
+ if (draft == null) {
+ handleError(CUSTOM_OBJECT_DRAFT_IS_NULL, null, 1);
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Given a {@link String} {@code errorMessage} and a {@link Throwable} {@code exception}, this method calls the
+ * optional error callback specified in the {@code syncOptions} and updates the {@code statistics} instance by
+ * incrementing the total number of failed custom objects to sync.
+ *
+ * @param errorMessage The error message describing the reason(s) of failure.
+ * @param exception The exception that called caused the failure, if any.
+ * @param failedTimes The number of times that the failed custom objects counter is incremented.
+ */
+ private void handleError(@Nonnull final String errorMessage, @Nullable final Throwable exception,
+ final int failedTimes) {
+ SyncException syncException = exception != null ? new SyncException(errorMessage, exception)
+ : new SyncException(errorMessage);
+ syncOptions.applyErrorCallback(syncException);
+ statistics.incrementFailed(failedTimes);
+ }
+
+ /**
+ * Given a {@link String} {@code errorMessage} and a {@link Throwable} {@code exception}, this method calls the
+ * optional error callback specified in the {@code syncOptions} and updates the {@code statistics} instance by
+ * incrementing the total number of failed custom objects to sync.
+ *
+ * @param errorMessage The error message describing the reason(s) of failure.
+ * @param exception The exception that called caused the failure, if any.
+ * @param failedTimes The number of times that the failed custom objects counter is incremented.
+ * @param oldCustomObject existing custom object that could be updated.
+ * @param newCustomObjectDraft draft containing data that could differ from data in {@code oldCustomObject}.
+ */
+ private void handleError(@Nonnull final String errorMessage, @Nullable final Throwable exception,
+ final int failedTimes, @Nullable final CustomObject oldCustomObject,
+ @Nullable final CustomObjectDraft newCustomObjectDraft) {
+
+ SyncException syncException = exception != null ? new SyncException(errorMessage, exception)
+ : new SyncException(errorMessage);
+ syncOptions.applyErrorCallback(syncException, oldCustomObject, newCustomObjectDraft, null);
+ statistics.incrementFailed(failedTimes);
+ }
+
+ /**
+ * Given a set of custom object drafts, attempts to sync the drafts with the existing custom objects in the CTP
+ * project. The custom object and the draft are considered to match if they have the same key and container.
+ *
+ * @param oldCustomObjects old custom objects.
+ * @param newCustomObjectDrafts drafts that need to be synced.
+ * @return a {@link CompletionStage} which contains an empty result after execution of the update
+ */
+ @Nonnull
+ private CompletionStage syncBatch(
+ @Nonnull final Set> oldCustomObjects,
+ @Nonnull final Set> newCustomObjectDrafts) {
+
+ final Map> oldCustomObjectMap =
+ oldCustomObjects.stream().collect(
+ toMap(customObject -> CustomObjectCompositeIdentifier.of(
+ customObject.getKey(), customObject.getContainer()).toString(), identity()));
+
+ return CompletableFuture.allOf(newCustomObjectDrafts
+ .stream()
+ .map(newCustomObjectDraft -> {
+ final CustomObject oldCustomObject = oldCustomObjectMap.get(
+ CustomObjectCompositeIdentifier.of(newCustomObjectDraft).toString());
+ return ofNullable(oldCustomObject)
+ .map(customObject -> updateCustomObject(oldCustomObject, newCustomObjectDraft))
+ .orElseGet(() -> applyCallbackAndCreate(newCustomObjectDraft));
+ })
+ .map(CompletionStage::toCompletableFuture)
+ .toArray(CompletableFuture[]::new));
+ }
+
+ /**
+ * Given a custom object draft, this method applies the beforeCreateCallback and then issues a create request to the
+ * CTP project to create the corresponding CustomObject.
+ *
+ * @param customObjectDraft the custom object draft to create the custom object from.
+ * @return a {@link CompletionStage} which contains created custom object after success execution of the create.
+ * Otherwise it contains an empty result in case of failure.
+ */
+ @Nonnull
+ private CompletionStage>> applyCallbackAndCreate(
+ @Nonnull final CustomObjectDraft customObjectDraft) {
+
+ return syncOptions
+ .applyBeforeCreateCallback(customObjectDraft)
+ .map(draft -> customObjectService
+ .upsertCustomObject(draft)
+ .thenApply(customObjectOptional -> {
+ if (customObjectOptional.isPresent()) {
+ statistics.incrementCreated();
+ } else {
+ statistics.incrementFailed();
+ }
+ return customObjectOptional;
+ }).exceptionally(sphereException -> {
+ final String errorMessage =
+ format(CTP_CUSTOM_OBJECT_CREATE_FAILED,
+ CustomObjectCompositeIdentifier.of(customObjectDraft).toString(),
+ sphereException.getMessage());
+ handleError(errorMessage, sphereException, 1,
+ null, customObjectDraft);
+ return Optional.empty();
+ })
+ ).orElse(completedFuture(Optional.empty()));
+ }
+
+ /**
+ * Given an existing {@link CustomObject} and a new {@link CustomObjectDraft}, the method first checks whether
+ * existing {@link CustomObject} and a new {@link CustomObjectDraft} are identical. If so, the method aborts update
+ * the new draft and return an empty result, otherwise a request is made to CTP to update the existing custom
+ * object.
+ *
+ * The {@code statistics} instance is updated accordingly to whether the CTP request was carried
+ * out successfully or not. If an exception was thrown on executing the request to CTP,the error handling method
+ * is called.
+ *
+ * @param oldCustomObject existing custom object that could be updated.
+ * @param newCustomObject draft containing data that could differ from data in {@code oldCustomObject}.
+ * @return a {@link CompletionStage} which contains an empty result after execution of the update.
+ */
+ @Nonnull
+ private CompletionStage>> updateCustomObject(
+ @Nonnull final CustomObject oldCustomObject,
+ @Nonnull final CustomObjectDraft newCustomObject) {
+
+ if (!CustomObjectSyncUtils.hasIdenticalValue(oldCustomObject, newCustomObject)) {
+ return customObjectService
+ .upsertCustomObject(newCustomObject)
+ .handle(ImmutablePair::new)
+ .thenCompose(updatedResponseEntry -> {
+ final Optional> updateCustomObjectOptional = updatedResponseEntry.getKey();
+ final Throwable sphereException = updatedResponseEntry.getValue();
+ if (sphereException != null) {
+ return executeSupplierIfConcurrentModificationException(sphereException,
+ () -> fetchAndUpdate(oldCustomObject, newCustomObject),
+ () -> {
+ final String errorMessage =
+ format(CTP_CUSTOM_OBJECT_UPDATE_FAILED,
+ CustomObjectCompositeIdentifier.of(newCustomObject).toString(),
+ sphereException.getMessage());
+ handleError(errorMessage, sphereException, 1,
+ oldCustomObject, newCustomObject);
+ return CompletableFuture.completedFuture(Optional.empty());
+ });
+ } else {
+ statistics.incrementUpdated();
+ return CompletableFuture.completedFuture(Optional.of(updateCustomObjectOptional.get()));
+ }
+
+ });
+ }
+ return completedFuture(Optional.empty());
+ }
+
+ @Nonnull
+ private CompletionStage>> fetchAndUpdate(
+ @Nonnull final CustomObject oldCustomObject,
+ @Nonnull final CustomObjectDraft customObjectDraft) {
+
+ final CustomObjectCompositeIdentifier identifier = CustomObjectCompositeIdentifier.of(oldCustomObject);
+
+ return customObjectService
+ .fetchCustomObject(identifier)
+ .handle(ImmutablePair::new)
+ .thenCompose(fetchedResponseEntry -> {
+ final Optional> fetchedCustomObjectOptional = fetchedResponseEntry.getKey();
+ final Throwable exception = fetchedResponseEntry.getValue();
+
+ if (exception != null) {
+ final String errorMessage = format(CTP_CUSTOM_OBJECT_UPDATE_FAILED, identifier.toString(),
+ "Failed to fetch from CTP while retrying after concurrency modification.");
+ handleError(errorMessage, exception, 1, oldCustomObject, customObjectDraft);
+ return CompletableFuture.completedFuture(Optional.empty());
+ }
+ return fetchedCustomObjectOptional
+ .map(fetchedCustomObject -> updateCustomObject(fetchedCustomObject, customObjectDraft))
+ .orElseGet(() -> {
+ final String errorMessage =
+ format(CTP_CUSTOM_OBJECT_UPDATE_FAILED, identifier.toString(),
+ "Not found when attempting to fetch while retrying "
+ + "after concurrency modification.");
+ handleError(errorMessage, null, 1,
+ oldCustomObject, customObjectDraft);
+ return CompletableFuture.completedFuture(null);
+ });
+
+ });
+ }
+}
diff --git a/src/main/java/com/commercetools/sync/customobjects/CustomObjectSyncOptions.java b/src/main/java/com/commercetools/sync/customobjects/CustomObjectSyncOptions.java
index c27eae1065..04b754fbab 100644
--- a/src/main/java/com/commercetools/sync/customobjects/CustomObjectSyncOptions.java
+++ b/src/main/java/com/commercetools/sync/customobjects/CustomObjectSyncOptions.java
@@ -5,29 +5,33 @@
import com.commercetools.sync.commons.utils.QuadConsumer;
import com.commercetools.sync.commons.utils.TriConsumer;
import com.commercetools.sync.commons.utils.TriFunction;
+import com.fasterxml.jackson.databind.JsonNode;
import io.sphere.sdk.client.SphereClient;
import io.sphere.sdk.commands.UpdateAction;
import io.sphere.sdk.customobjects.CustomObject;
import io.sphere.sdk.customobjects.CustomObjectDraft;
-
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
-public final class CustomObjectSyncOptions extends BaseSyncOptions {
+public final class CustomObjectSyncOptions extends BaseSyncOptions,
+ CustomObjectDraft> {
CustomObjectSyncOptions(
@Nonnull final SphereClient ctpClient,
- @Nullable final QuadConsumer, Optional,
- List>> errorCallBack,
- @Nullable final TriConsumer, Optional>
+ @Nullable final QuadConsumer>,
+ Optional>,
+ List>>> errorCallBack,
+ @Nullable final TriConsumer>,
+ Optional>>
warningCallBack,
final int batchSize,
- @Nullable final TriFunction>, CustomObjectDraft, CustomObject,
- List>> beforeUpdateCallback,
- @Nullable final Function beforeCreateCallback) {
+ @Nullable final TriFunction>>, CustomObjectDraft,
+ CustomObject,
+ List>>> beforeUpdateCallback,
+ @Nullable final Function, CustomObjectDraft> beforeCreateCallback) {
super(
ctpClient,
errorCallBack,
@@ -36,5 +40,4 @@ public final class CustomObjectSyncOptions extends BaseSyncOptions {
+ CustomObjectSyncOptions, CustomObject, CustomObjectDraft> {
public static final int BATCH_SIZE_DEFAULT = 50;
diff --git a/src/main/java/com/commercetools/sync/customobjects/helpers/CustomObjectCompositeIdentifier.java b/src/main/java/com/commercetools/sync/customobjects/helpers/CustomObjectCompositeIdentifier.java
index 73b57e7e63..e5f9700b59 100644
--- a/src/main/java/com/commercetools/sync/customobjects/helpers/CustomObjectCompositeIdentifier.java
+++ b/src/main/java/com/commercetools/sync/customobjects/helpers/CustomObjectCompositeIdentifier.java
@@ -4,6 +4,7 @@
import io.sphere.sdk.customobjects.CustomObjectDraft;
import javax.annotation.Nonnull;
+import java.util.Objects;
import static java.lang.String.format;
@@ -19,19 +20,18 @@ public final class CustomObjectCompositeIdentifier {
private final String container;
private CustomObjectCompositeIdentifier(@Nonnull final String key,
- @Nonnull final String container) {
+ @Nonnull final String container) {
this.key = key;
this.container = container;
}
-
/**
* Given a {@link CustomObjectDraft}, creates a {@link CustomObjectCompositeIdentifier} using the following fields
* from the supplied {@link CustomObjectDraft}:
*
* - {@link CustomObjectCompositeIdentifier#key}: key of {@link CustomObjectDraft#getKey()}
* - {@link CustomObjectCompositeIdentifier#container}: container of {@link CustomObjectDraft#getContainer()}
-
+ *
*
*
* @param customObjectDraft a composite id is built using its fields.
@@ -62,7 +62,7 @@ public static CustomObjectCompositeIdentifier of(@Nonnull final CustomObject cus
* Given a {@link String} and {@link String}, creates a {@link CustomObjectCompositeIdentifier} using the following
* fields from the supplied attributes.
*
- * @param key key of CustomerObject to build composite Id.
+ * @param key key of CustomerObject to build composite Id.
* @param container container of CustomerObject to build composite Id.
* @return a composite id comprised of the fields of the supplied {@code key} and {@code container}.
*/
@@ -83,4 +83,21 @@ public String getContainer() {
public String toString() {
return format("{key='%s', container='%s'}", key, container);
}
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof CustomObjectCompositeIdentifier)) {
+ return false;
+ }
+ final CustomObjectCompositeIdentifier that = (CustomObjectCompositeIdentifier) obj;
+ return key.equals(that.key) && container.equals(that.container);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(key, container);
+ }
}
diff --git a/src/main/java/com/commercetools/sync/customobjects/helpers/CustomObjectSyncStatistics.java b/src/main/java/com/commercetools/sync/customobjects/helpers/CustomObjectSyncStatistics.java
new file mode 100644
index 0000000000..3950da3c1c
--- /dev/null
+++ b/src/main/java/com/commercetools/sync/customobjects/helpers/CustomObjectSyncStatistics.java
@@ -0,0 +1,23 @@
+package com.commercetools.sync.customobjects.helpers;
+
+import com.commercetools.sync.commons.helpers.BaseSyncStatistics;
+
+import static java.lang.String.format;
+
+public class CustomObjectSyncStatistics extends BaseSyncStatistics {
+ /**
+ * Builds a summary of the custom object sync statistics instance that looks like the following example:
+ *
+ * "Summary: 2 custom objects were processed in total (0 created, 0 updated and 0 failed to sync)."
+ *
+ * @return a summary message of the custom objects sync statistics instance.
+ */
+ @Override
+ public String getReportMessage() {
+ reportMessage = format(
+ "Summary: %s custom objects were processed in total (%s created, %s updated and %s failed to sync).",
+ getProcessed(), getCreated(), getUpdated(), getFailed());
+
+ return reportMessage;
+ }
+}
diff --git a/src/main/java/com/commercetools/sync/customobjects/utils/CustomObjectSyncUtils.java b/src/main/java/com/commercetools/sync/customobjects/utils/CustomObjectSyncUtils.java
new file mode 100644
index 0000000000..498da3941c
--- /dev/null
+++ b/src/main/java/com/commercetools/sync/customobjects/utils/CustomObjectSyncUtils.java
@@ -0,0 +1,28 @@
+package com.commercetools.sync.customobjects.utils;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.sphere.sdk.customobjects.CustomObject;
+import io.sphere.sdk.customobjects.CustomObjectDraft;
+
+import javax.annotation.Nonnull;
+
+public class CustomObjectSyncUtils {
+
+ /**
+ * Compares the value of a {@link CustomObject} to the value of a {@link CustomObjectDraft}.
+ * It returns a boolean whether the values are identical or not.
+ *
+ * @param oldCustomObject the {@link CustomObject} which should be synced.
+ * @param newCustomObject the {@link CustomObjectDraft} with the new data.
+ * @return A boolean whether the value of the CustomObject and CustomObjectDraft is identical or not.
+ */
+
+ public static boolean hasIdenticalValue(
+ @Nonnull final CustomObject oldCustomObject,
+ @Nonnull final CustomObjectDraft newCustomObject) {
+ JsonNode oldValue = oldCustomObject.getValue();
+ JsonNode newValue = newCustomObject.getValue();
+
+ return oldValue.equals(newValue);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/com/commercetools/sync/services/CustomObjectService.java b/src/main/java/com/commercetools/sync/services/CustomObjectService.java
index 07fb83a0cc..88ed832aef 100644
--- a/src/main/java/com/commercetools/sync/services/CustomObjectService.java
+++ b/src/main/java/com/commercetools/sync/services/CustomObjectService.java
@@ -23,11 +23,11 @@ public interface CustomObjectService {
* a {@link CompletionStage}<{@link Optional}<{@link String}>>
* in which the {@link Optional} could contain the id inside of it.
*
- * @param identifier the identifier object containing CustomObject key and container, by which a
- * {@link io.sphere.sdk.customobjects.CustomObject} id should be fetched from the CTP project.
+ * @param identifier the identifier object containing CustomObject key and container, by which a
+ * {@link io.sphere.sdk.customobjects.CustomObject} id should be fetched from the CTP project.
* @return {@link CompletionStage}<{@link Optional}<{@link String}>> in which the result of its
- * completion could contain an {@link Optional} with the id inside of it or an empty {@link Optional} if no
- * {@link CustomObject} was found in the CTP project with this identifier.
+ * completion could contain an {@link Optional} with the id inside of it or an empty {@link Optional} if no
+ * {@link CustomObject} was found in the CTP project with this identifier.
*/
@Nonnull
@@ -42,7 +42,7 @@ public interface CustomObjectService {
* @param identifiers set of CustomObjectCompositeIdentifiers. Each identifier includes key and container to fetch
* matching CustomObject.
* @return {@link CompletionStage}<{@link Map}> in which the result of its completion contains a {@link Set}
- * of all matching CustomObjects.
+ * of all matching CustomObjects.
*/
@Nonnull
CompletionStage>> fetchMatchingCustomObjects(
@@ -56,7 +56,7 @@ CompletionStage>> fetchMatchingCustomObjects(
*
* @param identifier the identifier of the CustomObject to fetch.
* @return {@link CompletionStage}<{@link Optional}> in which the result of its completion contains an
- * {@link Optional} that contains the matching {@link CustomObject} if exists, otherwise empty.
+ * {@link Optional} that contains the matching {@link CustomObject} if exists, otherwise empty.
*/
@Nonnull
CompletionStage>> fetchCustomObject(
@@ -82,7 +82,7 @@ CompletionStage>> fetchCustomObject(
*
* @param customObjectDraft the resource draft to create or update a resource based off of.
* @return a {@link CompletionStage} containing an optional with the created/updated resource if successful
- * otherwise an empty optional.
+ * otherwise an empty optional.
*/
@Nonnull
CompletionStage>> upsertCustomObject(
diff --git a/src/main/java/com/commercetools/sync/services/impl/BaseService.java b/src/main/java/com/commercetools/sync/services/impl/BaseService.java
index 808851563d..3358c607f1 100644
--- a/src/main/java/com/commercetools/sync/services/impl/BaseService.java
+++ b/src/main/java/com/commercetools/sync/services/impl/BaseService.java
@@ -43,7 +43,7 @@
* @param Expansion Model (e.g. {@link io.sphere.sdk.products.expansion.ProductExpansionModel},
* {@link io.sphere.sdk.categories.expansion.CategoryExpansionModel}, etc..
*/
-abstract class BaseService, S extends BaseSyncOptions,
+abstract class BaseService, S extends BaseSyncOptions,
Q extends MetaModelQueryDsl, M, E> {
final S syncOptions;
@@ -67,7 +67,7 @@ abstract class BaseService, S extends BaseSyncOpt
* resource.
* @param updateActions the update actions to execute on the resource.
* @return an instance of {@link CompletionStage}<{@code U}> which contains as a result an instance of
- * the resource {@link U} after all the update actions have been executed.
+ * the resource {@link U} after all the update actions have been executed.
*/
@Nonnull
CompletionStage updateResource(
@@ -91,7 +91,7 @@ CompletionStage updateResource(
* resource.
* @param batches the batches of update actions to execute.
* @return an instance of {@link CompletionStage}<{@code U}> which contains as a result an instance of
- * the resource {@link U} after all the update actions in all batches have been executed.
+ * the resource {@link U} after all the update actions in all batches have been executed.
*/
@Nonnull
private CompletionStage updateBatches(
@@ -125,7 +125,7 @@ private CompletionStage updateBatches(
* @param keyMapper a function to get the key from the supplied draft.
* @param createCommand a function to get the create command using the supplied draft.
* @return a {@link CompletionStage} containing an optional with the created resource if successful otherwise an
- * empty optional.
+ * empty optional.
*/
@SuppressWarnings("unchecked")
@Nonnull
@@ -142,22 +142,8 @@ CompletionStage> createResource(
null, draft, null);
return CompletableFuture.completedFuture(Optional.empty());
} else {
- return syncOptions
- .getCtpClient()
- .execute(createCommand.apply(draft))
- .handle(((resource, exception) -> {
- if (exception == null) {
- keyToIdCache.put(draftKey, resource.getId());
- return Optional.of(resource);
- } else {
- syncOptions.applyErrorCallback(
- new SyncException(format(CREATE_FAILED, draftKey, exception.getMessage()), exception),
- null, draft, null);
- return Optional.empty();
- }
- }));
+ return executeCreateCommand(draft, keyMapper, createCommand);
}
-
}
/**
@@ -173,8 +159,8 @@ CompletionStage> createResource(
* @param keyMapper a function to get the key from the resource.
* @param querySupplier supplies the query to fetch the resource with the given key.
* @return {@link CompletionStage}<{@link Optional}<{@link String}>> in which the result of it's
- * completion could contain an {@link Optional} with the id inside of it or an empty {@link Optional} if no
- * resource was found in the CTP project with this key.
+ * completion could contain an {@link Optional} with the id inside of it or an empty {@link Optional} if no
+ * resource was found in the CTP project with this key.
*/
@Nonnull
CompletionStage> fetchCachedResourceId(
@@ -247,7 +233,7 @@ CompletionStage> cacheKeysToIds(
* @param keyMapper a function to get the key from the resource.
* @param querySupplier supplies the query to fetch the resources with the given keys.
* @return {@link CompletionStage}<{@link Set}<{@code U}>> in which the result of it's completion
- * contains a {@link Set} of all matching resources.
+ * contains a {@link Set} of all matching resources.
*/
@Nonnull
CompletionStage> fetchMatchingResources(
@@ -277,7 +263,7 @@ CompletionStage> fetchMatchingResources(
* @param key the key of the resource to fetch
* @param querySupplier supplies the query to fetch the resource with the given key.
* @return {@link CompletionStage}<{@link Optional}> in which the result of it's completion contains an
- * {@link Optional} that contains the matching {@code T} if exists, otherwise empty.
+ * {@link Optional} that contains the matching {@code T} if exists, otherwise empty.
*/
@Nonnull
CompletionStage> fetchResource(
@@ -299,4 +285,27 @@ CompletionStage> fetchResource(
}));
}
+ @Nonnull
+ CompletionStage> executeCreateCommand(
+ @Nonnull final T draft,
+ @Nonnull final Function keyMapper,
+ @Nonnull final Function> createCommand) {
+
+ final String draftKey = keyMapper.apply(draft);
+
+ return syncOptions
+ .getCtpClient()
+ .execute(createCommand.apply(draft))
+ .handle(((resource, exception) -> {
+ if (exception == null) {
+ keyToIdCache.put(draftKey, resource.getId());
+ return Optional.of(resource);
+ } else {
+ syncOptions.applyErrorCallback(
+ new SyncException(format(CREATE_FAILED, draftKey, exception.getMessage()), exception),
+ null, draft, null);
+ return Optional.empty();
+ }
+ }));
+ }
}
diff --git a/src/main/java/com/commercetools/sync/services/impl/BaseServiceWithKey.java b/src/main/java/com/commercetools/sync/services/impl/BaseServiceWithKey.java
index 6b84b7c99f..47427a5cc7 100644
--- a/src/main/java/com/commercetools/sync/services/impl/BaseServiceWithKey.java
+++ b/src/main/java/com/commercetools/sync/services/impl/BaseServiceWithKey.java
@@ -29,7 +29,7 @@
* {@link io.sphere.sdk.categories.expansion.CategoryExpansionModel}, etc..
*/
abstract class BaseServiceWithKey & WithKey, S extends BaseSyncOptions,
- Q extends MetaModelQueryDsl, M, E> extends BaseService {
+ Q extends MetaModelQueryDsl, M, E> extends BaseService {
BaseServiceWithKey(@Nonnull final S syncOptions) {
super(syncOptions);
@@ -52,7 +52,7 @@ abstract class BaseServiceWithKey & Wit
* @param draft the resource draft to create a resource based off of.
* @param createCommand a function to get the create command using the supplied draft.
* @return a {@link CompletionStage} containing an optional with the created resource if successful otherwise an
- * empty optional.
+ * empty optional.
*/
@Nonnull
CompletionStage> createResource(
@@ -71,11 +71,11 @@ CompletionStage> createResource(
* could contain an {@link Optional} with the id inside of it or an empty {@link Optional} if no resource
* was found in the CTP project with this key.
*
- * @param key the key by which a resource id should be fetched from the CTP project.
+ * @param key the key by which a resource id should be fetched from the CTP project.
* @param querySupplier supplies the query to fetch the resource with the given key.
* @return {@link CompletionStage}<{@link Optional}<{@link String}>> in which the result of it's
- * completion could contain an {@link Optional} with the id inside of it or an empty {@link Optional} if no
- * resource was found in the CTP project with this key.
+ * completion could contain an {@link Optional} with the id inside of it or an empty {@link Optional} if no
+ * resource was found in the CTP project with this key.
*/
@Nonnull
CompletionStage> fetchCachedResourceId(
@@ -92,7 +92,7 @@ CompletionStage> fetchCachedResourceId(
* Given a set of keys this method caches a mapping of the keys to ids of such keys only for the keys which are
* not already in the cache.
*
- * @param keys keys to cache.
+ * @param keys keys to cache.
* @param keysQueryMapper function that accepts a set of keys which are not cached and maps it to a query object
* representing the query to CTP on such keys.
* @return a map of key to ids of the requested keys.
@@ -112,10 +112,10 @@ CompletionStage> cacheKeysToIds(
* keys in the CTP project, defined in an injected {@link SphereClient}. A mapping of the key to the id
* of the fetched resources is persisted in an in-memory map.
*
- * @param keys set of state keys to fetch matching states by
+ * @param keys set of state keys to fetch matching states by
* @param querySupplier supplies the query to fetch the resources with the given keys.
* @return {@link CompletionStage}<{@link Set}<{@code U}>> in which the result of it's completion
- * contains a {@link Set} of all matching resources.
+ * contains a {@link Set} of all matching resources.
*/
@Nonnull
CompletionStage> fetchMatchingResources(
diff --git a/src/main/java/com/commercetools/sync/services/impl/CustomObjectServiceImpl.java b/src/main/java/com/commercetools/sync/services/impl/CustomObjectServiceImpl.java
index e91b0aa5db..7c6410ee3e 100644
--- a/src/main/java/com/commercetools/sync/services/impl/CustomObjectServiceImpl.java
+++ b/src/main/java/com/commercetools/sync/services/impl/CustomObjectServiceImpl.java
@@ -1,9 +1,11 @@
package com.commercetools.sync.services.impl;
+import com.commercetools.sync.customobjects.CustomObjectSync;
import com.commercetools.sync.customobjects.CustomObjectSyncOptions;
import com.commercetools.sync.customobjects.helpers.CustomObjectCompositeIdentifier;
import com.commercetools.sync.services.CustomObjectService;
import com.fasterxml.jackson.databind.JsonNode;
+import io.sphere.sdk.commands.DraftBasedCreateCommand;
import io.sphere.sdk.customobjects.CustomObject;
import io.sphere.sdk.customobjects.CustomObjectDraft;
import io.sphere.sdk.customobjects.commands.CustomObjectUpsertCommand;
@@ -20,6 +22,7 @@
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
+import java.util.function.Function;
import java.util.stream.Collectors;
/**
@@ -32,7 +35,7 @@ public class CustomObjectServiceImpl
CustomObjectSyncOptions,
CustomObjectQuery,
CustomObjectQueryModel>, CustomObjectExpansionModel>>
- implements CustomObjectService {
+ implements CustomObjectService {
public CustomObjectServiceImpl(@Nonnull final CustomObjectSyncOptions syncOptions) {
super(syncOptions);
@@ -41,7 +44,7 @@ public CustomObjectServiceImpl(@Nonnull final CustomObjectSyncOptions syncOption
@Nonnull
@Override
public CompletionStage> fetchCachedCustomObjectId(
- @Nonnull final CustomObjectCompositeIdentifier identifier) {
+ @Nonnull final CustomObjectCompositeIdentifier identifier) {
String container = identifier.getContainer();
String key = identifier.getKey();
@@ -53,19 +56,19 @@ public CompletionStage> fetchCachedCustomObjectId(
return fetchCachedResourceId(identifier.toString(),
draft -> CustomObjectCompositeIdentifier.of(draft).toString(),
() -> CustomObjectQuery.ofJsonNode()
- .withPredicates(q -> q.container().is(container).and(q.key().is(key)))
+ .withPredicates(q -> q.container().is(container).and(q.key().is(key)))
);
}
@Nonnull
@Override
public CompletionStage>> fetchMatchingCustomObjects(
- @Nonnull final Set identifiers) {
+ @Nonnull final Set identifiers) {
Set filteredIdentifiers = identifiers.stream()
.filter(identifier ->
- StringUtils.isNotEmpty(identifier.getContainer())
- && StringUtils.isNotEmpty(identifier.getKey()))
+ StringUtils.isNotEmpty(identifier.getContainer())
+ && StringUtils.isNotEmpty(identifier.getKey()))
.collect(Collectors.toSet());
if (filteredIdentifiers.size() == 0) {
@@ -73,9 +76,9 @@ public CompletionStage>> fetchMatchingCustomObjects(
}
Set identifierStrings =
- filteredIdentifiers.stream()
- .map(CustomObjectCompositeIdentifier::toString)
- .collect(Collectors.toSet());
+ filteredIdentifiers.stream()
+ .map(CustomObjectCompositeIdentifier::toString)
+ .collect(Collectors.toSet());
return fetchMatchingResources(identifierStrings,
draft -> CustomObjectCompositeIdentifier.of(draft).toString(),
@@ -88,8 +91,8 @@ public CompletionStage>> fetchMatchingCustomObjects(
@Nonnull
private QueryPredicate> createQuery(
- @Nonnull final CustomObjectQueryModel> queryModel,
- @Nonnull final Set identifiers) {
+ @Nonnull final CustomObjectQueryModel> queryModel,
+ @Nonnull final Set identifiers) {
QueryPredicate> queryPredicate = QueryPredicate.of(null);
boolean firstAttempt = true;
@@ -109,7 +112,7 @@ private QueryPredicate> createQuery(
@Nonnull
@Override
public CompletionStage>> fetchCustomObject(
- @Nonnull final CustomObjectCompositeIdentifier identifier) {
+ @Nonnull final CustomObjectCompositeIdentifier identifier) {
String container = identifier.getContainer();
String key = identifier.getKey();
@@ -131,8 +134,42 @@ public CompletionStage>> upsertCustomObject(
if (StringUtils.isEmpty(customObjectDraft.getKey()) || StringUtils.isEmpty(customObjectDraft.getContainer())) {
return CompletableFuture.completedFuture(Optional.empty());
}
- return createResource(customObjectDraft,
- draft -> CustomObjectCompositeIdentifier.of(draft).toString(),
- CustomObjectUpsertCommand::of);
+ CompletionStage>> createdResource = createResource(customObjectDraft,
+ draft -> CustomObjectCompositeIdentifier.of(draft).toString(), CustomObjectUpsertCommand::of);
+ return createdResource ;
+ }
+
+ /**
+ * Custom object has special behaviour that it only performs upsert operation. That means both update and create
+ * custom object operations in the end called {@link BaseService#createResource}, which is different from other
+ * resources.
+ *
+ * This method provides a specific exception handling after execution of create command for custom objects.
+ * Any exception that occurs inside executeCreateCommand method is thrown to the caller method in
+ * {@link CustomObjectSync}, which is necessary to trigger retry on error behaviour.
+ *
+ * @param draft the custom object draft to create a custom object in target CTP project.
+ * @param keyMapper a function to get the key from the supplied custom object draft.
+ * @param createCommand a function to get the create command using the supplied custom object draft.
+ * @return a {@link CompletionStage} containing an optional with the created resource if successful otherwise an
+ * exception.
+ */
+ @Nonnull
+ @Override
+ CompletionStage>> executeCreateCommand(
+ @Nonnull final CustomObjectDraft draft,
+ @Nonnull final Function, String> keyMapper,
+ @Nonnull final Function,
+ DraftBasedCreateCommand, CustomObjectDraft>> createCommand) {
+
+ final String draftKey = keyMapper.apply(draft);
+
+ return syncOptions
+ .getCtpClient()
+ .execute(createCommand.apply(draft))
+ .thenApply(resource -> {
+ keyToIdCache.put(draftKey, resource.getId());
+ return Optional.of(resource);
+ });
}
}
diff --git a/src/test/java/com/commercetools/sync/commons/asserts/statistics/AssertionsForStatistics.java b/src/test/java/com/commercetools/sync/commons/asserts/statistics/AssertionsForStatistics.java
index 5365cdf359..e7b8e7d6de 100644
--- a/src/test/java/com/commercetools/sync/commons/asserts/statistics/AssertionsForStatistics.java
+++ b/src/test/java/com/commercetools/sync/commons/asserts/statistics/AssertionsForStatistics.java
@@ -2,6 +2,7 @@
import com.commercetools.sync.cartdiscounts.helpers.CartDiscountSyncStatistics;
import com.commercetools.sync.categories.helpers.CategorySyncStatistics;
+import com.commercetools.sync.customobjects.helpers.CustomObjectSyncStatistics;
import com.commercetools.sync.inventories.helpers.InventorySyncStatistics;
import com.commercetools.sync.products.helpers.ProductSyncStatistics;
import com.commercetools.sync.producttypes.helpers.ProductTypeSyncStatistics;
@@ -103,4 +104,15 @@ public static StateSyncStatisticsAssert assertThat(@Nullable final StateSyncStat
public static TaxCategorySyncStatisticsAssert assertThat(@Nullable final TaxCategorySyncStatistics statistics) {
return new TaxCategorySyncStatisticsAssert(statistics);
}
+
+ /**
+ * Create assertion for {@link CustomObjectSyncStatistics}.
+ *
+ * @param statistics the actual value.
+ * @return the created assertion object.
+ */
+ @Nonnull
+ public static CustomObjectSyncStatisticsAssert assertThat(@Nullable final CustomObjectSyncStatistics statistics) {
+ return new CustomObjectSyncStatisticsAssert(statistics);
+ }
}
diff --git a/src/test/java/com/commercetools/sync/commons/asserts/statistics/CustomObjectSyncStatisticsAssert.java b/src/test/java/com/commercetools/sync/commons/asserts/statistics/CustomObjectSyncStatisticsAssert.java
new file mode 100644
index 0000000000..63f43198d3
--- /dev/null
+++ b/src/test/java/com/commercetools/sync/commons/asserts/statistics/CustomObjectSyncStatisticsAssert.java
@@ -0,0 +1,12 @@
+package com.commercetools.sync.commons.asserts.statistics;
+
+import com.commercetools.sync.customobjects.helpers.CustomObjectSyncStatistics;
+import javax.annotation.Nullable;
+
+public final class CustomObjectSyncStatisticsAssert extends
+ AbstractSyncStatisticsAssert {
+
+ CustomObjectSyncStatisticsAssert(@Nullable final CustomObjectSyncStatistics actual) {
+ super(actual, CustomObjectSyncStatisticsAssert.class);
+ }
+}
diff --git a/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncOptionsBuilderTest.java b/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncOptionsBuilderTest.java
new file mode 100644
index 0000000000..915e9cad65
--- /dev/null
+++ b/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncOptionsBuilderTest.java
@@ -0,0 +1,189 @@
+package com.commercetools.sync.customobjects;
+
+import com.commercetools.sync.commons.exceptions.SyncException;
+import com.commercetools.sync.commons.utils.QuadConsumer;
+import com.commercetools.sync.commons.utils.TriConsumer;
+import com.commercetools.sync.commons.utils.TriFunction;
+import com.fasterxml.jackson.databind.JsonNode;
+import io.sphere.sdk.client.SphereClient;
+import io.sphere.sdk.commands.UpdateAction;
+import io.sphere.sdk.customobjects.CustomObject;
+import io.sphere.sdk.customobjects.CustomObjectDraft;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import static java.util.Collections.emptyList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class CustomObjectSyncOptionsBuilderTest {
+
+ private static final SphereClient CTP_CLIENT = mock(SphereClient.class);
+ private CustomObjectSyncOptionsBuilder customObjectSyncOptionsBuilder =
+ CustomObjectSyncOptionsBuilder.of(CTP_CLIENT);
+
+
+ @Test
+ void of_WithClient_ShouldCreateCustomObjectSyncOptionsBuilder() {
+ final CustomObjectSyncOptionsBuilder builder = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT);
+ assertThat(builder).isNotNull();
+ }
+
+ @Test
+ void build_WithClient_ShouldBuildSyncOptions() {
+ final CustomObjectSyncOptions customObjectSyncOptions = customObjectSyncOptionsBuilder.build();
+ assertThat(customObjectSyncOptions).isNotNull();
+ assertThat(customObjectSyncOptions.getBeforeUpdateCallback()).isNull();
+ assertThat(customObjectSyncOptions.getBeforeCreateCallback()).isNull();
+ assertThat(customObjectSyncOptions.getErrorCallback()).isNull();
+ assertThat(customObjectSyncOptions.getWarningCallback()).isNull();
+ assertThat(customObjectSyncOptions.getCtpClient()).isEqualTo(CTP_CLIENT);
+ assertThat(customObjectSyncOptions.getBatchSize()).isEqualTo(CustomObjectSyncOptionsBuilder.BATCH_SIZE_DEFAULT);
+ }
+
+ @Test
+ void beforeCreateCallback_WithFilterAsCallback_ShouldSetCallback() {
+ customObjectSyncOptionsBuilder.beforeCreateCallback((newCustomObject) -> null);
+ final CustomObjectSyncOptions customObjectSyncOptions = customObjectSyncOptionsBuilder.build();
+ assertThat(customObjectSyncOptions.getBeforeCreateCallback()).isNotNull();
+ }
+
+ @Test
+ void errorCallBack_WithCallBack_ShouldSetCallBack() {
+ final QuadConsumer>,
+ Optional>, List>>>
+ mockErrorCallBack = (exception, newResource, oldResource, updateActions) -> { };
+ customObjectSyncOptionsBuilder.errorCallback(mockErrorCallBack);
+
+ final CustomObjectSyncOptions customObjectSyncOptions = customObjectSyncOptionsBuilder.build();
+ assertThat(customObjectSyncOptions.getErrorCallback()).isNotNull();
+ }
+
+ @Test
+ void warningCallBack_WithCallBack_ShouldSetCallBack() {
+ final TriConsumer>, Optional>> mockWarningCallBack =
+ (exception, newResource, oldResource) -> { };
+ customObjectSyncOptionsBuilder.warningCallback(mockWarningCallBack);
+ final CustomObjectSyncOptions cutomObjectSyncOptions = customObjectSyncOptionsBuilder.build();
+ assertThat(cutomObjectSyncOptions.getWarningCallback()).isNotNull();
+ }
+
+ @Test
+ void getThis_ShouldReturnCorrectInstance() {
+ final CustomObjectSyncOptionsBuilder instance = customObjectSyncOptionsBuilder.getThis();
+ assertThat(instance).isNotNull();
+ assertThat(instance).isInstanceOf(CustomObjectSyncOptionsBuilder.class);
+ assertThat(instance).isEqualTo(customObjectSyncOptionsBuilder);
+ }
+
+ @Test
+ void customObjectSyncOptionsBuilderSetters_ShouldBeCallableAfterBaseSyncOptionsBuildSetters() {
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder
+ .of(CTP_CLIENT)
+ .batchSize(30)
+ .beforeCreateCallback((newCustomObject) -> null)
+ .beforeUpdateCallback((updateActions, newCustomObject, oldCustomObject) -> emptyList())
+ .build();
+ assertThat(customObjectSyncOptions).isNotNull();
+ }
+
+ @Test
+ void batchSize_WithPositiveValue_ShouldSetBatchSize() {
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .batchSize(10)
+ .build();
+ assertThat(customObjectSyncOptions.getBatchSize()).isEqualTo(10);
+ }
+
+ @Test
+ void batchSize_WithZeroOrNegativeValue_ShouldFallBackToDefaultValue() {
+ final CustomObjectSyncOptions customObjectSyncOptionsWithZeroBatchSize =
+ CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .batchSize(0)
+ .build();
+ assertThat(customObjectSyncOptionsWithZeroBatchSize.getBatchSize())
+ .isEqualTo(CustomObjectSyncOptionsBuilder.BATCH_SIZE_DEFAULT);
+ final CustomObjectSyncOptions customObjectSyncOptionsWithNegativeBatchSize = CustomObjectSyncOptionsBuilder
+ .of(CTP_CLIENT)
+ .batchSize(-100)
+ .build();
+ assertThat(customObjectSyncOptionsWithNegativeBatchSize.getBatchSize())
+ .isEqualTo(CustomObjectSyncOptionsBuilder.BATCH_SIZE_DEFAULT);
+ }
+
+ @Test
+ void applyBeforeUpdateCallBack_WithNullReturnCallbackAndEmptyUpdateActions_ShouldReturnEmptyList() {
+ final TriFunction>>, CustomObjectDraft,
+ CustomObject, List>>>
+ beforeUpdateCallback = (updateActions, newCustomObject, oldCustomObject) -> null;
+
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .beforeUpdateCallback(
+ beforeUpdateCallback)
+ .build();
+ assertThat(customObjectSyncOptions.getBeforeUpdateCallback()).isNotNull();
+
+ final List>> updateActions = Collections.emptyList();
+
+ final List>> filteredList =
+ customObjectSyncOptions.applyBeforeUpdateCallback(
+ updateActions, mock(CustomObjectDraft.class), mock(CustomObject.class));
+ assertThat(filteredList).isEqualTo(updateActions);
+ assertThat(filteredList).isEmpty();
+ }
+
+ @Test
+ void applyBeforeCreateCallBack_WithCallback_ShouldReturnFilteredDraft() {
+ final Function, CustomObjectDraft> draftFunction =
+ customObjectDraft -> CustomObjectDraft.ofUnversionedUpsert(
+ customObjectDraft.getContainer() + "_filteredContainer",
+ customObjectDraft.getKey() + "_filteredKey",
+ (JsonNode) customObjectDraft.getValue());
+
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .beforeCreateCallback(
+ draftFunction)
+ .build();
+ assertThat(customObjectSyncOptions.getBeforeCreateCallback()).isNotNull();
+ final CustomObjectDraft resourceDraft = mock(CustomObjectDraft.class);
+ when(resourceDraft.getKey()).thenReturn("myKey");
+ when(resourceDraft.getContainer()).thenReturn("myContainer");
+ final Optional> filteredDraft =
+ customObjectSyncOptions.applyBeforeCreateCallback(resourceDraft);
+ assertThat(filteredDraft).isNotEmpty();
+ assertThat(filteredDraft.get().getKey()).isEqualTo("myKey_filteredKey");
+ assertThat(filteredDraft.get().getContainer()).isEqualTo("myContainer_filteredContainer");
+ }
+
+ @Test
+ void applyBeforeCreateCallBack_WithNullCallback_ShouldReturnIdenticalDraftInOptional() {
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT).build();
+ assertThat(customObjectSyncOptions.getBeforeCreateCallback()).isNull();
+ final CustomObjectDraft resourceDraft = mock(CustomObjectDraft.class);
+ final Optional> filteredDraft =
+ customObjectSyncOptions.applyBeforeCreateCallback(resourceDraft);
+ assertThat(filteredDraft).containsSame(resourceDraft);
+ }
+
+ @Test
+ void applyBeforeCreateCallBack_WithCallbackReturningNull_ShouldReturnEmptyOptional() {
+ final Function, CustomObjectDraft> draftFunction =
+ customObjectDraft -> null;
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .beforeCreateCallback(
+ draftFunction)
+ .build();
+ assertThat(customObjectSyncOptions.getBeforeCreateCallback()).isNotNull();
+ final CustomObjectDraft resourceDraft = mock(CustomObjectDraft.class);
+ final Optional> filteredDraft =
+ customObjectSyncOptions.applyBeforeCreateCallback(resourceDraft);
+ assertThat(filteredDraft).isEmpty();
+ }
+
+}
diff --git a/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncOptionsTest.java b/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncOptionsTest.java
new file mode 100644
index 0000000000..4626004ca4
--- /dev/null
+++ b/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncOptionsTest.java
@@ -0,0 +1,142 @@
+package com.commercetools.sync.customobjects;
+
+import com.commercetools.sync.commons.utils.TriFunction;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import io.sphere.sdk.client.SphereClient;
+import io.sphere.sdk.commands.UpdateAction;
+import io.sphere.sdk.customobjects.CustomObject;
+import io.sphere.sdk.customobjects.CustomObjectDraft;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+import static java.util.Collections.emptyList;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+
+class CustomObjectSyncOptionsTest {
+
+ private static SphereClient CTP_CLIENT = mock(SphereClient.class);
+
+ private interface MockTriFunction extends
+ TriFunction>>,
+ CustomObjectDraft, CustomObject, List>>> {
+ }
+
+ @Test
+ void applyBeforeUpdateCallback_WithNullCallbackAndEmptyUpdateActions_ShouldReturnIdenticalList() {
+ final CustomObjectSyncOptions customObjectSyncOptions =
+ CustomObjectSyncOptionsBuilder.of(CTP_CLIENT).build();
+
+ final List>> updateActions = emptyList();
+
+ final List>> filteredList =
+ customObjectSyncOptions.applyBeforeUpdateCallback(updateActions,
+ mock(CustomObjectDraft.class), mock(CustomObject.class));
+
+ assertThat(filteredList).isSameAs(updateActions);
+ }
+
+
+ @Test
+ void applyBeforeUpdateCallback_WithNullReturnCallbackAndEmptyUpdateActions_ShouldReturnEmptyList() {
+ final TriFunction>>, CustomObjectDraft,
+ CustomObject, List>>>
+ beforeUpdateCallback = (updateActions, newCustomObject, oldCustomObject) -> null;
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .beforeUpdateCallback(
+ beforeUpdateCallback)
+ .build();
+ final List>> updateActions = emptyList();
+
+ final List>> filteredList =
+ customObjectSyncOptions.applyBeforeUpdateCallback(
+ updateActions, mock(CustomObjectDraft.class), mock(CustomObject.class));
+
+ assertAll(
+ () -> assertThat(filteredList).isEqualTo(updateActions),
+ () -> assertThat(filteredList).isEmpty()
+ );
+ }
+
+
+ @Test
+ void applyBeforeUpdateCallback_WithEmptyUpdateActions_ShouldNotApplyBeforeUpdateCallback() {
+ final CustomObjectSyncOptionsTest.MockTriFunction beforeUpdateCallback =
+ mock(CustomObjectSyncOptionsTest.MockTriFunction.class);
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .beforeUpdateCallback(
+ beforeUpdateCallback)
+ .build();
+
+ final List>> filteredList =
+ customObjectSyncOptions.applyBeforeUpdateCallback(emptyList(),
+ mock(CustomObjectDraft.class), mock(CustomObject.class));
+
+ assertThat(filteredList).isEmpty();
+ verify(beforeUpdateCallback, never()).apply(any(), any(), any());
+ }
+
+
+ @Test
+ void applyBeforeCreateCallback_WithCallback_ShouldReturnFilteredDraft() {
+
+ final Function, CustomObjectDraft> draftFunction =
+ customObjectDraft -> CustomObjectDraft.ofUnversionedUpsert(
+ customObjectDraft.getContainer() + "_filteredContainer",
+ customObjectDraft.getKey() + "_filteredKey", customObjectDraft.getValue());
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .beforeCreateCallback(
+ draftFunction)
+ .build();
+ final CustomObjectDraft resourceDraft = mock(CustomObjectDraft.class);
+ when(resourceDraft.getKey()).thenReturn("myKey");
+ when(resourceDraft.getContainer()).thenReturn("myContainer");
+
+ final Optional> filteredDraft = customObjectSyncOptions
+ .applyBeforeCreateCallback(resourceDraft);
+
+ assertThat(filteredDraft).hasValueSatisfying(customObjectDraft ->
+ assertAll(
+ () -> assertThat(customObjectDraft.getKey()).isEqualTo("myKey_filteredKey"),
+ () -> assertThat(customObjectDraft.getContainer()).isEqualTo("myContainer_filteredContainer")
+ ));
+ }
+
+ @Test
+ void applyBeforeCreateCallback_WithNullCallback_ShouldReturnIdenticalDraftInOptional() {
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT).build();
+ final CustomObjectDraft resourceDraft = mock(CustomObjectDraft.class);
+
+ final Optional> filteredDraft = customObjectSyncOptions
+ .applyBeforeCreateCallback(resourceDraft);
+
+ assertThat(filteredDraft).containsSame(resourceDraft);
+ }
+
+ @Test
+ void applyBeforeCreateCallback_WithCallbackReturningNull_ShouldReturnEmptyOptional() {
+ final Function, CustomObjectDraft> draftFunction =
+ customObjectDraft -> null;
+ final CustomObjectSyncOptions customObjectSyncOptions = CustomObjectSyncOptionsBuilder.of(CTP_CLIENT)
+ .beforeCreateCallback(
+ draftFunction)
+ .build();
+ final CustomObjectDraft resourceDraft = mock(CustomObjectDraft.class);
+
+ final Optional> filteredDraft = customObjectSyncOptions
+ .applyBeforeCreateCallback(resourceDraft);
+
+ assertThat(filteredDraft).isEmpty();
+ }
+}
diff --git a/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncTest.java b/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncTest.java
new file mode 100644
index 0000000000..63a23f488a
--- /dev/null
+++ b/src/test/java/com/commercetools/sync/customobjects/CustomObjectSyncTest.java
@@ -0,0 +1,495 @@
+package com.commercetools.sync.customobjects;
+
+import com.commercetools.sync.customobjects.helpers.CustomObjectCompositeIdentifier;
+import com.commercetools.sync.customobjects.helpers.CustomObjectSyncStatistics;
+import com.commercetools.sync.services.CustomObjectService;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.JsonNodeFactory;
+import io.sphere.sdk.client.ConcurrentModificationException;
+import io.sphere.sdk.client.SphereClient;
+import io.sphere.sdk.customobjects.CustomObject;
+import io.sphere.sdk.customobjects.CustomObjectDraft;
+import io.sphere.sdk.models.SphereException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.annotation.Nonnull;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletionException;
+
+import static com.commercetools.sync.commons.asserts.statistics.AssertionsForStatistics.assertThat;
+import static java.lang.String.format;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singleton;
+import static java.util.Collections.singletonList;
+import static java.util.concurrent.CompletableFuture.completedFuture;
+import static java.util.concurrent.CompletableFuture.supplyAsync;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+
+public class CustomObjectSyncTest {
+
+ private CustomObjectDraft newCustomObjectDraft;
+
+ @BeforeEach
+ void setup() {
+ newCustomObjectDraft = CustomObjectDraft
+ .ofUnversionedUpsert("someContainer", "someKey",
+ JsonNodeFactory.instance.objectNode().put("json-field", "json-value"));
+ }
+
+ @Test
+ void sync_WithErrorFetchingExistingKeys_ShouldExecuteCallbackOnErrorAndIncreaseFailedCounter() {
+ final List errorMessages = new ArrayList<>();
+ final List exceptions = new ArrayList<>();
+
+ final CustomObjectSyncOptions spyCustomObjectSyncOptions =
+ initCustomObjectSyncOptions(errorMessages, exceptions);
+
+ final CustomObjectService mockCustomObjectService = mock(CustomObjectService.class);
+
+ when(mockCustomObjectService.fetchMatchingCustomObjects(anySet()))
+ .thenReturn(supplyAsync(() -> {
+ throw new SphereException();
+ }));
+
+ final CustomObjectSync customObjectSync =
+ new CustomObjectSync(spyCustomObjectSyncOptions, mockCustomObjectService);
+
+ // test
+ final CustomObjectSyncStatistics customObjectSyncStatistics = customObjectSync
+ .sync(singletonList(newCustomObjectDraft))
+ .toCompletableFuture().join();
+
+ // assertion
+ assertThat(errorMessages)
+ .hasSize(1).singleElement().asString()
+ .isEqualTo("Failed to fetch existing custom objects with keys: "
+ + "'[{key='someKey', container='someContainer'}]'.");
+
+ assertThat(exceptions)
+ .hasSize(1).singleElement().isInstanceOfSatisfying(Throwable.class, throwable -> {
+ assertThat(throwable).isExactlyInstanceOf(CompletionException.class);
+ assertThat(throwable).hasCauseExactlyInstanceOf(SphereException.class);
+ });
+
+ assertThat(customObjectSyncStatistics).hasValues(1, 0, 0, 1);
+ }
+
+ @Test
+ void sync_WithOnlyDraftsToCreate_ShouldCallBeforeCreateCallback_ShouldNotCallBeforeUpdateCallback() {
+ final CustomObjectSyncOptions spyCustomObjectSyncOptions =
+ initCustomObjectSyncOptions(emptyList(),emptyList());
+
+ final CustomObjectService customObjectService = mock(CustomObjectService.class);
+ when(customObjectService.fetchMatchingCustomObjects(anySet())).thenReturn(completedFuture(emptySet()));
+ when(customObjectService.upsertCustomObject(any())).thenReturn(completedFuture(Optional.empty()));
+
+ // test
+ new CustomObjectSync(spyCustomObjectSyncOptions, customObjectService)
+ .sync(singletonList(newCustomObjectDraft)).toCompletableFuture().join();
+
+ // assertion
+ verify(spyCustomObjectSyncOptions).applyBeforeCreateCallback(newCustomObjectDraft);
+ verify(spyCustomObjectSyncOptions, never()).applyBeforeUpdateCallback(any(), any(), any());
+ }
+
+ @Test
+ void sync_WithOnlyDraftsToUpdate_ShouldCallBeforeCreateCallback_ShouldNotCallBeforeUpdateCallback() {
+ final CustomObjectSyncOptions spyCustomObjectSyncOptions =
+ initCustomObjectSyncOptions(emptyList(), emptyList());
+
+ final CustomObject mockedExistingCustomObject = mock(CustomObject.class);
+ when(mockedExistingCustomObject.getKey()).thenReturn(newCustomObjectDraft.getKey());
+
+ final CustomObjectService customObjectService = mock(CustomObjectService.class);
+ when(customObjectService.fetchMatchingCustomObjects(anySet()))
+ .thenReturn(completedFuture(singleton(mockedExistingCustomObject)));
+ when(customObjectService.upsertCustomObject(any()))
+ .thenReturn(completedFuture(Optional.of(mockedExistingCustomObject)));
+
+ // test
+ new CustomObjectSync(spyCustomObjectSyncOptions, customObjectService)
+ .sync(singletonList(newCustomObjectDraft)).toCompletableFuture().join();
+
+ // assertion
+ verify(spyCustomObjectSyncOptions).applyBeforeCreateCallback(newCustomObjectDraft);
+ verify(spyCustomObjectSyncOptions, never()).applyBeforeUpdateCallback(any(), any(), any());
+ }
+
+ @Test
+ void sync_WithSameIdentifiersAndDifferentValues_ShouldUpdateSuccessfully() {
+ final CustomObjectSyncOptions spyCustomObjectSyncOptions =
+ initCustomObjectSyncOptions(emptyList(), emptyList());
+
+ final CustomObject existingCustomObject = mock(CustomObject.class);
+ when(existingCustomObject.getContainer()).thenReturn("someContainer");
+ when(existingCustomObject.getKey()).thenReturn("someKey");
+ when(existingCustomObject.getValue()).thenReturn(JsonNodeFactory.instance.numberNode(2020));
+
+ final CustomObject updatedCustomObject = mock(CustomObject.class);
+ when(updatedCustomObject.getContainer()).thenReturn("someContainer");
+ when(updatedCustomObject.getKey()).thenReturn("someKey");
+ when(updatedCustomObject.getValue()).thenReturn(newCustomObjectDraft.getValue());
+
+ final Set> existingCustomObjectSet = new HashSet>();
+ existingCustomObjectSet.add(existingCustomObject);
+
+ final CustomObjectService customObjectService = mock(CustomObjectService.class);
+ when(customObjectService.fetchMatchingCustomObjects(anySet()))
+ .thenReturn(completedFuture(existingCustomObjectSet));
+ when(customObjectService.upsertCustomObject(any()))
+ .thenReturn(completedFuture(Optional.of(updatedCustomObject)));
+
+ // test
+ CustomObjectSyncStatistics syncStatistics =
+ new CustomObjectSync(spyCustomObjectSyncOptions, customObjectService)
+ .sync(singletonList(newCustomObjectDraft)).toCompletableFuture().join();
+
+ // assertion
+ assertAll(
+ () -> assertThat(syncStatistics.getProcessed().get()).isEqualTo(1),
+ () -> assertThat(syncStatistics.getUpdated().get()).isEqualTo(1),
+ () -> assertThat(syncStatistics.getCreated().get()).isEqualTo(0),
+ () -> assertThat(syncStatistics.getFailed().get()).isEqualTo(0)
+ );
+ }
+
+ @Test
+ void sync_WithSameIdentifiersAndIdenticalValues_ShouldProcessedAndNotUpdated() {
+ final CustomObjectSyncOptions spyCustomObjectSyncOptions =
+ initCustomObjectSyncOptions(emptyList(), emptyList());
+
+ final CustomObject existingCustomObject = mock(CustomObject.class);
+ when(existingCustomObject.getContainer()).thenReturn("someContainer");
+ when(existingCustomObject.getKey()).thenReturn("someKey");
+ when(existingCustomObject.getValue()).thenReturn(newCustomObjectDraft.getValue());
+
+ final CustomObject updatedCustomObject = mock(CustomObject.class);
+ when(updatedCustomObject.getContainer()).thenReturn("someContainer");
+ when(updatedCustomObject.getKey()).thenReturn("someKey");
+ when(updatedCustomObject.getValue()).thenReturn(newCustomObjectDraft.getValue());
+
+ final Set> existingCustomObjectSet = new HashSet>();
+ existingCustomObjectSet.add(existingCustomObject);
+
+ final CustomObjectService customObjectService = mock(CustomObjectService.class);
+ when(customObjectService.fetchMatchingCustomObjects(anySet()))
+ .thenReturn(completedFuture(existingCustomObjectSet));
+ when(customObjectService.upsertCustomObject(any()))
+ .thenReturn(completedFuture(Optional.of(updatedCustomObject)));
+
+ // test
+ CustomObjectSyncStatistics syncStatistics =
+ new CustomObjectSync(spyCustomObjectSyncOptions, customObjectService)
+ .sync(singletonList(newCustomObjectDraft)).toCompletableFuture().join();
+
+ // assertion
+ assertAll(
+ () -> assertThat(syncStatistics.getProcessed().get()).isEqualTo(1),
+ () -> assertThat(syncStatistics.getUpdated().get()).isEqualTo(0),
+ () -> assertThat(syncStatistics.getCreated().get()).isEqualTo(0),
+ () -> assertThat(syncStatistics.getFailed().get()).isEqualTo(0)
+ );
+ }
+
+
+ @Test
+ void sync_UpdateWithConcurrentModificationExceptionAndRetryWithFetchException_ShouldIncrementFailed() {
+ final List errorMessages = new ArrayList<>();
+ final List exceptions = new ArrayList<>();
+
+ final CustomObjectSyncOptions spyCustomObjectSyncOptions =
+ initCustomObjectSyncOptions(errorMessages, exceptions);
+
+ final CustomObject existingCustomObject = mock(CustomObject.class);
+ when(existingCustomObject.getContainer()).thenReturn("someContainer");
+ when(existingCustomObject.getKey()).thenReturn("someKey");
+ when(existingCustomObject.getValue()).thenReturn(JsonNodeFactory.instance.numberNode(2020));
+
+ final Set> existingCustomObjectSet = new HashSet>();
+ existingCustomObjectSet.add(existingCustomObject);
+
+ final CustomObject updatedCustomObject = mock(CustomObject.class);
+ when(updatedCustomObject.getContainer()).thenReturn("someContainer");
+ when(updatedCustomObject.getKey()).thenReturn("someKey");
+ when(updatedCustomObject.getValue()).thenReturn(newCustomObjectDraft.getValue());
+
+ final CustomObjectService customObjectService = mock(CustomObjectService.class);
+ when(customObjectService.fetchMatchingCustomObjects(anySet()))
+ .thenReturn(completedFuture(existingCustomObjectSet));
+ when(customObjectService.upsertCustomObject(any()))
+ .thenReturn(supplyAsync(() -> { throw new ConcurrentModificationException(); }));
+ when(customObjectService.fetchCustomObject(any(CustomObjectCompositeIdentifier.class)))
+ .thenReturn(supplyAsync(() -> {
+ throw new SphereException();
+ }));
+
+ // test
+ CustomObjectSyncStatistics syncStatistics =
+ new CustomObjectSync(spyCustomObjectSyncOptions, customObjectService)
+ .sync(singletonList(newCustomObjectDraft)).toCompletableFuture().join();
+ // assertion
+ assertAll(
+ () -> assertThat(syncStatistics.getProcessed().get()).isEqualTo(1),
+ () -> assertThat(syncStatistics.getCreated().get()).isEqualTo(0),
+ () -> assertThat(syncStatistics.getUpdated().get()).isEqualTo(0),
+ () -> assertThat(syncStatistics.getFailed().get()).isEqualTo(1)
+ );
+ assertThat(exceptions).hasSize(1);
+ assertThat(errorMessages)
+ .hasSize(1)
+ .singleElement()
+ .isEqualTo(
+ format("Failed to update custom object with key: '%s'. Reason: %s",
+ CustomObjectCompositeIdentifier.of(newCustomObjectDraft).toString(),
+ "Failed to fetch from CTP while retrying after concurrency modification.")
+ );
+
+ verify(customObjectService).fetchCustomObject(any(CustomObjectCompositeIdentifier.class));
+ verify(customObjectService).upsertCustomObject(any());
+ verify(customObjectService).fetchMatchingCustomObjects(any());
+ }
+
+ @Test
+ void sync_UpdateWithSphereExceptionAndRetryWithFetchException_ShouldIncrementFailed() {
+ final List errorMessages = new ArrayList<>();
+ final List exceptions = new ArrayList<>();
+
+ final CustomObjectSyncOptions spyCustomObjectSyncOptions =
+ initCustomObjectSyncOptions(errorMessages, exceptions);
+
+ final CustomObject existingCustomObject = mock(CustomObject.class);
+ when(existingCustomObject.getContainer()).thenReturn("someContainer");
+ when(existingCustomObject.getKey()).thenReturn("someKey");
+ when(existingCustomObject.getValue()).thenReturn(JsonNodeFactory.instance.numberNode(2020));
+
+ final Set> existingCustomObjectSet = new HashSet>();
+ existingCustomObjectSet.add(existingCustomObject);
+
+ final CustomObject