diff --git a/drivers/mongock-driver-mongodb/integration-tests/src/main/java/io/mongock/integrationtests/spring5/springdata3/events/MongockFailEventListener.java b/drivers/mongock-driver-mongodb/integration-tests/src/main/java/io/mongock/integrationtests/spring5/springdata3/events/MongockFailEventListener.java index 157e3b3f5..233809415 100644 --- a/drivers/mongock-driver-mongodb/integration-tests/src/main/java/io/mongock/integrationtests/spring5/springdata3/events/MongockFailEventListener.java +++ b/drivers/mongock-driver-mongodb/integration-tests/src/main/java/io/mongock/integrationtests/spring5/springdata3/events/MongockFailEventListener.java @@ -8,7 +8,6 @@ public class MongockFailEventListener implements ApplicationListener org.mongodb mongodb-driver-sync - ${mongodb-sync-4.version} + 4.2.3 provided diff --git a/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/com/github/cloudyrock/mongock/driver/mongodb/springdata/v3/decorator/impl/MongockTemplate.java b/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/com/github/cloudyrock/mongock/driver/mongodb/springdata/v3/decorator/impl/MongockTemplate.java index 3919f8fc3..b15341a4f 100644 --- a/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/com/github/cloudyrock/mongock/driver/mongodb/springdata/v3/decorator/impl/MongockTemplate.java +++ b/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/com/github/cloudyrock/mongock/driver/mongodb/springdata/v3/decorator/impl/MongockTemplate.java @@ -1,17 +1,5 @@ package com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.impl; -import io.changock.migration.api.annotations.NonLockGuarded; -import io.changock.migration.api.annotations.NonLockGuardedType; -import io.mongock.driver.api.lock.guard.decorator.DecoratorBase; -import io.mongock.driver.api.lock.guard.invoker.LockGuardInvoker; -import com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.operation.executable.aggregation.impl.ExecutableAggregationDecoratorImpl; -import com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.operation.executable.find.impl.ExecutableFindDecoratorImpl; -import com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.operation.executable.insert.impl.ExecutableInsertDecoratorImpl; -import com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.operation.executable.mapreduce.impl.ExecutableMapReduceDecoratorImpl; -import com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.operation.executable.remove.impl.ExecutableRemoveDecoratorImpl; -import com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.operation.executable.update.impl.ExecutableUpdateDecoratorImpl; -import io.mongock.driver.mongodb.sync.v4.decorator.impl.MongoCollectionDecoratorImpl; -import io.mongock.driver.mongodb.sync.v4.decorator.impl.MongoDataBaseDecoratorImpl; import com.mongodb.ClientSessionOptions; import com.mongodb.ReadPreference; import com.mongodb.WriteConcern; @@ -20,10 +8,10 @@ import com.mongodb.client.MongoDatabase; import com.mongodb.client.result.DeleteResult; import com.mongodb.client.result.UpdateResult; +import io.mongock.driver.api.lock.guard.invoker.LockGuardInvoker; import org.bson.Document; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; -import org.springframework.context.ApplicationContextAware; import org.springframework.dao.support.PersistenceExceptionTranslator; import org.springframework.data.geo.GeoResults; import org.springframework.data.mongodb.MongoDatabaseFactory; @@ -32,6 +20,12 @@ import org.springframework.data.mongodb.core.CollectionOptions; import org.springframework.data.mongodb.core.DbCallback; import org.springframework.data.mongodb.core.DocumentCallbackHandler; +import org.springframework.data.mongodb.core.ExecutableAggregationOperation; +import org.springframework.data.mongodb.core.ExecutableFindOperation; +import org.springframework.data.mongodb.core.ExecutableInsertOperation; +import org.springframework.data.mongodb.core.ExecutableMapReduceOperation; +import org.springframework.data.mongodb.core.ExecutableRemoveOperation; +import org.springframework.data.mongodb.core.ExecutableUpdateOperation; import org.springframework.data.mongodb.core.FindAndModifyOptions; import org.springframework.data.mongodb.core.FindAndReplaceOptions; import org.springframework.data.mongodb.core.MongoOperations; @@ -45,7 +39,6 @@ import org.springframework.data.mongodb.core.aggregation.TypedAggregation; import org.springframework.data.mongodb.core.convert.MongoConverter; import org.springframework.data.mongodb.core.index.IndexOperations; -import org.springframework.data.mongodb.core.index.IndexOperationsProvider; import org.springframework.data.mongodb.core.mapreduce.GroupBy; import org.springframework.data.mongodb.core.mapreduce.GroupByResults; import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions; @@ -72,524 +65,529 @@ * @see MongoTemplate */ @Deprecated -public class MongockTemplate extends DecoratorBase implements MongoOperations, ApplicationContextAware, IndexOperationsProvider { +public class MongockTemplate { - public MongockTemplate(MongoTemplate impl, LockGuardInvoker invoker) { - super(impl, invoker); + private final MongoTemplate impl; + + public MongockTemplate(MongoTemplate impl) { + this.impl = impl; + } + + private MongoTemplate getImpl() { + return impl; } - @NonLockGuarded(NonLockGuardedType.NONE) + public void setWriteResultChecking(WriteResultChecking resultChecking) { getImpl().setWriteResultChecking(resultChecking); } - @NonLockGuarded(NonLockGuardedType.NONE) + public void setWriteConcern(WriteConcern writeConcern) { getImpl().setWriteConcern(writeConcern); } - @NonLockGuarded(NonLockGuardedType.NONE) + public void setWriteConcernResolver(WriteConcernResolver writeConcernResolver) { getImpl().setWriteConcernResolver(writeConcernResolver); } - @NonLockGuarded(NonLockGuardedType.NONE) + public void setReadPreference(ReadPreference readPreference) { getImpl().setReadPreference(readPreference); } - @Override - @NonLockGuarded(NonLockGuardedType.NONE) + + public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { getImpl().setApplicationContext(applicationContext); } - @Override - @NonLockGuarded(NonLockGuardedType.NONE) + + public MongoConverter getConverter() { return getImpl().getConverter(); } - @Override + public CloseableIterator stream(final Query query, final Class entityType) { - return new CloseableIteratorDecoratorImpl<>(getInvoker().invoke(() -> getImpl().stream(query, entityType)), getInvoker()); + return getImpl().stream(query, entityType); } - @Override + public CloseableIterator stream(final Query query, final Class entityType, final String collectionName) { - return new CloseableIteratorDecoratorImpl<>(getInvoker().invoke(() -> getImpl().stream(query, entityType, collectionName)), getInvoker()); + return getImpl().stream(query, entityType, collectionName); } - @Override - @NonLockGuarded(NonLockGuardedType.NONE) + + public String getCollectionName(Class entityClass) { return getImpl().getCollectionName(entityClass); } - @Override + public Document executeCommand(final String jsonCommand) { - return getInvoker().invoke(() -> getImpl().executeCommand(jsonCommand)); + return getImpl().executeCommand(jsonCommand); } - @Override + public Document executeCommand(final Document command) { - return getInvoker().invoke(() -> getImpl().executeCommand(command)); + return getImpl().executeCommand(command); } - @Override + public Document executeCommand(Document command, ReadPreference readPreference) { - return getInvoker().invoke(() -> getImpl().executeCommand(command, readPreference)); + return getImpl().executeCommand(command, readPreference); } - @Override + public void executeQuery(Query query, String collectionName, DocumentCallbackHandler dch) { - getInvoker().invoke(() -> getImpl().executeQuery(query, collectionName, dch)); + getImpl().executeQuery(query, collectionName, dch); } - @Override + public T execute(DbCallback action) { - return getInvoker().invoke(() -> getImpl().execute(action)); + return getImpl().execute(action); } - @Override + public T execute(Class entityClass, CollectionCallback callback) { - return getInvoker().invoke(() -> getImpl().execute(entityClass, callback)); + return getImpl().execute(entityClass, callback); } - @Override + public T execute(String collectionName, CollectionCallback callback) { - return getInvoker().invoke(() -> getImpl().execute(collectionName, callback)); + return getImpl().execute(collectionName, callback); } - @Override + public MongoCollection createCollection(Class entityClass) { - return new MongoCollectionDecoratorImpl<>(getInvoker().invoke(() -> getImpl().createCollection(entityClass)), getInvoker()); + return /**new MongoCollectionDecoratorImpl<>(**/getImpl().createCollection(entityClass); } - @Override + public MongoCollection createCollection(Class entityClass, CollectionOptions collectionOptions) { - return new MongoCollectionDecoratorImpl<>(getInvoker().invoke(() -> getImpl().createCollection(entityClass, collectionOptions)), getInvoker()); + return /**new MongoCollectionDecoratorImpl<>(**/getImpl().createCollection(entityClass, collectionOptions); } - @Override + public MongoCollection createCollection(final String collectionName) { - return new MongoCollectionDecoratorImpl<>(getInvoker().invoke(() -> getImpl().createCollection(collectionName)), getInvoker()); + return /**new MongoCollectionDecoratorImpl<>(**/getImpl().createCollection(collectionName); } - @Override + public MongoCollection createCollection(final String collectionName, final CollectionOptions collectionOptions) { - return new MongoCollectionDecoratorImpl<>(getInvoker().invoke(() -> getImpl().createCollection(collectionName, collectionOptions)), getInvoker()); + return /**new MongoCollectionDecoratorImpl<>(**/getImpl().createCollection(collectionName, collectionOptions); } - @Override + public MongoCollection getCollection(final String collectionName) { - return new MongoCollectionDecoratorImpl<>(getInvoker().invoke(() -> getImpl().getCollection(collectionName)), getInvoker()); + return /**new MongoCollectionDecoratorImpl<>(**/getImpl().getCollection(collectionName); } - @Override + public boolean collectionExists(Class entityClass) { - return getInvoker().invoke(() -> getImpl().collectionExists(entityClass)); + return getImpl().collectionExists(entityClass); } - @Override + public boolean collectionExists(final String collectionName) { - return getInvoker().invoke(() -> getImpl().collectionExists(collectionName)); + return getImpl().collectionExists(collectionName); } - @Override + public void dropCollection(Class entityClass) { - getInvoker().invoke(() -> getImpl().dropCollection(entityClass)); + getImpl().dropCollection(entityClass); } - @Override + public void dropCollection(String collectionName) { - getInvoker().invoke(() -> getImpl().dropCollection(collectionName)); + getImpl().dropCollection(collectionName); } - @Override + public T findOne(Query query, Class entityClass) { - return getInvoker().invoke(() -> getImpl().findOne(query, entityClass)); + return getImpl().findOne(query, entityClass); } - @Override + public T findOne(Query query, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().findOne(query, entityClass, collectionName)); + return getImpl().findOne(query, entityClass, collectionName); } - @Override + public boolean exists(Query query, Class entityClass) { - return getInvoker().invoke(() -> getImpl().exists(query, entityClass)); + return getImpl().exists(query, entityClass); } - @Override + public boolean exists(Query query, String collectionName) { - return getInvoker().invoke(() -> getImpl().exists(query, collectionName)); + return getImpl().exists(query, collectionName); } - @Override + public boolean exists(Query query, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().exists(query, entityClass, collectionName)); + return getImpl().exists(query, entityClass, collectionName); } - @Override + public List find(Query query, Class entityClass) { - return getInvoker().invoke(() -> getImpl().find(query, entityClass)); + return getImpl().find(query, entityClass); } - @Override + public List find(Query query, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().find(query, entityClass, collectionName)); + return getImpl().find(query, entityClass, collectionName); } - @Override + public T findById(Object id, Class entityClass) { - return getInvoker().invoke(() -> getImpl().findById(id, entityClass)); + return getImpl().findById(id, entityClass); } - @Override + public T findById(Object id, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().findById(id, entityClass, collectionName)); + return getImpl().findById(id, entityClass, collectionName); } - @Override + public GeoResults geoNear(NearQuery near, Class entityClass) { - return getInvoker().invoke(() -> getImpl().geoNear(near, entityClass)); + return getImpl().geoNear(near, entityClass); } - @Override + @SuppressWarnings("unchecked") public GeoResults geoNear(NearQuery near, Class domainType, String collectionName) { - return getInvoker().invoke(() -> getImpl().geoNear(near, domainType, collectionName)); + return getImpl().geoNear(near, domainType, collectionName); } public GeoResults geoNear(NearQuery near, Class domainType, String collectionName, Class returnType) { - return getInvoker().invoke(() -> getImpl().geoNear(near, domainType, collectionName, returnType)); + return getImpl().geoNear(near, domainType, collectionName, returnType); } - @Override + public T findAndRemove(Query query, Class entityClass) { - return getInvoker().invoke(() -> getImpl().findAndRemove(query, entityClass)); + return getImpl().findAndRemove(query, entityClass); } - @Override + public T findAndRemove(Query query, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().findAndRemove(query, entityClass, collectionName)); + return getImpl().findAndRemove(query, entityClass, collectionName); } - @Override + public long count(Query query, Class entityClass) { - return getInvoker().invoke(() -> getImpl().count(query, entityClass)); + return getImpl().count(query, entityClass); } - @Override + public long count(final Query query, String collectionName) { - return getInvoker().invoke(() -> getImpl().count(query, collectionName)); + return getImpl().count(query, collectionName); } - @Override + public long estimatedCount(Class entityClass) { - return getInvoker().invoke(() -> getImpl().estimatedCount(entityClass)); + return getImpl().estimatedCount(entityClass); } - @Override + public long estimatedCount(String s) { - return getInvoker().invoke(() -> getImpl().estimatedCount(s)); + return getImpl().estimatedCount(s); } - @Override + public long count(Query query, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().count(query, entityClass, collectionName)); + return getImpl().count(query, entityClass, collectionName); } - @Override + public T insert(T objectToSave) { - return getInvoker().invoke(() -> getImpl().insert(objectToSave)); + return getImpl().insert(objectToSave); } - @Override + public T insert(T objectToSave, String collectionName) { - return getInvoker().invoke(() -> getImpl().insert(objectToSave, collectionName)); + return getImpl().insert(objectToSave, collectionName); } - @Override + public Collection insert(Collection batchToSave, Class entityClass) { - return getInvoker().invoke(() -> getImpl().insert(batchToSave, entityClass)); + return getImpl().insert(batchToSave, entityClass); } - @Override + public Collection insert(Collection batchToSave, String collectionName) { - return getInvoker().invoke(() -> getImpl().insert(batchToSave, collectionName)); + return getImpl().insert(batchToSave, collectionName); } - @Override + public Collection insertAll(Collection objectsToSave) { - return getInvoker().invoke(() -> getImpl().insertAll(objectsToSave)); + return getImpl().insertAll(objectsToSave); } - @Override + public T save(T objectToSave) { - return getInvoker().invoke(() -> getImpl().save(objectToSave)); + return getImpl().save(objectToSave); } - @Override + public T save(T objectToSave, String collectionName) { - return getInvoker().invoke(() -> getImpl().save(objectToSave, collectionName)); + return getImpl().save(objectToSave, collectionName); } - @Override + public DeleteResult remove(Object object) { - return getInvoker().invoke(() -> getImpl().remove(object)); + return getImpl().remove(object); } - @Override + public DeleteResult remove(Object object, String collectionName) { - return getInvoker().invoke(() -> getImpl().remove(object, collectionName)); + return getImpl().remove(object, collectionName); } - @Override + public DeleteResult remove(Query query, String collectionName) { - return getInvoker().invoke(() -> getImpl().remove(query, collectionName)); + return getImpl().remove(query, collectionName); } - @Override + public DeleteResult remove(Query query, Class entityClass) { - return getInvoker().invoke(() -> getImpl().remove(query, entityClass)); + return getImpl().remove(query, entityClass); } - @Override + public DeleteResult remove(Query query, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().remove(query, entityClass, collectionName)); + return getImpl().remove(query, entityClass, collectionName); } - @Override + public List findAll(Class entityClass) { - return getInvoker().invoke(() -> getImpl().findAll(entityClass)); + return getImpl().findAll(entityClass); } - @Override + public List findAll(Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().findAll(entityClass, collectionName)); + return getImpl().findAll(entityClass, collectionName); } - @Override + public MapReduceResults mapReduce(String inputCollectionName, String mapFunction, String reduceFunction, Class entityClass) { - return getInvoker().invoke(() -> getImpl().mapReduce(inputCollectionName, mapFunction, reduceFunction, entityClass)); + return getImpl().mapReduce(inputCollectionName, mapFunction, reduceFunction, entityClass); } - @Override + public MapReduceResults mapReduce(String inputCollectionName, String mapFunction, String reduceFunction, MapReduceOptions mapReduceOptions, Class entityClass) { - return getInvoker().invoke(() -> getImpl().mapReduce(inputCollectionName, mapFunction, reduceFunction, mapReduceOptions, entityClass)); + return getImpl().mapReduce(inputCollectionName, mapFunction, reduceFunction, mapReduceOptions, entityClass); } - @Override + public MapReduceResults mapReduce(Query query, String inputCollectionName, String mapFunction, String reduceFunction, Class entityClass) { - return getInvoker().invoke(() -> getImpl().mapReduce(query, inputCollectionName, mapFunction, reduceFunction, entityClass)); + return getImpl().mapReduce(query, inputCollectionName, mapFunction, reduceFunction, entityClass); } - @Override + public MapReduceResults mapReduce(Query query, String inputCollectionName, String mapFunction, String reduceFunction, MapReduceOptions mapReduceOptions, Class entityClass) { - return getInvoker().invoke(() -> getImpl().mapReduce(query, inputCollectionName, mapFunction, reduceFunction, mapReduceOptions, entityClass)); + return getImpl().mapReduce(query, inputCollectionName, mapFunction, reduceFunction, mapReduceOptions, entityClass); } - @Override + public GroupByResults group(String inputCollectionName, GroupBy groupBy, Class entityClass) { - return getInvoker().invoke(() -> getImpl().group(inputCollectionName, groupBy, entityClass)); + return getImpl().group(inputCollectionName, groupBy, entityClass); } - @Override + public GroupByResults group(Criteria criteria, String inputCollectionName, GroupBy groupBy, Class entityClass) { - return getInvoker().invoke(() -> getImpl().group(criteria, inputCollectionName, groupBy, entityClass)); + return getImpl().group(criteria, inputCollectionName, groupBy, entityClass); } - @Override + public AggregationResults aggregate(TypedAggregation aggregation, Class outputType) { - return getInvoker().invoke(() -> getImpl().aggregate(aggregation, outputType)); + return getImpl().aggregate(aggregation, outputType); } - @Override + public AggregationResults aggregate(TypedAggregation aggregation, String inputCollectionName, Class outputType) { - return getInvoker().invoke(() -> getImpl().aggregate(aggregation, inputCollectionName, outputType)); + return getImpl().aggregate(aggregation, inputCollectionName, outputType); } - @Override + public AggregationResults aggregate(Aggregation aggregation, Class inputType, Class outputType) { - return getInvoker().invoke(() -> getImpl().aggregate(aggregation, inputType, outputType)); + return getImpl().aggregate(aggregation, inputType, outputType); } - @Override + public AggregationResults aggregate(Aggregation aggregation, String collectionName, Class outputType) { - return getInvoker().invoke(() -> getImpl().aggregate(aggregation, collectionName, outputType)); + return getImpl().aggregate(aggregation, collectionName, outputType); } - @Override + public CloseableIterator aggregateStream(TypedAggregation aggregation, String inputCollectionName, Class outputType) { - return new CloseableIteratorDecoratorImpl<>(getInvoker().invoke(() -> getImpl().aggregateStream(aggregation, inputCollectionName, outputType)), getInvoker()); + return getImpl().aggregateStream(aggregation, inputCollectionName, outputType); } - @Override + public CloseableIterator aggregateStream(TypedAggregation aggregation, Class outputType) { - return new CloseableIteratorDecoratorImpl<>(getInvoker().invoke(() -> getImpl().aggregateStream(aggregation, outputType)), getInvoker()); + return /**return new CloseableIteratorDecoratorImpl<>(**/getImpl().aggregateStream(aggregation, outputType); } - @Override + public CloseableIterator aggregateStream(Aggregation aggregation, Class inputType, Class outputType) { - return new CloseableIteratorDecoratorImpl<>(getInvoker().invoke(() -> getImpl().aggregateStream(aggregation, inputType, outputType)), getInvoker()); + return /**return new CloseableIteratorDecoratorImpl<>(**/getImpl().aggregateStream(aggregation, inputType, outputType); } - @Override + public CloseableIterator aggregateStream(Aggregation aggregation, String collectionName, Class outputType) { - return new CloseableIteratorDecoratorImpl<>(getInvoker().invoke(() -> getImpl().aggregateStream(aggregation, collectionName, outputType)), getInvoker()); + return /**return new CloseableIteratorDecoratorImpl<>(**/getImpl().aggregateStream(aggregation, collectionName, outputType); } - @Override + public List findAllAndRemove(Query query, String collectionName) { - return getInvoker().invoke(() -> getImpl().findAllAndRemove(query, collectionName)); + return getImpl().findAllAndRemove(query, collectionName); } - @Override + public List findAllAndRemove(Query query, Class entityClass) { - return getInvoker().invoke(() -> getImpl().findAllAndRemove(query, entityClass)); + return getImpl().findAllAndRemove(query, entityClass); } - @Override + public List findAllAndRemove(Query query, Class entityClass, String collectionName) { - return getInvoker().invoke(() -> getImpl().findAllAndRemove(query, entityClass, collectionName)); + return getImpl().findAllAndRemove(query, entityClass, collectionName); } - @Override - public ExecutableFind query(Class domainType) { - return new ExecutableFindDecoratorImpl<>(getInvoker().invoke(() -> getImpl().query(domainType)), getInvoker()); + + public ExecutableFindOperation.ExecutableFind query(Class domainType) { + return /**new ExecutableFindDecoratorImpl<>(**/getImpl().query(domainType); } - @Override - public ExecutableUpdate update(Class domainType) { - return new ExecutableUpdateDecoratorImpl<>(getInvoker().invoke(() -> getImpl().update(domainType)), getInvoker()); + + public ExecutableUpdateOperation.ExecutableUpdate update(Class domainType) { + return getImpl().update(domainType); } - @Override - public ExecutableRemove remove(Class domainType) { - return new ExecutableRemoveDecoratorImpl<>(getInvoker().invoke(() -> getImpl().remove(domainType)), getInvoker()); + + public ExecutableRemoveOperation.ExecutableRemove remove(Class domainType) { + return getImpl().remove(domainType); } - @Override - public ExecutableAggregation aggregateAndReturn(Class domainType) { - return new ExecutableAggregationDecoratorImpl<>(getInvoker().invoke(() -> getImpl().aggregateAndReturn(domainType)), getInvoker()); + + public ExecutableAggregationOperation.ExecutableAggregation aggregateAndReturn(Class domainType) { + return getImpl().aggregateAndReturn(domainType); } - @Override - public ExecutableInsert insert(Class domainType) { - return new ExecutableInsertDecoratorImpl<>(getInvoker().invoke(() -> getImpl().insert(domainType)), getInvoker()); + + public ExecutableInsertOperation.ExecutableInsert insert(Class domainType) { + return getImpl().insert(domainType); } - @Override + public Set getCollectionNames() { - return getInvoker().invoke(getImpl()::getCollectionNames); + return getImpl().getCollectionNames(); } public MongoDatabase getDb() { - return new MongoDataBaseDecoratorImpl(getInvoker().invoke(getImpl()::getDb), getInvoker()); + return getImpl().getDb(); } - @NonLockGuarded(NonLockGuardedType.NONE) + public PersistenceExceptionTranslator getExceptionTranslator() { return getImpl().getExceptionTranslator(); } - @NonLockGuarded(NonLockGuardedType.NONE) + public MongoDatabaseFactory getMongoDbFactory() { - return new MongoDatabaseFactoryDecoratorImpl(getInvoker().invoke(() -> getImpl().getMongoDbFactory()), getInvoker()); + return getImpl().getMongoDbFactory(); } - @Override + public List findDistinct(Query query, String field, Class entityClass, Class resultClass) { - return getInvoker().invoke(() -> getImpl().findDistinct(query, field, entityClass, resultClass)); + return getImpl().findDistinct(query, field, entityClass, resultClass); } - @Override + public List findDistinct(Query query, String field, String collectionName, Class entityClass, Class resultClass) { - return getInvoker().invoke(() -> getImpl().findDistinct(query, field, collectionName, entityClass, resultClass)); + return getImpl().findDistinct(query, field, collectionName, entityClass, resultClass); } - @Override + public T findAndReplace(Query query, S replacement, FindAndReplaceOptions options, Class entityType, String collectionName, Class resultType) { - return getInvoker().invoke(() -> - getImpl().findAndReplace(query, replacement, options, entityType, collectionName, resultType)); + return getImpl().findAndReplace(query, replacement, options, entityType, collectionName, resultType); } - @Override - public ExecutableMapReduce mapReduce(Class domainType) { - return getInvoker().invoke(() -> new ExecutableMapReduceDecoratorImpl<>(getImpl().mapReduce(domainType), getInvoker())); + + public ExecutableMapReduceOperation.ExecutableMapReduce mapReduce(Class domainType) { + return getImpl().mapReduce(domainType); } - @Override + public MongoOperations withSession(ClientSession session) { - return getInvoker().invoke(() -> new MongockTemplate(getImpl().withSession(session), getInvoker())); + return getImpl().withSession(session); } - @Override + public IndexOperations indexOps(String collectionName) { - return getInvoker().invoke(() -> new IndexOperationsDecoratorImpl(getImpl().indexOps(collectionName), getInvoker())); + return getImpl().indexOps(collectionName); } - @Override + public IndexOperations indexOps(String s, Class aClass) { - return getInvoker().invoke(() -> new IndexOperationsDecoratorImpl(getImpl().indexOps(s, aClass), getInvoker())); + return getImpl().indexOps(s, aClass); } - @Override + public IndexOperations indexOps(Class entityClass) { - return getInvoker().invoke(() -> new IndexOperationsDecoratorImpl(getImpl().indexOps(entityClass), getInvoker())); + return getImpl().indexOps(entityClass); } - @Override + public BulkOperations bulkOps(BulkOperations.BulkMode mode, String collectionName) { - return new BulkOperationsDecoratorImpl(getInvoker().invoke(() -> getImpl().bulkOps(mode, collectionName)), getInvoker()); + return getImpl().bulkOps(mode, collectionName); } - @Override + public BulkOperations bulkOps(BulkOperations.BulkMode mode, Class entityType) { - return new BulkOperationsDecoratorImpl(getInvoker().invoke(() -> getImpl().bulkOps(mode, entityType)), getInvoker()); + return getImpl().bulkOps(mode, entityType); } - @Override + public BulkOperations bulkOps(BulkOperations.BulkMode mode, Class entityType, String collectionName) { - return new BulkOperationsDecoratorImpl(getInvoker().invoke(() -> getImpl().bulkOps(mode, entityType, collectionName)), getInvoker()); + return getImpl().bulkOps(mode, entityType, collectionName); } - @Override + public ScriptOperations scriptOps() { - return new ScriptOperationsDecoratorImpl(getInvoker().invoke(getImpl()::scriptOps), getInvoker()); + return getImpl().scriptOps(); } - @Override + public SessionScoped withSession(ClientSessionOptions sessionOptions) { - return getInvoker().invoke(() -> new SessionScopedDecoratorImpl(getImpl().withSession(sessionOptions), getInvoker())); + return getImpl().withSession(sessionOptions); } //default methods overwritten to ensure lock - @Override + public List findDistinct(Query query, String field, String collection, Class resultClass) { - return getInvoker().invoke(() -> getImpl().findDistinct(query, field, collection, resultClass)); + return getImpl().findDistinct(query, field, collection, resultClass); } - @Override + public List findDistinct(String field, Class entityClass, Class resultClass) { - return getInvoker().invoke(() -> getImpl().findDistinct(field, entityClass, resultClass)); + return getImpl().findDistinct(field, entityClass, resultClass); } - @Override + public SessionScoped withSession(Supplier sessionProvider) { - return new SessionScopedDecoratorImpl(getInvoker().invoke(() -> getImpl().withSession(sessionProvider)), getInvoker()); + return getImpl().withSession(sessionProvider); } @@ -598,99 +596,99 @@ public SessionScoped withSession(Supplier sessionProvider) { // since sprind-data-mongodb:3.0 - @Override + public T findAndModify(Query query, UpdateDefinition update, Class entityClass) { - return getInvoker().invoke(()-> getImpl().findAndModify(query, update, entityClass)); + return getImpl().findAndModify(query, update, entityClass); } - @Override + public T findAndModify(Query query, UpdateDefinition update, Class entityClass, String collectionName) { - return getInvoker().invoke(()-> getImpl().findAndModify(query, update, entityClass, collectionName)); + return getImpl().findAndModify(query, update, entityClass, collectionName); } - @Override + public T findAndModify(Query query, UpdateDefinition update, FindAndModifyOptions options, Class entityClass) { - return getInvoker().invoke(()-> getImpl().findAndModify(query, update, options, entityClass)); + return getImpl().findAndModify(query, update, options, entityClass); } - @Override + public T findAndModify(Query query, UpdateDefinition update, FindAndModifyOptions options, Class entityClass, String collectionName) { - return getInvoker().invoke(()-> getImpl().findAndModify(query, update, options, entityClass, collectionName)); + return getImpl().findAndModify(query, update, options, entityClass, collectionName); } - @Override + public T findAndReplace(Query query, T replacement) { - return getInvoker().invoke(()-> getImpl().findAndReplace(query, replacement)); + return getImpl().findAndReplace(query, replacement); } - @Override + public T findAndReplace(Query query, T replacement, String collectionName) { - return getInvoker().invoke(()-> getImpl().findAndReplace(query, replacement, collectionName)); + return getImpl().findAndReplace(query, replacement, collectionName); } - @Override + public T findAndReplace(Query query, T replacement, FindAndReplaceOptions options) { - return getInvoker().invoke(()-> getImpl().findAndReplace(query, replacement, options)); + return getImpl().findAndReplace(query, replacement, options); } - @Override + public T findAndReplace(Query query, T replacement, FindAndReplaceOptions options, String collectionName) { - return getInvoker().invoke(()-> getImpl().findAndReplace(query, replacement, options, collectionName)); + return getImpl().findAndReplace(query, replacement, options, collectionName); } - @Override + public T findAndReplace(Query query, T replacement, FindAndReplaceOptions options, Class entityType, String collectionName) { - return getInvoker().invoke(()-> getImpl().findAndReplace(query, replacement, options, entityType, collectionName)); + return getImpl().findAndReplace(query, replacement, options, entityType, collectionName); } - @Override + public T findAndReplace(Query query, S replacement, FindAndReplaceOptions options, Class entityType, Class resultType) { - return getInvoker().invoke(()-> getImpl().findAndReplace(query, replacement, options, entityType, resultType)); + return getImpl().findAndReplace(query, replacement, options, entityType, resultType); } - @Override + public UpdateResult upsert(Query query, UpdateDefinition update, Class entityClass) { - return getInvoker().invoke(()-> getImpl().upsert(query, update, entityClass)); + return getImpl().upsert(query, update, entityClass); } - @Override + public UpdateResult upsert(Query query, UpdateDefinition update, String collectionName) { - return getInvoker().invoke(()-> getImpl().upsert(query, update, collectionName)); + return getImpl().upsert(query, update, collectionName); } - @Override + public UpdateResult upsert(Query query, UpdateDefinition update, Class entityClass, String collectionName) { - return getInvoker().invoke(()-> getImpl().upsert(query, update, entityClass, collectionName)); + return getImpl().upsert(query, update, entityClass, collectionName); } - @Override + public UpdateResult updateFirst(Query query, UpdateDefinition update, Class entityClass) { - return getInvoker().invoke(()-> getImpl().updateFirst(query, update, entityClass)); + return getImpl().updateFirst(query, update, entityClass); } - @Override + public UpdateResult updateFirst(Query query, UpdateDefinition update, String collectionName) { - return getInvoker().invoke(()-> getImpl().updateFirst(query, update, collectionName)); + return getImpl().updateFirst(query, update, collectionName); } - @Override + public UpdateResult updateFirst(Query query, UpdateDefinition update, Class entityClass, String collectionName) { - return getInvoker().invoke(()-> getImpl().updateFirst(query, update, entityClass, collectionName)); + return getImpl().updateFirst(query, update, entityClass, collectionName); } - @Override + public UpdateResult updateMulti(Query query, UpdateDefinition update, Class entityClass) { - return getInvoker().invoke(()-> getImpl().updateMulti(query, update, entityClass)); + return getImpl().updateMulti(query, update, entityClass); } - @Override + public UpdateResult updateMulti(Query query, UpdateDefinition update, String collectionName) { - return getInvoker().invoke(()-> getImpl().updateMulti(query, update, collectionName)); + return getImpl().updateMulti(query, update, collectionName); } - @Override + public UpdateResult updateMulti(Query query, UpdateDefinition update, Class entityClass, String collectionName) { - return getInvoker().invoke(()-> getImpl().updateMulti(query, update, entityClass, collectionName)); + return getImpl().updateMulti(query, update, entityClass, collectionName); } } diff --git a/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/io/mongock/driver/mongodb/springdata/v3/SpringDataMongoV3DriverBase.java b/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/io/mongock/driver/mongodb/springdata/v3/SpringDataMongoV3DriverBase.java index 8ba6ec813..295d32b30 100644 --- a/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/io/mongock/driver/mongodb/springdata/v3/SpringDataMongoV3DriverBase.java +++ b/drivers/mongock-driver-mongodb/mongodb-springdata-v3-driver/src/main/java/io/mongock/driver/mongodb/springdata/v3/SpringDataMongoV3DriverBase.java @@ -1,10 +1,10 @@ package io.mongock.driver.mongodb.springdata.v3; import io.mongock.driver.api.driver.ChangeSetDependency; +import io.mongock.driver.api.driver.ChangeSetDependencyBuildable; import io.mongock.driver.api.driver.Transactioner; import io.mongock.driver.api.entry.ChangeEntry; import io.mongock.driver.api.entry.ChangeEntryService; -import io.mongock.driver.api.lock.guard.invoker.LockGuardInvokerImpl; import com.github.cloudyrock.mongock.driver.mongodb.springdata.v3.decorator.impl.MongockTemplate; import io.mongock.driver.mongodb.sync.v4.driver.MongoSync4DriverGeneric; import io.mongock.api.exception.MongockException; @@ -45,10 +45,16 @@ public void runValidation() throws MongockException { } } + + @Override public void specificInitialization() { super.specificInitialization(); - dependencies.add(new ChangeSetDependency(MongockTemplate.class, new MongockTemplate(mongoTemplate, new LockGuardInvokerImpl(this.getLockManager())), false)); + dependencies.add(new ChangeSetDependencyBuildable( + MongockTemplate.class, + MongoTemplate.class, + impl -> new MongockTemplate((MongoTemplate) impl), + true)); dependencies.add(new ChangeSetDependency(MongoTemplate.class, this.mongoTemplate)); } diff --git a/drivers/mongock-driver-mongodb/pom.xml b/drivers/mongock-driver-mongodb/pom.xml index d19b1198b..85ce64712 100644 --- a/drivers/mongock-driver-mongodb/pom.xml +++ b/drivers/mongock-driver-mongodb/pom.xml @@ -29,10 +29,10 @@ [2.0.0, 3.0.0) - 3.2.0 + 3.2.5 2.2.13.RELEASE [4.0.0, 5.0.0) - 3.12.8 + [3.0.0, 4.0.0) 1.8 1.8 diff --git a/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependency.java b/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependency.java index 24b2e175e..35a917d83 100644 --- a/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependency.java +++ b/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependency.java @@ -10,8 +10,8 @@ public class ChangeSetDependency { private String name; private Class type; - private Object instance; private boolean proxeable; + protected Object instance; public ChangeSetDependency(Object instance) { @@ -31,23 +31,28 @@ public ChangeSetDependency(String name, Class type, Object instance) { } public ChangeSetDependency(String name, Class type, Object instance, boolean proxeable) { - checkParameters(name, type, instance); + this(name, type, proxeable); + if (instance == null) { + throw new MongockException("dependency instance cannot be null"); + } + this.instance = instance; + } + + protected ChangeSetDependency(String name, Class type, boolean proxeable) { + checkParameters(name, type); this.name = name; this.type = type; - this.instance = instance; this.proxeable = proxeable; } - private void checkParameters(String name, Class type, Object instance) { + + private void checkParameters(String name, Class type) { if (name == null || name.isEmpty()) { throw new MongockException("dependency name cannot be null/empty"); } if (type == null) { throw new MongockException("dependency type cannot be null"); } - if (instance == null) { - throw new MongockException("dependency instance cannot be null"); - } } public String getName() { diff --git a/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependencyBuildable.java b/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependencyBuildable.java index 6a2c79605..7d878eb7f 100644 --- a/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependencyBuildable.java +++ b/mongock-core/mongock-driver/mongock-driver-api/src/main/java/io/mongock/driver/api/driver/ChangeSetDependencyBuildable.java @@ -2,23 +2,37 @@ import java.util.function.Function; -public class DecoratorChangeSetDependency extends ChangeSetDependency{ - private final Function decoratorFunction; +/** + * This class it to hold dependencies that have as implementation a dependency from the DependencyManager itself. So they + * need to retrieve the impl from the dependencyManager + */ +public class ChangeSetDependencyBuildable extends ChangeSetDependency{ - public DecoratorChangeSetDependency(Class type, Class implType, Function decoratorFunction) { - super(DEFAULT_NAME, type, null, false); + private final Function decoratorFunction; + private final Class implType; + + public ChangeSetDependencyBuildable(Class type, Class implType, Function decoratorFunction, boolean implProxeable) { + super(DEFAULT_NAME, type, implProxeable); this.decoratorFunction = decoratorFunction; + this.implType = implType; } - public void setImpl(IMPL impl) { + public void setImpl(Object impl) { this.instance = impl; } @Override - @SuppressWarnings("unchecked") public Object getInstance() { - return decoratorFunction.apply((IMPL)instance); + return decoratorFunction.apply(instance); } + + public Function getDecoratorFunction() { + return decoratorFunction; + } + + public Class getImplType() { + return implType; + } } diff --git a/mongock-core/mongock-runner/mongock-runner-core/src/main/java/io/mongock/runner/core/executor/dependency/DependencyManager.java b/mongock-core/mongock-runner/mongock-runner-core/src/main/java/io/mongock/runner/core/executor/dependency/DependencyManager.java index 965836951..d34f5bda1 100644 --- a/mongock-core/mongock-runner/mongock-runner-core/src/main/java/io/mongock/runner/core/executor/dependency/DependencyManager.java +++ b/mongock-core/mongock-runner/mongock-runner-core/src/main/java/io/mongock/runner/core/executor/dependency/DependencyManager.java @@ -4,6 +4,7 @@ import io.mongock.driver.api.common.ForbiddenParameterException; import io.mongock.driver.api.common.Validable; import io.mongock.driver.api.driver.ChangeSetDependency; +import io.mongock.driver.api.driver.ChangeSetDependencyBuildable; import io.mongock.driver.api.lock.guard.proxy.LockGuardProxyFactory; import io.mongock.utils.annotation.NotThreadSafe; @@ -34,9 +35,25 @@ public Optional getDependency(Class type, String name, boolean lockGuard if (!dependencyOpt.isPresent()) { dependencyOpt = getDependencyFromStore(standardDependencies, type, name); } - return dependencyOpt.isPresent() && dependencyOpt.get().isProxeable() && lockGuarded - ? dependencyOpt.map(dependency -> lockGuardProxyFactory.getRawProxy(dependency.getInstance(), type)) - : dependencyOpt.map(ChangeSetDependency::getInstance); + if(!dependencyOpt.isPresent()) { + return Optional.empty(); + } + ChangeSetDependency dependency = dependencyOpt.get(); + if(ChangeSetDependencyBuildable.class.isAssignableFrom(dependency.getClass())) { + ChangeSetDependencyBuildable buildable = (ChangeSetDependencyBuildable)dependency; + Optional implOpt = getDependency(buildable.getImplType(), buildable.isProxeable()); + if(!implOpt.isPresent()) { + return Optional.empty(); + } + return implOpt.map(buildable.getDecoratorFunction()); + } else { + + return dependency.isProxeable() && lockGuarded + ? Optional.of(lockGuardProxyFactory.getRawProxy(dependency.getInstance(), type)) + : Optional.ofNullable(dependency.getInstance()); + } + + } @SuppressWarnings("unchecked") diff --git a/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/ChangeLogServiceTest.java b/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/ChangeLogServiceTest.java index 43a95880f..dba2b2038 100644 --- a/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/ChangeLogServiceTest.java +++ b/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/ChangeLogServiceTest.java @@ -220,11 +220,7 @@ public void shouldReturnChangeSetsFromMultiplePackagesAndIsolatedClassesAndKeeps assertEquals(2, changeLogPackage.getChangeSetItems().size()); ChangeSetItem changeSet2 = changeLogPackage.getChangeSetItems().get(0); ChangeSetItem changeSet3 = changeLogPackage.getChangeSetItems().get(1); - - System.out.println("\n\n\n******** " + changeLogPackage.getChangeSetItems().size()); - System.out.println("\n\n\n******** " + changeSet2.getId()); - System.out.println("\n\n\n******** " + changeSet3.getId()); - System.out.println("\n\n\n"); + assertEquals("no_package", changeSet2.getId()); assertEquals("noPackage", changeSet2.getMethod().getName()); diff --git a/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/changelogs/test1/ChangeLogSuccess12.java b/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/changelogs/test1/ChangeLogSuccess12.java index b89a45189..80c3ab60a 100644 --- a/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/changelogs/test1/ChangeLogSuccess12.java +++ b/mongock-core/mongock-runner/mongock-runner-core/src/test/java/io/mongock/runner/core/changelogs/test1/ChangeLogSuccess12.java @@ -13,7 +13,6 @@ public class ChangeLogSuccess12 { runAlways = true, systemVersion = "2") public void method_121() { - System.out.println(ChangeLogSuccess12.class.getCanonicalName() + ".method_121()"); } diff --git a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/defaultprofiled/DefaultProfiledChangerLog.java b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/defaultprofiled/DefaultProfiledChangerLog.java index 0a9d6aa3f..4f495db78 100644 --- a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/defaultprofiled/DefaultProfiledChangerLog.java +++ b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/defaultprofiled/DefaultProfiledChangerLog.java @@ -13,12 +13,10 @@ public class DefaultProfiledChangerLog { @Profile("default") @ChangeSet(author = "testuser", id = "default-profiled", order = "01") public void defaultProfiled() { - System.out.println("invoked Pdev1"); } @ChangeSet(author = "testuser", id = "no-profiled", order = "02") public void noProfiled() { - System.out.println("invoked Pdev2"); } diff --git a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/dev/DevProfiledChangerLog.java b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/dev/DevProfiledChangerLog.java index 713eb3bb8..d89088a81 100644 --- a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/dev/DevProfiledChangerLog.java +++ b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/dev/DevProfiledChangerLog.java @@ -12,25 +12,25 @@ public class DevProfiledChangerLog { @ChangeSet(author = "testuser", id = "Pdev1", order = "01") public void testChangeSet() { - System.out.println("invoked Pdev1"); + //System.out.println("invoked Pdev1"); } @ChangeSet(author = "testuser", id = "Pdev2", order = "02") @Profile("pro") public void testChangeSet2() { - System.out.println("invoked Pdev2"); + //System.out.println("invoked Pdev2"); } @ChangeSet(author = "testuser", id = "Pdev3", order = "03") @Profile("default") public void testChangeSet3() { - System.out.println("invoked Pdev3"); + //System.out.println("invoked Pdev3"); } @ChangeSet(author = "testuser", id = "Pdev4", order = "04", runAlways = true) @Profile("dev") public void testChangeSet4() { - System.out.println("invoked Pdev4"); + //System.out.println("invoked Pdev4"); } } diff --git a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/enseuredecorators/EnsureDecoratorChangerLog.java b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/enseuredecorators/EnsureDecoratorChangerLog.java index a97316ccf..e197635bf 100644 --- a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/enseuredecorators/EnsureDecoratorChangerLog.java +++ b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/enseuredecorators/EnsureDecoratorChangerLog.java @@ -16,7 +16,7 @@ public void ensureDecoratorChangeSet( CallVerifier callVerifier, TemplateForTestImpl templateForTest) { callVerifier.counter++; - System.out.println("invoked ensureDecoratorChangeSet"); + //System.out.println("invoked ensureDecoratorChangeSet"); if (templateForTest == null) { throw new RuntimeException("Must pass dependency"); diff --git a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/integration/IntegrationProfiledChangerLog.java b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/integration/IntegrationProfiledChangerLog.java index 0aa186c56..cabd2b3ca 100644 --- a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/integration/IntegrationProfiledChangerLog.java +++ b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/integration/IntegrationProfiledChangerLog.java @@ -17,28 +17,28 @@ public class IntegrationProfiledChangerLog { @Profile("profileIncluded1") @ChangeSet(author = "testuser", id = "testWithProfileIncluded1", order = "01") public void testWithProfileIncluded1() { - System.out.println("invoked testWIthProfileIncluded1"); + //System.out.println("invoked testWIthProfileIncluded1"); } // should be executed @Profile("profileIncluded2") @ChangeSet(author = "testuser", id = "testWithProfileIncluded2", order = "02") public void testWithProfileIncluded2() { - System.out.println("invoked testWIthProfileIncluded2"); + //System.out.println("invoked testWIthProfileIncluded2"); } // should not be executed @Profile("profileNotIncluded") @ChangeSet(author = "testuser", id = "testWithProfileINotIncluded", order = "03") public void testWithProfileINotIncluded() { - System.out.println("invoked testWithProfileINotIncluded"); + //System.out.println("invoked testWithProfileINotIncluded"); } // should not be executed @Profile("default") @ChangeSet(author = "testuser", id = "testWithDefaultProfile", order = "04") public void testWithDefaultProfile() { - System.out.println("invoked testWithDefaultProfile"); + //System.out.println("invoked testWithDefaultProfile"); } // should be executed @@ -49,7 +49,7 @@ public void testWithProfileIncluded1OrProfileINotIncluded( CallVerifier callVerifier, TemplateForTest templateForTest) { callVerifier.counter++; - System.out.println("invoked testWithProfileIncluded1OrProfileINotIncluded"); + //System.out.println("invoked testWithProfileIncluded1OrProfileINotIncluded"); if (environment == null) { throw new RuntimeException("Environment shouldn't be null in changeSet testWithProfileIncluded1OrProfileINotIncluded"); } diff --git a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/pro/ProProfiledChangeLog.java b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/pro/ProProfiledChangeLog.java index 7423df17e..ce7421516 100644 --- a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/pro/ProProfiledChangeLog.java +++ b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/pro/ProProfiledChangeLog.java @@ -9,18 +9,18 @@ public class ProProfiledChangeLog { @ChangeSet(author = "testuser", id = "no-profiled", order = "01") public void noProfiledMethod() { - System.out.println("invoked Pdev1"); + //System.out.println("invoked Pdev1"); } @Profile("pro") @ChangeSet(author = "testuser", id = "pro-profiled", order = "04") public void proProfiledMethod() { - System.out.println("invoked Pdev4"); + //System.out.println("invoked Pdev4"); } @Profile("!pro") @ChangeSet(author = "testuser", id = "no-pro-profiled", order = "05", runAlways = true) public void noProProfiledMethod() { - System.out.println("invoked Pdev5"); + //System.out.println("invoked Pdev5"); } } diff --git a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/unprofiled/UnprofiledChangerLog.java b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/unprofiled/UnprofiledChangerLog.java index b2b40eaf3..ba4f4be6e 100644 --- a/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/unprofiled/UnprofiledChangerLog.java +++ b/mongock-core/mongock-runner/spring/springboot/mongock-springboot/src/test/java/io/mongock/runner/springboot/profiles/unprofiled/UnprofiledChangerLog.java @@ -10,7 +10,7 @@ public class UnprofiledChangerLog { @ChangeSet(author = "testuser", id = "no-profiled", order = "01") public void noProfiled() { - System.out.println("invoked Pdev1"); + //System.out.println("invoked Pdev1"); } }