diff --git a/changelog/src/changelog/entries/2025/09/8467.SUP-19020.bugfix b/changelog/src/changelog/entries/2025/09/8467.SUP-19020.bugfix new file mode 100644 index 0000000000..833e0e1883 --- /dev/null +++ b/changelog/src/changelog/entries/2025/09/8467.SUP-19020.bugfix @@ -0,0 +1 @@ +Core: A default value of `true` for `MESH_HIBERNATE_SECOND_LEVEL_CACHE_ENABLED` config has been restored, enabling the second level SQL cache. The startup of a second level cache in the cluster environment has been fixed. \ No newline at end of file diff --git a/connectors/common/pom.xml b/connectors/common/pom.xml index cf1411d407..81b37dd2a5 100644 --- a/connectors/common/pom.xml +++ b/connectors/common/pom.xml @@ -25,6 +25,17 @@ mesh-mdm-hibernate-core provided + + com.gentics.mesh + mesh-database-tests-common + ${project.version} + test + + + com.gentics.mesh + mesh-test-common + test + diff --git a/connectors/common/src/test/java/com/gentics/mesh/core/ExternalDatabaseTestContextProvider.java b/connectors/common/src/test/java/com/gentics/mesh/core/ExternalDatabaseTestContextProvider.java new file mode 100644 index 0000000000..fddd752b15 --- /dev/null +++ b/connectors/common/src/test/java/com/gentics/mesh/core/ExternalDatabaseTestContextProvider.java @@ -0,0 +1,18 @@ +package com.gentics.mesh.core; + +import com.gentics.mesh.etc.config.HibernateMeshOptions; +import com.gentics.mesh.test.MeshOptionsProvider; +import com.gentics.mesh.test.MeshTestContextProvider; + +public class ExternalDatabaseTestContextProvider extends HibernateTestContextProvider implements MeshTestContextProvider { + + static { + System.setProperty(MeshOptionsProvider.ENV_OPTIONS_PROVIDER_CLASS, ExternalDatabaseTestContextProvider.class.getCanonicalName()); + } + + @Override + public void fillMeshOptions(HibernateMeshOptions meshOptions) { + // Taken from the env variables of HibernateMeshOptions + } + +} diff --git a/connectors/hsqldb/src/test/java/com/gentics/mesh/core/HSQLMemoryTestContextProvider.java b/connectors/hsqldb/src/test/java/com/gentics/mesh/core/HSQLMemoryTestContextProvider.java index 7f2b6bae18..8c9a052b53 100644 --- a/connectors/hsqldb/src/test/java/com/gentics/mesh/core/HSQLMemoryTestContextProvider.java +++ b/connectors/hsqldb/src/test/java/com/gentics/mesh/core/HSQLMemoryTestContextProvider.java @@ -123,5 +123,4 @@ public Comparator reversed() { } }; } - } diff --git a/mdm/hibernate-api/src/main/java/com/gentics/mesh/etc/config/hibernate/HibernateStorageOptions.java b/mdm/hibernate-api/src/main/java/com/gentics/mesh/etc/config/hibernate/HibernateStorageOptions.java index c155db84ce..4973431e95 100644 --- a/mdm/hibernate-api/src/main/java/com/gentics/mesh/etc/config/hibernate/HibernateStorageOptions.java +++ b/mdm/hibernate-api/src/main/java/com/gentics/mesh/etc/config/hibernate/HibernateStorageOptions.java @@ -37,7 +37,7 @@ public class HibernateStorageOptions implements Option { public static final String DEFAULT_CONNECTION_PASSWORD = "admin"; public static final Boolean DEFAULT_SHOW_SQL = false; public static final Boolean DEFAULT_FORMAT_SQL = false; - public static final Boolean DEFAULT_SECOND_LEVEL_CACHE_ENABLED = false; + public static final Boolean DEFAULT_SECOND_LEVEL_CACHE_ENABLED = true; public static final Boolean DEFAULT_GENERATE_STATISTICS = false; public static final long DEFAULT_QUERY_TIMEOUT = 0; public static final int DEFAULT_HIBERNATE_JDBC_BATCH_SIZE = 5; diff --git a/mdm/hibernate-core/src/main/java/com/gentics/mesh/database/DefaultSQLDatabase.java b/mdm/hibernate-core/src/main/java/com/gentics/mesh/database/DefaultSQLDatabase.java index e583c78dba..51aaaa48f9 100644 --- a/mdm/hibernate-core/src/main/java/com/gentics/mesh/database/DefaultSQLDatabase.java +++ b/mdm/hibernate-core/src/main/java/com/gentics/mesh/database/DefaultSQLDatabase.java @@ -86,7 +86,7 @@ private void setSecondLevelCacheOptions(ImmutableMap.Builder opt if (options.getClusterOptions().isEnabled()) { optionBuilder .put("hibernate.cache.region.factory_class", HazelcastLocalCacheRegionFactory.class.getName()) - .put("hibernate.cache.hazelcast.instance_name", options.getClusterOptions().getClusterName()); + .put("hibernate.cache.hazelcast.instance_name", options.getNodeName()); } else { optionBuilder .put("hibernate.cache.region.factory_class", JCacheRegionFactory.class.getName()) diff --git a/tests/api/src/main/java/com/gentics/mesh/test/MeshOptionsProvider.java b/tests/api/src/main/java/com/gentics/mesh/test/MeshOptionsProvider.java index b37e669d4e..8eeaaa586d 100644 --- a/tests/api/src/main/java/com/gentics/mesh/test/MeshOptionsProvider.java +++ b/tests/api/src/main/java/com/gentics/mesh/test/MeshOptionsProvider.java @@ -3,7 +3,10 @@ import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.Modifier; +import java.util.Objects; +import java.util.Optional; import java.util.ServiceLoader; +import java.util.function.Function; import org.apache.commons.lang3.StringUtils; @@ -43,7 +46,7 @@ public interface MeshOptionsProvider { * @return */ public static MeshOptionsProvider getProvider() { - return spawnProviderInstance(System.getProperty(ENV_OPTIONS_PROVIDER_CLASS), MeshOptionsProvider.class); + return spawnProviderInstance(getOptionalConfig(ENV_OPTIONS_PROVIDER_CLASS, (String)null, Function.identity(), Object::toString), MeshOptionsProvider.class); } @SuppressWarnings("unchecked") @@ -99,4 +102,25 @@ static boolean isEligible(Class classOfT) { return true; } } + + /** + * Get an optional configuration from either the environment variable, or the system parameter. + * + * @param + * @param configName + * @param defaultValue + * @param parse + * @param stringify + * @return + */ + static T getOptionalConfig(String configName, T defaultValue, Function parse, Function stringify) { + return parse.apply(System.getenv() + .entrySet().stream() + .filter(e -> e.getKey().equals(configName)) + .map(e -> e.getValue()) + .filter(Objects::nonNull) + .findAny() + .or(() -> Optional.ofNullable(System.getProperty(configName, stringify.apply(defaultValue)))) + .orElseGet(() -> stringify.apply(defaultValue))); + } } diff --git a/tests/common/src/main/java/com/gentics/mesh/test/TestDataProvider.java b/tests/common/src/main/java/com/gentics/mesh/test/TestDataProvider.java index ccd2acb9a0..29ec36cc75 100644 --- a/tests/common/src/main/java/com/gentics/mesh/test/TestDataProvider.java +++ b/tests/common/src/main/java/com/gentics/mesh/test/TestDataProvider.java @@ -409,9 +409,15 @@ private void addUserGroupRoleProject(Tx tx) { project.addLanguage(tx.languageDao().findByLanguageTag(getGerman())); } HibUser jobUser = userInfo.getUser(); - //schemaDao.assign(getSchemaContainer("folder"), project, jobUser, batch); // already done - schemaDao.assign(getSchemaContainer("content"), project, jobUser, batch); - schemaDao.assign(getSchemaContainer("binary_content"), project, jobUser, batch); + if (!schemaDao.isLinkedToProject(getSchemaContainer("folder"), project)) { + schemaDao.assign(getSchemaContainer("folder"), project, jobUser, batch); + } + if (!schemaDao.isLinkedToProject(getSchemaContainer("content"), project)) { + schemaDao.assign(getSchemaContainer("content"), project, jobUser, batch); + } + if (!schemaDao.isLinkedToProject(getSchemaContainer("binary_content"), project)) { + schemaDao.assign(getSchemaContainer("binary_content"), project, jobUser, batch); + } projectUuid = project.getUuid(); branchUuid = project.getInitialBranch().getUuid(); diff --git a/tests/context-api/src/main/java/com/gentics/mesh/test/MeshTestContextProvider.java b/tests/context-api/src/main/java/com/gentics/mesh/test/MeshTestContextProvider.java index 65764160b1..4c4a760b6e 100644 --- a/tests/context-api/src/main/java/com/gentics/mesh/test/MeshTestContextProvider.java +++ b/tests/context-api/src/main/java/com/gentics/mesh/test/MeshTestContextProvider.java @@ -1,6 +1,7 @@ package com.gentics.mesh.test; import java.util.Comparator; +import java.util.function.Function; import com.gentics.mesh.etc.config.MeshOptions; @@ -31,7 +32,7 @@ public interface MeshTestContextProvider extends MeshOptionsProvider { * @return */ public static MeshTestContextProvider getProvider() { - return MeshOptionsProvider.spawnProviderInstance(System.getProperty(ENV_TEST_CONTEXT_PROVIDER_CLASS), MeshTestContextProvider.class); + return MeshOptionsProvider.spawnProviderInstance(MeshOptionsProvider.getOptionalConfig(ENV_TEST_CONTEXT_PROVIDER_CLASS, (String)null, Function.identity(), Object::toString), MeshTestContextProvider.class); } /** diff --git a/tests/tests-core/src/main/java/com/gentics/mesh/core/node/AbstractMassiveNodeLoadTest.java b/tests/tests-core/src/main/java/com/gentics/mesh/core/node/AbstractMassiveNodeLoadTest.java index ebe436f621..81d31367d8 100644 --- a/tests/tests-core/src/main/java/com/gentics/mesh/core/node/AbstractMassiveNodeLoadTest.java +++ b/tests/tests-core/src/main/java/com/gentics/mesh/core/node/AbstractMassiveNodeLoadTest.java @@ -4,6 +4,10 @@ import static com.gentics.mesh.test.TestDataProvider.PROJECT_NAME; import static org.junit.Assert.assertEquals; +import java.util.Optional; +import java.util.UUID; +import java.util.function.BiFunction; + import org.junit.After; import org.junit.Before; @@ -13,10 +17,12 @@ import com.gentics.mesh.core.rest.node.FieldMapImpl; import com.gentics.mesh.core.rest.node.NodeCreateRequest; import com.gentics.mesh.core.rest.node.NodeListResponse; +import com.gentics.mesh.core.rest.node.NodeUpsertRequest; import com.gentics.mesh.core.rest.schema.impl.SchemaReferenceImpl; import com.gentics.mesh.parameter.impl.DeleteParametersImpl; import com.gentics.mesh.parameter.impl.VersioningParametersImpl; import com.gentics.mesh.test.context.AbstractMeshTest; +import com.gentics.mesh.util.UUIDUtil; public abstract class AbstractMassiveNodeLoadTest extends AbstractMeshTest { @@ -44,19 +50,34 @@ public void nukeEmAll() { } protected void makeEmAll(long howMany, String parentNodeUuid) { + makeEmAll(howMany, parentNodeUuid, false, Optional.empty()); + } + + protected void makeEmAll(long howMany, String parentNodeUuid, boolean publish, Optional> maybeUuidProvider) { try (Tx tx = tx()) { if (parentFolderUuid == null) { SchemaReferenceImpl schemaReference = new SchemaReferenceImpl(); schemaReference.setName("folder"); - NodeCreateRequest create2 = new NodeCreateRequest(); FieldMap fields = new FieldMapImpl(); fields.put("name", FieldUtil.createStringField("MassiveParentFolder")); fields.put("slug", FieldUtil.createStringField("massiveparentfolder")); - create2.setFields(fields); - create2.setSchema(schemaReference); - create2.setLanguage("en"); - create2.setParentNodeUuid(parentNodeUuid); - parentFolderUuid = call(() -> client().createNode(PROJECT_NAME, create2)).getUuid(); + parentFolderUuid = maybeUuidProvider.map(uuidProvider -> { + NodeUpsertRequest create2 = new NodeUpsertRequest(); + create2.setFields(fields); + create2.setSchema(schemaReference); + create2.setLanguage("en"); + create2.setParentNodeUuid(parentNodeUuid); + create2.setPublish(publish); + return call(() -> client().upsertNode(PROJECT_NAME, UUIDUtil.toShortUuid(maybeUuidProvider.get().apply(UUIDUtil.toJavaUuid(parentNodeUuid), -1)), create2)).getUuid(); + }).orElseGet(() -> { + NodeCreateRequest create2 = new NodeCreateRequest(); + create2.setFields(fields); + create2.setSchema(schemaReference); + create2.setLanguage("en"); + create2.setParentNodeUuid(parentNodeUuid); + create2.setPublish(publish); + return call(() -> client().createNode(PROJECT_NAME, create2)).getUuid(); + }); } NodeListResponse nodeList = call(() -> client().findNodeChildren(PROJECT_NAME, parentFolderUuid, new VersioningParametersImpl().draft())); @@ -66,15 +87,27 @@ protected void makeEmAll(long howMany, String parentNodeUuid) { schemaReference.setName("folder"); for (int i = 0; i < howMany; i++) { - NodeCreateRequest create2 = new NodeCreateRequest(); + final int ii = i; FieldMap fields = new FieldMapImpl(); fields.put("name", FieldUtil.createStringField("Folder " + i)); fields.put("slug", FieldUtil.createStringField("folder" + i)); - create2.setFields(fields); - create2.setSchema(schemaReference); - create2.setLanguage("en"); - create2.setParentNodeUuid(parentFolderUuid); - call(() -> client().createNode(PROJECT_NAME, create2)); + maybeUuidProvider.ifPresentOrElse(uuidProvider -> { + NodeUpsertRequest upsert2 = new NodeUpsertRequest(); + upsert2.setFields(fields); + upsert2.setSchema(schemaReference); + upsert2.setLanguage("en"); + upsert2.setParentNodeUuid(parentFolderUuid); + upsert2.setPublish(publish); + call(() -> client().upsertNode(PROJECT_NAME, UUIDUtil.toShortUuid(uuidProvider.apply(UUIDUtil.toJavaUuid(parentFolderUuid), ii)), upsert2)); + }, () -> { + NodeCreateRequest create2 = new NodeCreateRequest(); + create2.setFields(fields); + create2.setSchema(schemaReference); + create2.setLanguage("en"); + create2.setParentNodeUuid(parentFolderUuid); + create2.setPublish(publish); + call(() -> client().createNode(PROJECT_NAME, create2)); + }); } } } diff --git a/tests/tests-core/src/main/java/com/gentics/mesh/core/node/NodeLotOfChildrenTest.java b/tests/tests-core/src/main/java/com/gentics/mesh/core/node/NodeLotOfChildrenTest.java index e91c906e5c..3ceaa22ddc 100644 --- a/tests/tests-core/src/main/java/com/gentics/mesh/core/node/NodeLotOfChildrenTest.java +++ b/tests/tests-core/src/main/java/com/gentics/mesh/core/node/NodeLotOfChildrenTest.java @@ -16,7 +16,6 @@ public class NodeLotOfChildrenTest extends AbstractMassiveNodeLoadTest { @Test public void testReadAll() { - String uuid = tx(() -> project().getBaseNode().getUuid()); NodeListResponse nodeList = call(() -> client().findNodeChildren(PROJECT_NAME, parentFolderUuid, new VersioningParametersImpl().draft())); assertEquals("The subnode did not contain the created node", numOfNodesPerLevel, nodeList.getData().size()); } diff --git a/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/AbstractMassivePublishTest.java b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/AbstractMassivePublishTest.java new file mode 100644 index 0000000000..4f4068df11 --- /dev/null +++ b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/AbstractMassivePublishTest.java @@ -0,0 +1,52 @@ +package com.gentics.mesh.cache; + +import java.time.Instant; +import java.time.format.DateTimeFormatter; +import java.util.Optional; +import java.util.UUID; +import java.util.concurrent.TimeUnit; +import java.util.function.BiFunction; + +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.rules.RuleChain; +import org.junit.rules.Timeout; + +import com.gentics.mesh.core.node.AbstractMassiveNodeLoadTest; +import com.gentics.mesh.util.UUIDUtil; + +import ch.qos.logback.core.util.Duration; + +public abstract class AbstractMassivePublishTest extends AbstractMassiveNodeLoadTest { + + /** + * Global Test Timeout of 60 Minutes, to fit 'em all + */ + public static Timeout globalTimeout= new Timeout(60, TimeUnit.MINUTES); + + @ClassRule + public static RuleChain chain = RuleChain.outerRule(globalTimeout).around(testContext); + + protected static final UUID VERY_BASE_UUID = UUIDUtil.toJavaUuid("6B06697A9ABE11F096B6F7559C093C6E"); + + public AbstractMassivePublishTest() { + super(10000); + } + + @Before + public void makeEmAll() { + // No make yet + } + + @Test + public void testAndMeasureMassivePublish() { + Instant started = Instant.now(); + System.out.println(String.format("Publish started at %s", DateTimeFormatter.ISO_INSTANT.format(started))); + makeEmAll(numOfNodesPerLevel, tx(() -> project().getBaseNode().getUuid()), true, getMaybeUuidProvider()); + Instant ended = Instant.now(); + System.out.println(String.format("Publish ended at %s, duration %s", DateTimeFormatter.ISO_INSTANT.format(ended), Duration.buildByMilliseconds(ended.toEpochMilli() - started.toEpochMilli()))); + } + + protected abstract Optional> getMaybeUuidProvider(); +} diff --git a/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveOrderedPublishTestCached.java b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveOrderedPublishTestCached.java new file mode 100644 index 0000000000..9b5a829b58 --- /dev/null +++ b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveOrderedPublishTestCached.java @@ -0,0 +1,43 @@ +package com.gentics.mesh.cache; + +import static com.gentics.mesh.test.ElasticsearchTestMode.TRACKING; +import static com.gentics.mesh.test.TestSize.FULL; + +import java.math.BigInteger; +import java.util.Optional; +import java.util.UUID; +import java.util.function.BiFunction; + +import org.junit.experimental.categories.Category; + +import com.gentics.mesh.etc.config.HibernateMeshOptions; +import com.gentics.mesh.etc.config.MeshOptions; +import com.gentics.mesh.test.MeshOptionChanger; +import com.gentics.mesh.test.MeshTestSetting; +import com.gentics.mesh.test.category.FailingTests; +import com.gentics.mesh.util.UUIDUtil; + +@MeshTestSetting(elasticsearch = TRACKING, testSize = FULL, startServer = true, customOptionChanger = NodeMassiveOrderedPublishTestCached.class) +@Category({FailingTests.class}) +//Not actually failing, but may last long +public class NodeMassiveOrderedPublishTestCached extends AbstractMassivePublishTest implements MeshOptionChanger { + + @Override + public void change(MeshOptions options) { + HibernateMeshOptions.class.cast(options).getStorageOptions().setSecondLevelCacheEnabled(true); + } + + @Override + protected Optional> getMaybeUuidProvider() { + return Optional.of((uuid, i) -> { + if (i < 0) { + i = 0; + uuid = VERY_BASE_UUID; + } + BigInteger number = new BigInteger(UUIDUtil.toBytes(uuid)); + // Minus! + number = number.subtract(BigInteger.valueOf(i)); + return UUIDUtil.toJavaUuid(number.toByteArray()); + }); + } +} diff --git a/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveOrderedPublishTestNoCache.java b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveOrderedPublishTestNoCache.java new file mode 100644 index 0000000000..cb53d29fee --- /dev/null +++ b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveOrderedPublishTestNoCache.java @@ -0,0 +1,43 @@ +package com.gentics.mesh.cache; + +import static com.gentics.mesh.test.ElasticsearchTestMode.TRACKING; +import static com.gentics.mesh.test.TestSize.FULL; + +import java.math.BigInteger; +import java.util.Optional; +import java.util.UUID; +import java.util.function.BiFunction; + +import org.junit.experimental.categories.Category; + +import com.gentics.mesh.etc.config.HibernateMeshOptions; +import com.gentics.mesh.etc.config.MeshOptions; +import com.gentics.mesh.test.MeshOptionChanger; +import com.gentics.mesh.test.MeshTestSetting; +import com.gentics.mesh.test.category.FailingTests; +import com.gentics.mesh.util.UUIDUtil; + +@MeshTestSetting(elasticsearch = TRACKING, testSize = FULL, startServer = true, customOptionChanger = NodeMassiveOrderedPublishTestNoCache.class) +@Category({FailingTests.class}) +//Not actually failing, but may last long +public class NodeMassiveOrderedPublishTestNoCache extends AbstractMassivePublishTest implements MeshOptionChanger { + + @Override + public void change(MeshOptions options) { + HibernateMeshOptions.class.cast(options).getStorageOptions().setSecondLevelCacheEnabled(false); + } + + @Override + protected Optional> getMaybeUuidProvider() { + return Optional.of((uuid, i) -> { + if (i < 0) { + i = 0; + uuid = VERY_BASE_UUID; + } + BigInteger number = new BigInteger(UUIDUtil.toBytes(uuid)); + // Plus! + number = number.add(BigInteger.valueOf(i)); + return UUIDUtil.toJavaUuid(number.toByteArray()); + }); + } +} diff --git a/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveRandomPublishTestCached.java b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveRandomPublishTestCached.java new file mode 100644 index 0000000000..0bd00cab52 --- /dev/null +++ b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveRandomPublishTestCached.java @@ -0,0 +1,32 @@ +package com.gentics.mesh.cache; + +import static com.gentics.mesh.test.ElasticsearchTestMode.TRACKING; +import static com.gentics.mesh.test.TestSize.FULL; + +import java.util.Optional; +import java.util.UUID; +import java.util.function.BiFunction; + +import org.junit.experimental.categories.Category; + +import com.gentics.mesh.etc.config.HibernateMeshOptions; +import com.gentics.mesh.etc.config.MeshOptions; +import com.gentics.mesh.test.MeshOptionChanger; +import com.gentics.mesh.test.MeshTestSetting; +import com.gentics.mesh.test.category.FailingTests; + +@MeshTestSetting(elasticsearch = TRACKING, testSize = FULL, startServer = true, customOptionChanger = NodeMassiveRandomPublishTestCached.class) +@Category({FailingTests.class}) +// Not actually failing, but may last long +public class NodeMassiveRandomPublishTestCached extends AbstractMassivePublishTest implements MeshOptionChanger { + + @Override + public void change(MeshOptions options) { + HibernateMeshOptions.class.cast(options).getStorageOptions().setSecondLevelCacheEnabled(true); + } + + @Override + protected Optional> getMaybeUuidProvider() { + return Optional.empty(); + } +} diff --git a/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveRandomPublishTestNoCache.java b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveRandomPublishTestNoCache.java new file mode 100644 index 0000000000..74c91fa079 --- /dev/null +++ b/tests/tests-hibernate/src/main/java/com/gentics/mesh/cache/NodeMassiveRandomPublishTestNoCache.java @@ -0,0 +1,32 @@ +package com.gentics.mesh.cache; + +import static com.gentics.mesh.test.ElasticsearchTestMode.TRACKING; +import static com.gentics.mesh.test.TestSize.FULL; + +import java.util.Optional; +import java.util.UUID; +import java.util.function.BiFunction; + +import org.junit.experimental.categories.Category; + +import com.gentics.mesh.etc.config.HibernateMeshOptions; +import com.gentics.mesh.etc.config.MeshOptions; +import com.gentics.mesh.test.MeshOptionChanger; +import com.gentics.mesh.test.MeshTestSetting; +import com.gentics.mesh.test.category.FailingTests; + +@MeshTestSetting(elasticsearch = TRACKING, testSize = FULL, startServer = true, customOptionChanger = NodeMassiveRandomPublishTestNoCache.class) +@Category({FailingTests.class}) +//Not actually failing, but may last long +public class NodeMassiveRandomPublishTestNoCache extends AbstractMassivePublishTest implements MeshOptionChanger { + + @Override + public void change(MeshOptions options) { + HibernateMeshOptions.class.cast(options).getStorageOptions().setSecondLevelCacheEnabled(false); + } + + @Override + protected Optional> getMaybeUuidProvider() { + return Optional.empty(); + } +}