diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 92658998df..20a1f50341 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -547,7 +547,7 @@ jobs: run: | echo "Storage available before deletion" df -h / - echo + echo sudo rm -r /usr/local/lib/android echo "Storage available after deletion" df -h / @@ -565,10 +565,10 @@ jobs: - name: Wait for the container to be ready timeout-minutes: 5 run : | - while [ "`docker inspect -f {{.State.Health.Status}} oracle-23`" != "healthy" ] - do + while [ "`docker inspect -f {{.State.Health.Status}} oracle-23`" != "healthy" ] + do sleep 10 - echo "Container is not yet ready" + echo "Container is not yet ready" done echo "Container is ready" diff --git a/core/build.gradle b/core/build.gradle index 92bfe85a50..24ccc3886a 100644 --- a/core/build.gradle +++ b/core/build.gradle @@ -145,7 +145,7 @@ task integrationTestCosmos(type: Test) { systemProperties(System.getProperties()) } maxParallelForks = 3 - jvmArgs '-XX:MaxDirectMemorySize=2g', '-Xmx4g' + jvmArgs '-XX:MaxDirectMemorySize=4g', '-Xmx4g' } task integrationTestDynamo(type: Test) { diff --git a/core/src/integration-test/java/com/scalar/db/storage/cassandra/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra.java b/core/src/integration-test/java/com/scalar/db/storage/cassandra/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra.java new file mode 100644 index 0000000000..423e6c2a7c --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/cassandra/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra.java @@ -0,0 +1,19 @@ +package com.scalar.db.storage.cassandra; + +import com.scalar.db.transaction.consensuscommit.ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Collections; +import java.util.Map; +import java.util.Properties; + +public class ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra + extends ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + @Override + protected Properties getProperties(String testName) { + return CassandraEnv.getProperties(testName); + } + + @Override + protected Map getCreationOptions() { + return Collections.singletonMap(CassandraAdmin.REPLICATION_FACTOR, "1"); + } +} diff --git a/core/src/integration-test/java/com/scalar/db/storage/cassandra/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra.java b/core/src/integration-test/java/com/scalar/db/storage/cassandra/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra.java new file mode 100644 index 0000000000..cee789f8b5 --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/cassandra/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra.java @@ -0,0 +1,19 @@ +package com.scalar.db.storage.cassandra; + +import com.scalar.db.transaction.consensuscommit.TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Collections; +import java.util.Map; +import java.util.Properties; + +public class TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCassandra + extends TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + @Override + protected Properties getProperties(String testName) { + return CassandraEnv.getProperties(testName); + } + + @Override + protected Map getCreationOptions() { + return Collections.singletonMap(CassandraAdmin.REPLICATION_FACTOR, "1"); + } +} diff --git a/core/src/integration-test/java/com/scalar/db/storage/cosmos/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos.java b/core/src/integration-test/java/com/scalar/db/storage/cosmos/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos.java new file mode 100644 index 0000000000..fc2c35bed6 --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/cosmos/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos.java @@ -0,0 +1,27 @@ +package com.scalar.db.storage.cosmos; + +import com.scalar.db.transaction.consensuscommit.ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Map; +import java.util.Optional; +import java.util.Properties; + +public class ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos + extends ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + @Override + protected Properties getProperties(String testName) { + return CosmosEnv.getProperties(testName); + } + + @Override + protected String getNamespace() { + String namespace = super.getNamespace(); + Optional databasePrefix = CosmosEnv.getDatabasePrefix(); + return databasePrefix.map(prefix -> prefix + namespace).orElse(namespace); + } + + @Override + protected Map getCreationOptions() { + return CosmosEnv.getCreationOptions(); + } +} diff --git a/core/src/integration-test/java/com/scalar/db/storage/cosmos/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos.java b/core/src/integration-test/java/com/scalar/db/storage/cosmos/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos.java new file mode 100644 index 0000000000..38179d0928 --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/cosmos/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos.java @@ -0,0 +1,27 @@ +package com.scalar.db.storage.cosmos; + +import com.scalar.db.transaction.consensuscommit.TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Map; +import java.util.Optional; +import java.util.Properties; + +public class TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithCosmos + extends TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + @Override + protected Properties getProperties(String testName) { + return CosmosEnv.getProperties(testName); + } + + @Override + protected String getNamespace() { + String namespace = super.getNamespace(); + Optional databasePrefix = CosmosEnv.getDatabasePrefix(); + return databasePrefix.map(prefix -> prefix + namespace).orElse(namespace); + } + + @Override + protected Map getCreationOptions() { + return CosmosEnv.getCreationOptions(); + } +} diff --git a/core/src/integration-test/java/com/scalar/db/storage/dynamo/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo.java b/core/src/integration-test/java/com/scalar/db/storage/dynamo/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo.java new file mode 100644 index 0000000000..19a9219696 --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/dynamo/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo.java @@ -0,0 +1,19 @@ +package com.scalar.db.storage.dynamo; + +import com.scalar.db.transaction.consensuscommit.ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Map; +import java.util.Properties; + +public class ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo + extends ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + @Override + protected Properties getProperties(String testName) { + return DynamoEnv.getProperties(testName); + } + + @Override + protected Map getCreationOptions() { + return DynamoEnv.getCreationOptions(); + } +} diff --git a/core/src/integration-test/java/com/scalar/db/storage/dynamo/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo.java b/core/src/integration-test/java/com/scalar/db/storage/dynamo/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo.java new file mode 100644 index 0000000000..4f20ad7b59 --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/dynamo/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo.java @@ -0,0 +1,19 @@ +package com.scalar.db.storage.dynamo; + +import com.scalar.db.transaction.consensuscommit.TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Map; +import java.util.Properties; + +public class TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithDynamo + extends TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + @Override + protected Properties getProperties(String testName) { + return DynamoEnv.getProperties(testName); + } + + @Override + protected Map getCreationOptions() { + return DynamoEnv.getCreationOptions(); + } +} diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase.java new file mode 100644 index 0000000000..cca816a14d --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/jdbc/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase.java @@ -0,0 +1,13 @@ +package com.scalar.db.storage.jdbc; + +import com.scalar.db.transaction.consensuscommit.ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Properties; + +public class ConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase + extends ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + @Override + protected Properties getProperties(String testName) { + return JdbcEnv.getProperties(testName); + } +} diff --git a/core/src/integration-test/java/com/scalar/db/storage/jdbc/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase.java b/core/src/integration-test/java/com/scalar/db/storage/jdbc/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase.java new file mode 100644 index 0000000000..57dc02feba --- /dev/null +++ b/core/src/integration-test/java/com/scalar/db/storage/jdbc/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase.java @@ -0,0 +1,13 @@ +package com.scalar.db.storage.jdbc; + +import com.scalar.db.transaction.consensuscommit.TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase; +import java.util.Properties; + +public class TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestWithJdbcDatabase + extends TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + @Override + protected Properties getProperties(String testName) { + return JdbcEnv.getProperties(testName); + } +} diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminImportTableIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminImportTableIntegrationTestBase.java index f1a10faed1..3839e09580 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminImportTableIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminImportTableIntegrationTestBase.java @@ -1,7 +1,6 @@ package com.scalar.db.transaction.consensuscommit; import com.scalar.db.api.DistributedTransactionAdminImportTableIntegrationTestBase; -import com.scalar.db.config.DatabaseConfig; import java.util.Properties; public abstract class ConsensusCommitAdminImportTableIntegrationTestBase @@ -11,16 +10,10 @@ public abstract class ConsensusCommitAdminImportTableIntegrationTestBase protected final Properties getProperties(String testName) { Properties properties = new Properties(); properties.putAll(getProps(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - properties.setProperty(DatabaseConfig.TRANSACTION_MANAGER, "consensus-commit"); - // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + testName); - } + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); + return properties; } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java index a285bb43dc..e8a61920bd 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminIntegrationTestBase.java @@ -1,74 +1,21 @@ package com.scalar.db.transaction.consensuscommit; -import static org.assertj.core.api.Assertions.assertThat; - -import com.scalar.db.api.DistributedTransactionAdmin; import com.scalar.db.api.DistributedTransactionAdminIntegrationTestBase; -import com.scalar.db.api.TableMetadata; -import com.scalar.db.config.DatabaseConfig; -import com.scalar.db.exception.storage.ExecutionException; -import com.scalar.db.service.TransactionFactory; import java.util.Properties; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.Test; public abstract class ConsensusCommitAdminIntegrationTestBase extends DistributedTransactionAdminIntegrationTestBase { - private DistributedTransactionAdmin adminWithIncludeMetadataEnabled; - - @Override - protected void initialize(String testName) throws Exception { - Properties includeMetadataEnabledProperties = getPropsWithIncludeMetadataEnabled(testName); - adminWithIncludeMetadataEnabled = - TransactionFactory.create(includeMetadataEnabledProperties).getTransactionAdmin(); - } - - @AfterAll - @Override - public void afterAll() throws Exception { - super.afterAll(); - - adminWithIncludeMetadataEnabled.close(); - } @Override protected final Properties getProperties(String testName) { Properties properties = new Properties(); properties.putAll(getProps(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - properties.setProperty(DatabaseConfig.TRANSACTION_MANAGER, "consensus-commit"); - // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + testName); - } - return properties; - } - - protected abstract Properties getProps(String testName); + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties(testName); - properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); return properties; } - @Test - public void - getTableMetadata_WhenIncludeMetadataIsEnabled_ShouldReturnCorrectMetadataWithTransactionMetadataColumns() - throws ExecutionException { - // Arrange - TableMetadata transactionTableMetadata = - ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_METADATA); - - // Act - TableMetadata tableMetadata = - adminWithIncludeMetadataEnabled.getTableMetadata(getNamespace1(), TABLE1); - - // Assert - assertThat(tableMetadata).isEqualTo(transactionTableMetadata); - } + protected abstract Properties getProps(String testName); } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminRepairIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminRepairIntegrationTestBase.java index 09021ce0b7..95b4752fe3 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminRepairIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitAdminRepairIntegrationTestBase.java @@ -1,7 +1,6 @@ package com.scalar.db.transaction.consensuscommit; import com.scalar.db.api.DistributedTransactionAdminRepairIntegrationTestBase; -import com.scalar.db.config.DatabaseConfig; import java.util.Properties; public abstract class ConsensusCommitAdminRepairIntegrationTestBase @@ -11,16 +10,10 @@ public abstract class ConsensusCommitAdminRepairIntegrationTestBase protected final Properties getProperties(String testName) { Properties properties = new Properties(); properties.putAll(getProps(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - properties.setProperty(DatabaseConfig.TRANSACTION_MANAGER, "consensus-commit"); - // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + testName); - } + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); + return properties; } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitCrossPartitionScanIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitCrossPartitionScanIntegrationTestBase.java index ac411842e2..a1b62e58d4 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitCrossPartitionScanIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitCrossPartitionScanIntegrationTestBase.java @@ -4,50 +4,18 @@ import static org.assertj.core.api.Assertions.catchThrowable; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import com.google.common.collect.ImmutableSet; import com.scalar.db.api.ConditionBuilder; import com.scalar.db.api.Consistency; import com.scalar.db.api.DistributedTransaction; import com.scalar.db.api.DistributedTransactionCrossPartitionScanIntegrationTestBase; -import com.scalar.db.api.DistributedTransactionManager; import com.scalar.db.api.Put; -import com.scalar.db.api.Result; import com.scalar.db.api.Scan; -import com.scalar.db.api.ScanBuilder.BuildableScanOrScanAllFromExisting; -import com.scalar.db.api.TableMetadata; -import com.scalar.db.config.DatabaseConfig; import com.scalar.db.exception.transaction.TransactionException; -import com.scalar.db.io.Column; -import com.scalar.db.io.Key; -import com.scalar.db.service.TransactionFactory; -import java.util.List; import java.util.Properties; -import java.util.Set; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; public abstract class ConsensusCommitCrossPartitionScanIntegrationTestBase extends DistributedTransactionCrossPartitionScanIntegrationTestBase { - private DistributedTransactionManager managerWithIncludeMetadataEnabled; - - @BeforeAll - @Override - public void beforeAll() throws Exception { - super.beforeAll(); - - Properties includeMetadataEnabledProperties = getPropsWithIncludeMetadataEnabled(getTestName()); - managerWithIncludeMetadataEnabled = - TransactionFactory.create(includeMetadataEnabledProperties).getTransactionManager(); - } - - @AfterAll - @Override - public void afterAll() throws Exception { - super.afterAll(); - - managerWithIncludeMetadataEnabled.close(); - } @Override protected String getTestName() { @@ -58,27 +26,15 @@ protected String getTestName() { protected final Properties getProperties(String testName) { Properties properties = new Properties(); properties.putAll(getProps(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - properties.setProperty(DatabaseConfig.TRANSACTION_MANAGER, "consensus-commit"); - - // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + testName); - } - return properties; - } - protected abstract Properties getProps(String testName); + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties(testName); - properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); return properties; } + protected abstract Properties getProps(String testName); + @Test public void scan_PutAndOverlappedCrossPartitionScanGiven_ShouldThrowException() throws TransactionException { @@ -191,61 +147,4 @@ public void scan_PutResultOverlappedWithCrossPartitionScanWithLikeGiven_ShouldTh // Assert assertThat(thrown).isInstanceOf(IllegalArgumentException.class); } - - @Test - public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - scan_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false); - } - - @Test - public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - scan_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true); - } - - private void scan_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(boolean hasProjections) - throws TransactionException { - // Arrange - Put put = - Put.newBuilder() - .namespace(namespace) - .table(TABLE) - .partitionKey(Key.ofInt(ACCOUNT_ID, 0)) - .intValue(ACCOUNT_TYPE, 0) - .intValue(BALANCE, INITIAL_BALANCE) - .build(); - DistributedTransaction transaction = managerWithIncludeMetadataEnabled.start(); - transaction.put(put); - transaction.commit(); - transaction = managerWithIncludeMetadataEnabled.start(); - Set projections = - ImmutableSet.of(ACCOUNT_ID, Attribute.BEFORE_PREFIX + BALANCE, Attribute.STATE); - - // Act Assert - BuildableScanOrScanAllFromExisting scanBuilder = - Scan.newBuilder(prepareCrossPartitionScan(0, 0, 1)); - if (hasProjections) { - scanBuilder.projections(projections); - } - List results = transaction.scan(scanBuilder.build()); - assertThat(results.size()).isOne(); - Result result = results.get(0); - transaction.commit(); - - // Assert the actual result - TableMetadata transactionTableMetadata = - ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_METADATA); - if (hasProjections) { - assertThat(result.getContainedColumnNames()).isEqualTo(projections); - } else { - assertThat(result.getContainedColumnNames().size()) - .isEqualTo(transactionTableMetadata.getColumnNames().size()); - } - for (Column column : result.getColumns().values()) { - assertThat(column.getName()).isIn(transactionTableMetadata.getColumnNames()); - assertThat(column.getDataType()) - .isEqualTo(transactionTableMetadata.getColumnDataType(column.getName())); - } - } } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitIntegrationTestBase.java index ba0df27922..49b6d86ce0 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitIntegrationTestBase.java @@ -1,52 +1,10 @@ package com.scalar.db.transaction.consensuscommit; -import static org.assertj.core.api.Assertions.assertThat; - -import com.google.common.collect.ImmutableSet; -import com.scalar.db.api.DistributedTransaction; import com.scalar.db.api.DistributedTransactionIntegrationTestBase; -import com.scalar.db.api.DistributedTransactionManager; -import com.scalar.db.api.Get; -import com.scalar.db.api.GetBuilder.BuildableGet; -import com.scalar.db.api.Put; -import com.scalar.db.api.Result; -import com.scalar.db.api.Scan; -import com.scalar.db.api.ScanBuilder.BuildableScanOrScanAllFromExisting; -import com.scalar.db.api.TableMetadata; -import com.scalar.db.config.DatabaseConfig; -import com.scalar.db.exception.transaction.TransactionException; -import com.scalar.db.io.Column; -import com.scalar.db.io.Key; -import com.scalar.db.service.TransactionFactory; -import java.util.List; -import java.util.Optional; import java.util.Properties; -import java.util.Set; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; public abstract class ConsensusCommitIntegrationTestBase extends DistributedTransactionIntegrationTestBase { - private DistributedTransactionManager managerWithIncludeMetadataEnabled; - - @BeforeAll - @Override - public void beforeAll() throws Exception { - super.beforeAll(); - - Properties includeMetadataEnabledProperties = getPropsWithIncludeMetadataEnabled(getTestName()); - managerWithIncludeMetadataEnabled = - TransactionFactory.create(includeMetadataEnabledProperties).getTransactionManager(); - } - - @AfterAll - @Override - public void afterAll() throws Exception { - super.afterAll(); - - managerWithIncludeMetadataEnabled.close(); - } @Override protected String getTestName() { @@ -57,105 +15,12 @@ protected String getTestName() { protected final Properties getProperties(String testName) { Properties properties = new Properties(); properties.putAll(getProps(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - properties.setProperty(DatabaseConfig.TRANSACTION_MANAGER, "consensus-commit"); - - // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + testName); - } - return properties; - } - protected abstract Properties getProps(String testName); + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties(testName); - properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); return properties; } - @Test - public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, false); - } - - @Test - public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, true); - } - - @Test - public void get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, false); - } - - @Test - public void get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, true); - } - - private void selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns( - boolean isScan, boolean hasProjections) throws TransactionException { - // Arrange - Put put = - Put.newBuilder() - .namespace(namespace) - .table(TABLE) - .partitionKey(Key.ofInt(ACCOUNT_ID, 0)) - .clusteringKey(Key.ofInt(ACCOUNT_TYPE, 0)) - .intValue(BALANCE, INITIAL_BALANCE) - .build(); - DistributedTransaction transaction = managerWithIncludeMetadataEnabled.start(); - transaction.put(put); - transaction.commit(); - transaction = managerWithIncludeMetadataEnabled.start(); - Set projections = - ImmutableSet.of(ACCOUNT_ID, Attribute.BEFORE_PREFIX + BALANCE, Attribute.STATE); - - // Act Assert - Result result; - if (isScan) { - // Perform a Scan - BuildableScanOrScanAllFromExisting scanBuilder = Scan.newBuilder(prepareScan(0, 0, 1)); - if (hasProjections) { - scanBuilder.projections(projections); - } - List results = transaction.scan(scanBuilder.build()); - assertThat(results.size()).isOne(); - result = results.get(0); - } else { - // Perform a Get - BuildableGet getBuilder = Get.newBuilder(prepareGet(0, 0)); - if (hasProjections) { - getBuilder.projections(projections); - } - Optional optionalResult = transaction.get(getBuilder.build()); - assertThat(optionalResult).isPresent(); - result = optionalResult.get(); - } - transaction.commit(); - - // Assert the actual result - TableMetadata transactionTableMetadata = - ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_METADATA); - if (hasProjections) { - assertThat(result.getContainedColumnNames()).isEqualTo(projections); - } else { - assertThat(result.getContainedColumnNames().size()) - .isEqualTo(transactionTableMetadata.getColumnNames().size()); - } - for (Column column : result.getColumns().values()) { - assertThat(column.getName()).isIn(transactionTableMetadata.getColumnNames()); - assertThat(column.getDataType()) - .isEqualTo(transactionTableMetadata.getColumnDataType(column.getName())); - } - } + protected abstract Properties getProps(String testName); } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitIntegrationTestUtils.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitIntegrationTestUtils.java new file mode 100644 index 0000000000..c3a08908c7 --- /dev/null +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitIntegrationTestUtils.java @@ -0,0 +1,15 @@ +package com.scalar.db.transaction.consensuscommit; + +import java.util.Properties; + +public final class ConsensusCommitIntegrationTestUtils { + + private ConsensusCommitIntegrationTestUtils() {} + + public static void addSuffixToCoordinatorNamespace(Properties properties, String suffix) { + String coordinatorNamespace = + properties.getProperty(ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); + properties.setProperty( + ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + suffix); + } +} diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitNullMetadataIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitNullMetadataIntegrationTestBase.java index 3a9510e923..4a12d17a24 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitNullMetadataIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitNullMetadataIntegrationTestBase.java @@ -81,10 +81,7 @@ public void beforeAll() throws Exception { Properties properties = getProperties(TEST_NAME); // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty(ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + TEST_NAME); + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, TEST_NAME); StorageFactory factory = StorageFactory.create(properties); admin = factory.getStorageAdmin(); diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitSpecificIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitSpecificIntegrationTestBase.java index 6fcdc7a60c..1dc27c04a3 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitSpecificIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitSpecificIntegrationTestBase.java @@ -88,10 +88,7 @@ public void beforeAll() throws Exception { Properties properties = getProperties(TEST_NAME); // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty(ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + TEST_NAME); + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, TEST_NAME); StorageFactory factory = StorageFactory.create(properties); admin = factory.getStorageAdmin(); diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase.java new file mode 100644 index 0000000000..d827d3bccb --- /dev/null +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase.java @@ -0,0 +1,227 @@ +package com.scalar.db.transaction.consensuscommit; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.google.common.collect.ImmutableSet; +import com.scalar.db.api.Consistency; +import com.scalar.db.api.DistributedTransaction; +import com.scalar.db.api.DistributedTransactionAdmin; +import com.scalar.db.api.DistributedTransactionManager; +import com.scalar.db.api.Get; +import com.scalar.db.api.GetBuilder.BuildableGet; +import com.scalar.db.api.Put; +import com.scalar.db.api.Result; +import com.scalar.db.api.Scan; +import com.scalar.db.api.ScanBuilder.BuildableScanOrScanAllFromExisting; +import com.scalar.db.api.TableMetadata; +import com.scalar.db.exception.storage.ExecutionException; +import com.scalar.db.exception.transaction.TransactionException; +import com.scalar.db.io.Column; +import com.scalar.db.io.DataType; +import com.scalar.db.io.Key; +import com.scalar.db.service.TransactionFactory; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Properties; +import java.util.Set; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +public abstract class ConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + protected static final String TEST_NAME = "cc_inc_meta"; + protected static final String NAMESPACE = "int_test_" + TEST_NAME; + protected static final String TABLE = "test_table"; + protected static final String ACCOUNT_ID = "account_id"; + protected static final String ACCOUNT_TYPE = "account_type"; + protected static final String BALANCE = "balance"; + protected static final int INITIAL_BALANCE = 1000; + protected static final TableMetadata TABLE_METADATA = + TableMetadata.newBuilder() + .addColumn(ACCOUNT_ID, DataType.INT) + .addColumn(ACCOUNT_TYPE, DataType.INT) + .addColumn(BALANCE, DataType.INT) + .addPartitionKey(ACCOUNT_ID) + .addClusteringKey(ACCOUNT_TYPE) + .build(); + protected DistributedTransactionAdmin admin; + protected DistributedTransactionManager manager; + protected String namespace; + + @BeforeAll + public void beforeAll() throws Exception { + initialize(TEST_NAME); + Properties properties = getProperties(TEST_NAME); + + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, TEST_NAME); + + // Enable to include metadata + properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); + + TransactionFactory factory = TransactionFactory.create(properties); + admin = factory.getTransactionAdmin(); + namespace = getNamespace(); + createTables(); + manager = factory.getTransactionManager(); + } + + protected void initialize(String testName) throws Exception {} + + protected abstract Properties getProperties(String testName); + + protected String getNamespace() { + return NAMESPACE; + } + + private void createTables() throws ExecutionException { + Map options = getCreationOptions(); + admin.createNamespace(namespace, true, options); + admin.createTable(namespace, TABLE, TABLE_METADATA, true, options); + admin.createCoordinatorTables(true, options); + } + + protected Map getCreationOptions() { + return Collections.emptyMap(); + } + + @BeforeEach + public void setUp() throws Exception { + admin.truncateTable(namespace, TABLE); + admin.truncateCoordinatorTables(); + } + + @AfterAll + public void afterAll() throws Exception { + dropTables(); + admin.close(); + manager.close(); + } + + private void dropTables() throws ExecutionException { + admin.dropTable(namespace, TABLE); + admin.dropNamespace(namespace); + admin.dropCoordinatorTables(); + } + + @Test + public void + getTableMetadata_WhenIncludeMetadataIsEnabled_ShouldReturnCorrectMetadataWithTransactionMetadataColumns() + throws ExecutionException { + // Arrange + TableMetadata transactionTableMetadata = + ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_METADATA); + + // Act + TableMetadata tableMetadata = admin.getTableMetadata(namespace, TABLE); + + // Assert + assertThat(tableMetadata).isEqualTo(transactionTableMetadata); + } + + @Test + public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, false); + } + + @Test + public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, true); + } + + @Test + public void get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, false); + } + + @Test + public void get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, true); + } + + private void selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns( + boolean isScan, boolean hasProjections) throws TransactionException { + // Arrange + Put put = + Put.newBuilder() + .namespace(namespace) + .table(TABLE) + .partitionKey(Key.ofInt(ACCOUNT_ID, 0)) + .clusteringKey(Key.ofInt(ACCOUNT_TYPE, 0)) + .intValue(BALANCE, INITIAL_BALANCE) + .build(); + DistributedTransaction transaction = manager.start(); + transaction.put(put); + transaction.commit(); + transaction = manager.start(); + Set projections = + ImmutableSet.of(ACCOUNT_ID, Attribute.BEFORE_PREFIX + BALANCE, Attribute.STATE); + + // Act Assert + Result result; + if (isScan) { + // Perform a Scan + BuildableScanOrScanAllFromExisting scanBuilder = Scan.newBuilder(prepareScan(0, 0, 1)); + if (hasProjections) { + scanBuilder.projections(projections); + } + List results = transaction.scan(scanBuilder.build()); + assertThat(results.size()).isOne(); + result = results.get(0); + } else { + // Perform a Get + BuildableGet getBuilder = Get.newBuilder(prepareGet(0, 0)); + if (hasProjections) { + getBuilder.projections(projections); + } + Optional optionalResult = transaction.get(getBuilder.build()); + assertThat(optionalResult).isPresent(); + result = optionalResult.get(); + } + transaction.commit(); + + // Assert the actual result + TableMetadata transactionTableMetadata = + ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_METADATA); + if (hasProjections) { + assertThat(result.getContainedColumnNames()).isEqualTo(projections); + } else { + assertThat(result.getContainedColumnNames().size()) + .isEqualTo(transactionTableMetadata.getColumnNames().size()); + } + for (Column column : result.getColumns().values()) { + assertThat(column.getName()).isIn(transactionTableMetadata.getColumnNames()); + assertThat(column.getDataType()) + .isEqualTo(transactionTableMetadata.getColumnDataType(column.getName())); + } + } + + protected Get prepareGet(int id, int type) { + Key partitionKey = new Key(ACCOUNT_ID, id); + Key clusteringKey = new Key(ACCOUNT_TYPE, type); + return new Get(partitionKey, clusteringKey) + .forNamespace(namespace) + .forTable(TABLE) + .withConsistency(Consistency.LINEARIZABLE); + } + + protected Scan prepareScan(int id, int fromType, int toType) { + Key partitionKey = new Key(ACCOUNT_ID, id); + return new Scan(partitionKey) + .forNamespace(namespace) + .forTable(TABLE) + .withConsistency(Consistency.LINEARIZABLE) + .withStart(new Key(ACCOUNT_TYPE, fromType)) + .withEnd(new Key(ACCOUNT_TYPE, toType)); + } +} diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitCrossPartitionScanIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitCrossPartitionScanIntegrationTestBase.java index af46e59408..fddee5dc53 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitCrossPartitionScanIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitCrossPartitionScanIntegrationTestBase.java @@ -4,64 +4,32 @@ import static org.assertj.core.api.Assertions.catchThrowable; import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; -import com.google.common.collect.ImmutableSet; import com.scalar.db.api.ConditionBuilder; import com.scalar.db.api.Consistency; import com.scalar.db.api.Put; -import com.scalar.db.api.Result; import com.scalar.db.api.Scan; -import com.scalar.db.api.ScanBuilder.BuildableScanOrScanAllFromExisting; -import com.scalar.db.api.TableMetadata; import com.scalar.db.api.TwoPhaseCommitTransaction; import com.scalar.db.api.TwoPhaseCommitTransactionCrossPartitionScanIntegrationTestBase; -import com.scalar.db.api.TwoPhaseCommitTransactionManager; -import com.scalar.db.config.DatabaseConfig; import com.scalar.db.exception.transaction.TransactionException; -import com.scalar.db.io.Column; -import com.scalar.db.io.Key; -import com.scalar.db.service.TransactionFactory; -import java.util.List; import java.util.Properties; -import java.util.Set; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; public abstract class TwoPhaseConsensusCommitCrossPartitionScanIntegrationTestBase extends TwoPhaseCommitTransactionCrossPartitionScanIntegrationTestBase { - private TwoPhaseCommitTransactionManager managerWithWithIncludeMetadataEnabled; - - @BeforeAll - @Override - public void beforeAll() throws Exception { - super.beforeAll(); - - Properties includeMetadataEnabledProperties = getPropsWithIncludeMetadataEnabled(getTestName()); - managerWithWithIncludeMetadataEnabled = - TransactionFactory.create(includeMetadataEnabledProperties) - .getTwoPhaseCommitTransactionManager(); - } - - @AfterAll - @Override - public void afterAll() throws Exception { - super.afterAll(); - - managerWithWithIncludeMetadataEnabled.close(); - } @Override protected String getTestName() { - return "2pc_cc"; + return "tx_2pcc"; } @Override protected final Properties getProperties1(String testName) { Properties properties = new Properties(); properties.putAll(getProps1(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - modifyProperties(properties, testName); - } + + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); + return properties; } @@ -69,20 +37,11 @@ protected final Properties getProperties1(String testName) { protected final Properties getProperties2(String testName) { Properties properties = new Properties(); properties.putAll(getProps2(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - modifyProperties(properties, testName); - } - return properties; - } - - private void modifyProperties(Properties properties, String testName) { - properties.setProperty(DatabaseConfig.TRANSACTION_MANAGER, "consensus-commit"); // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty(ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + testName); + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); + + return properties; } protected abstract Properties getProps1(String testName); @@ -91,12 +50,6 @@ protected Properties getProps2(String testName) { return getProps1(testName); } - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties1(testName); - properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); - return properties; - } - @Test public void scan_PutAndOverlappedCrossPartitionScanGiven_ShouldThrowException() throws TransactionException { @@ -232,65 +185,4 @@ public void scan_PutResultOverlappedWithCrossPartitionScanWithLikeGiven_ShouldTh // Assert assertThat(thrown).isInstanceOf(IllegalArgumentException.class); } - - @Test - public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - scan_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false); - } - - @Test - public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - scan_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true); - } - - private void scan_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(boolean hasProjections) - throws TransactionException { - // Arrange - Put put = - Put.newBuilder() - .namespace(namespace1) - .table(TABLE_1) - .partitionKey(Key.ofInt(ACCOUNT_ID, 0)) - .intValue(ACCOUNT_TYPE, 0) - .intValue(BALANCE, INITIAL_BALANCE) - .build(); - TwoPhaseCommitTransaction transaction = managerWithWithIncludeMetadataEnabled.start(); - transaction.put(put); - transaction.prepare(); - transaction.validate(); - transaction.commit(); - transaction = managerWithWithIncludeMetadataEnabled.start(); - Set projections = - ImmutableSet.of(ACCOUNT_ID, Attribute.BEFORE_PREFIX + BALANCE, Attribute.STATE); - - // Act Assert - BuildableScanOrScanAllFromExisting scanBuilder = - Scan.newBuilder(prepareCrossPartitionScan(namespace1, TABLE_1, 0, 0, 1)); - if (hasProjections) { - scanBuilder.projections(projections); - } - List results = transaction.scan(scanBuilder.build()); - assertThat(results.size()).isOne(); - Result result = results.get(0); - transaction.prepare(); - transaction.validate(); - transaction.commit(); - - // Assert the actual result - TableMetadata transactionTableMetadata = - ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_1_METADATA); - if (hasProjections) { - assertThat(result.getContainedColumnNames()).isEqualTo(projections); - } else { - assertThat(result.getContainedColumnNames().size()) - .isEqualTo(transactionTableMetadata.getColumnNames().size()); - } - for (Column column : result.getColumns().values()) { - assertThat(column.getName()).isIn(transactionTableMetadata.getColumnNames()); - assertThat(column.getDataType()) - .isEqualTo(transactionTableMetadata.getColumnDataType(column.getName())); - } - } } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitIntegrationTestBase.java index 2f9f9ef9ed..781087ed79 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitIntegrationTestBase.java @@ -1,66 +1,24 @@ package com.scalar.db.transaction.consensuscommit; -import static org.assertj.core.api.Assertions.assertThat; - -import com.google.common.collect.ImmutableSet; -import com.scalar.db.api.Get; -import com.scalar.db.api.GetBuilder.BuildableGet; -import com.scalar.db.api.Put; -import com.scalar.db.api.Result; -import com.scalar.db.api.Scan; -import com.scalar.db.api.ScanBuilder.BuildableScanOrScanAllFromExisting; -import com.scalar.db.api.TableMetadata; -import com.scalar.db.api.TwoPhaseCommitTransaction; import com.scalar.db.api.TwoPhaseCommitTransactionIntegrationTestBase; -import com.scalar.db.api.TwoPhaseCommitTransactionManager; -import com.scalar.db.config.DatabaseConfig; -import com.scalar.db.exception.transaction.TransactionException; -import com.scalar.db.io.Column; -import com.scalar.db.io.Key; -import com.scalar.db.service.TransactionFactory; -import java.util.List; -import java.util.Optional; import java.util.Properties; -import java.util.Set; -import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; public abstract class TwoPhaseConsensusCommitIntegrationTestBase extends TwoPhaseCommitTransactionIntegrationTestBase { - private TwoPhaseCommitTransactionManager managerWithWithIncludeMetadataEnabled; - - @BeforeAll - @Override - public void beforeAll() throws Exception { - super.beforeAll(); - - Properties includeMetadataEnabledProperties = getPropsWithIncludeMetadataEnabled(getTestName()); - managerWithWithIncludeMetadataEnabled = - TransactionFactory.create(includeMetadataEnabledProperties) - .getTwoPhaseCommitTransactionManager(); - } - - @AfterAll - @Override - public void afterAll() throws Exception { - super.afterAll(); - - managerWithWithIncludeMetadataEnabled.close(); - } @Override protected String getTestName() { - return "2pc_cc"; + return "tx_2pcc"; } @Override protected final Properties getProperties1(String testName) { Properties properties = new Properties(); properties.putAll(getProps1(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - modifyProperties(properties, testName); - } + + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); + return properties; } @@ -68,20 +26,11 @@ protected final Properties getProperties1(String testName) { protected final Properties getProperties2(String testName) { Properties properties = new Properties(); properties.putAll(getProps2(testName)); - if (!properties.containsKey(DatabaseConfig.TRANSACTION_MANAGER)) { - modifyProperties(properties, testName); - } - return properties; - } - - private void modifyProperties(Properties properties, String testName) { - properties.setProperty(DatabaseConfig.TRANSACTION_MANAGER, "consensus-commit"); // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty(ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + testName); + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, testName); + + return properties; } protected abstract Properties getProps1(String testName); @@ -89,96 +38,4 @@ private void modifyProperties(Properties properties, String testName) { protected Properties getProps2(String testName) { return getProps1(testName); } - - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties1(testName); - properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); - return properties; - } - - @Test - public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, false); - } - - @Test - public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, true); - } - - @Test - public void get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, false); - } - - @Test - public void get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, true); - } - - private void selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns( - boolean isScan, boolean hasProjections) throws TransactionException { - // Arrange - Put put = - Put.newBuilder() - .namespace(namespace1) - .table(TABLE_1) - .partitionKey(Key.ofInt(ACCOUNT_ID, 0)) - .clusteringKey(Key.ofInt(ACCOUNT_TYPE, 0)) - .intValue(BALANCE, INITIAL_BALANCE) - .build(); - TwoPhaseCommitTransaction transaction = managerWithWithIncludeMetadataEnabled.start(); - transaction.put(put); - transaction.prepare(); - transaction.validate(); - transaction.commit(); - transaction = managerWithWithIncludeMetadataEnabled.start(); - Set projections = - ImmutableSet.of(ACCOUNT_ID, Attribute.BEFORE_PREFIX + BALANCE, Attribute.STATE); - - // Act Assert - Result result; - if (isScan) { - // Perform a Scan - BuildableScanOrScanAllFromExisting scanBuilder = - Scan.newBuilder(prepareScan(0, 0, 1, namespace1, TABLE_1)); - if (hasProjections) { - scanBuilder.projections(projections); - } - List results = transaction.scan(scanBuilder.build()); - assertThat(results.size()).isOne(); - result = results.get(0); - } else { - // Perform a Get - BuildableGet getBuilder = Get.newBuilder(prepareGet(0, 0, namespace1, TABLE_1)); - if (hasProjections) { - getBuilder.projections(projections); - } - Optional optionalResult = transaction.get(getBuilder.build()); - assertThat(optionalResult).isPresent(); - result = optionalResult.get(); - } - transaction.prepare(); - transaction.validate(); - transaction.commit(); - - // Assert the actual result - TableMetadata transactionTableMetadata = - ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_METADATA); - if (hasProjections) { - assertThat(result.getContainedColumnNames()).isEqualTo(projections); - } else { - assertThat(result.getContainedColumnNames().size()) - .isEqualTo(transactionTableMetadata.getColumnNames().size()); - } - for (Column column : result.getColumns().values()) { - assertThat(column.getName()).isIn(transactionTableMetadata.getColumnNames()); - assertThat(column.getDataType()) - .isEqualTo(transactionTableMetadata.getColumnDataType(column.getName())); - } - } } diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitSpecificIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitSpecificIntegrationTestBase.java index c5c0e39932..da4b8f2135 100644 --- a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitSpecificIntegrationTestBase.java +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitSpecificIntegrationTestBase.java @@ -72,8 +72,13 @@ public abstract class TwoPhaseConsensusCommitSpecificIntegrationTestBase { @BeforeAll public void beforeAll() throws Exception { initialize(); - Properties properties1 = modifyProperties(getProperties1(TEST_NAME)); - Properties properties2 = modifyProperties(getProperties2(TEST_NAME)); + Properties properties1 = getProperties1(TEST_NAME); + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties1, TEST_NAME); + + Properties properties2 = getProperties2(TEST_NAME); + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties2, TEST_NAME); namespace1 = getNamespace1(); namespace2 = getNamespace2(); @@ -95,16 +100,6 @@ public void beforeAll() throws Exception { coordinatorForStorage1 = new Coordinator(storage1, consensusCommitConfig1); } - private Properties modifyProperties(Properties properties) { - // Add testName as a coordinator namespace suffix - String coordinatorNamespace = - properties.getProperty(ConsensusCommitConfig.COORDINATOR_NAMESPACE, Coordinator.NAMESPACE); - properties.setProperty( - ConsensusCommitConfig.COORDINATOR_NAMESPACE, coordinatorNamespace + "_" + TEST_NAME); - - return properties; - } - protected void initialize() throws Exception {} protected abstract Properties getProperties1(String testName); diff --git a/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase.java b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase.java new file mode 100644 index 0000000000..b1a89e0d59 --- /dev/null +++ b/integration-test/src/main/java/com/scalar/db/transaction/consensuscommit/TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase.java @@ -0,0 +1,217 @@ +package com.scalar.db.transaction.consensuscommit; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.google.common.collect.ImmutableSet; +import com.scalar.db.api.Consistency; +import com.scalar.db.api.DistributedTransactionAdmin; +import com.scalar.db.api.Get; +import com.scalar.db.api.GetBuilder; +import com.scalar.db.api.Put; +import com.scalar.db.api.Result; +import com.scalar.db.api.Scan; +import com.scalar.db.api.ScanBuilder; +import com.scalar.db.api.TableMetadata; +import com.scalar.db.api.TwoPhaseCommitTransaction; +import com.scalar.db.api.TwoPhaseCommitTransactionManager; +import com.scalar.db.exception.storage.ExecutionException; +import com.scalar.db.exception.transaction.TransactionException; +import com.scalar.db.io.Column; +import com.scalar.db.io.DataType; +import com.scalar.db.io.Key; +import com.scalar.db.service.TransactionFactory; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Properties; +import java.util.Set; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +public abstract class TwoPhaseConsensusCommitWithIncludeMetadataEnabledIntegrationTestBase { + + protected static final String TEST_NAME = "2pcc_inc_meta"; + protected static final String NAMESPACE = "int_test_" + TEST_NAME; + protected static final String TABLE = "test_table"; + protected static final String ACCOUNT_ID = "account_id"; + protected static final String ACCOUNT_TYPE = "account_type"; + protected static final String BALANCE = "balance"; + protected static final int INITIAL_BALANCE = 1000; + protected static final TableMetadata TABLE_METADATA = + TableMetadata.newBuilder() + .addColumn(ACCOUNT_ID, DataType.INT) + .addColumn(ACCOUNT_TYPE, DataType.INT) + .addColumn(BALANCE, DataType.INT) + .addPartitionKey(ACCOUNT_ID) + .addClusteringKey(ACCOUNT_TYPE) + .build(); + protected DistributedTransactionAdmin admin; + protected TwoPhaseCommitTransactionManager manager; + protected String namespace; + + @BeforeAll + public void beforeAll() throws Exception { + initialize(TEST_NAME); + Properties properties = getProperties(TEST_NAME); + + // Add testName as a coordinator namespace suffix + ConsensusCommitIntegrationTestUtils.addSuffixToCoordinatorNamespace(properties, TEST_NAME); + + // Enable to include metadata + properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); + + TransactionFactory factory = TransactionFactory.create(properties); + admin = factory.getTransactionAdmin(); + namespace = getNamespace(); + createTables(); + manager = factory.getTwoPhaseCommitTransactionManager(); + } + + protected void initialize(String testName) throws Exception {} + + protected abstract Properties getProperties(String testName); + + protected String getNamespace() { + return NAMESPACE; + } + + private void createTables() throws ExecutionException { + Map options = getCreationOptions(); + admin.createNamespace(namespace, true, options); + admin.createTable(namespace, TABLE, TABLE_METADATA, true, options); + admin.createCoordinatorTables(true, options); + } + + protected Map getCreationOptions() { + return Collections.emptyMap(); + } + + @BeforeEach + public void setUp() throws Exception { + admin.truncateTable(namespace, TABLE); + admin.truncateCoordinatorTables(); + } + + @AfterAll + public void afterAll() throws Exception { + dropTables(); + admin.close(); + manager.close(); + } + + private void dropTables() throws ExecutionException { + admin.dropTable(namespace, TABLE); + admin.dropNamespace(namespace); + admin.dropCoordinatorTables(); + } + + @Test + public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, false); + } + + @Test + public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(true, true); + } + + @Test + public void get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, false); + } + + @Test + public void get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() + throws TransactionException { + selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns(false, true); + } + + private void selection_WithIncludeMetadataEnabled_ShouldReturnCorrectColumns( + boolean isScan, boolean hasProjections) throws TransactionException { + // Arrange + Put put = + Put.newBuilder() + .namespace(namespace) + .table(TABLE) + .partitionKey(Key.ofInt(ACCOUNT_ID, 0)) + .clusteringKey(Key.ofInt(ACCOUNT_TYPE, 0)) + .intValue(BALANCE, INITIAL_BALANCE) + .build(); + TwoPhaseCommitTransaction transaction = manager.start(); + transaction.put(put); + transaction.prepare(); + transaction.validate(); + transaction.commit(); + transaction = manager.start(); + Set projections = + ImmutableSet.of(ACCOUNT_ID, Attribute.BEFORE_PREFIX + BALANCE, Attribute.STATE); + + // Act Assert + Result result; + if (isScan) { + // Perform a Scan + ScanBuilder.BuildableScanOrScanAllFromExisting scanBuilder = + Scan.newBuilder(prepareScan(0, 0, 1)); + if (hasProjections) { + scanBuilder.projections(projections); + } + List results = transaction.scan(scanBuilder.build()); + assertThat(results.size()).isOne(); + result = results.get(0); + } else { + // Perform a Get + GetBuilder.BuildableGet getBuilder = Get.newBuilder(prepareGet(0, 0)); + if (hasProjections) { + getBuilder.projections(projections); + } + Optional optionalResult = transaction.get(getBuilder.build()); + assertThat(optionalResult).isPresent(); + result = optionalResult.get(); + } + transaction.prepare(); + transaction.validate(); + transaction.commit(); + + // Assert the actual result + TableMetadata transactionTableMetadata = + ConsensusCommitUtils.buildTransactionTableMetadata(TABLE_METADATA); + if (hasProjections) { + assertThat(result.getContainedColumnNames()).isEqualTo(projections); + } else { + assertThat(result.getContainedColumnNames().size()) + .isEqualTo(transactionTableMetadata.getColumnNames().size()); + } + for (Column column : result.getColumns().values()) { + assertThat(column.getName()).isIn(transactionTableMetadata.getColumnNames()); + assertThat(column.getDataType()) + .isEqualTo(transactionTableMetadata.getColumnDataType(column.getName())); + } + } + + protected Get prepareGet(int id, int type) { + Key partitionKey = new Key(ACCOUNT_ID, id); + Key clusteringKey = new Key(ACCOUNT_TYPE, type); + return new Get(partitionKey, clusteringKey) + .forNamespace(namespace) + .forTable(TABLE) + .withConsistency(Consistency.LINEARIZABLE); + } + + protected Scan prepareScan(int id, int fromType, int toType) { + Key partitionKey = new Key(ACCOUNT_ID, id); + return new Scan(partitionKey) + .forNamespace(namespace) + .forTable(TABLE) + .withConsistency(Consistency.LINEARIZABLE) + .withStart(new Key(ACCOUNT_TYPE, fromType)) + .withEnd(new Key(ACCOUNT_TYPE, toType)); + } +} diff --git a/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitAdminIntegrationTestWithServer.java b/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitAdminIntegrationTestWithServer.java index aa84167f08..df2ef3f704 100644 --- a/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitAdminIntegrationTestWithServer.java +++ b/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitAdminIntegrationTestWithServer.java @@ -1,7 +1,5 @@ package com.scalar.db.server; -import com.scalar.db.config.DatabaseConfig; -import com.scalar.db.exception.storage.ExecutionException; import com.scalar.db.transaction.consensuscommit.ConsensusCommitAdminIntegrationTestBase; import com.scalar.db.transaction.consensuscommit.ConsensusCommitConfig; import com.scalar.db.transaction.consensuscommit.Coordinator; @@ -10,16 +8,11 @@ import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.DisabledIf; public class ConsensusCommitAdminIntegrationTestWithServer extends ConsensusCommitAdminIntegrationTestBase { - private static final String PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED = "60053"; - private ScalarDbServer server; - private ScalarDbServer serverWithIncludeMetadataEnabled; - private boolean isExternalServerUsed; @Override protected void initialize(String testName) throws Exception { @@ -36,13 +29,6 @@ protected void initialize(String testName) throws Exception { server = new ScalarDbServer(properties); server.start(); - - properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); - properties.setProperty(ServerConfig.PORT, PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED); - serverWithIncludeMetadataEnabled = new ScalarDbServer(properties); - serverWithIncludeMetadataEnabled.start(); - } else { - isExternalServerUsed = true; } } @@ -51,14 +37,6 @@ protected Properties getProps(String testName) { return ServerEnv.getClient1Properties(testName); } - @Override - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties(testName); - properties.setProperty( - DatabaseConfig.CONTACT_PORT, PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED); - return properties; - } - @AfterAll @Override public void afterAll() throws Exception { @@ -66,20 +44,11 @@ public void afterAll() throws Exception { if (server != null) { server.shutdown(); } - if (serverWithIncludeMetadataEnabled != null) { - serverWithIncludeMetadataEnabled.shutdown(); - } } - /** This test is disabled if {@link #isExternalServerUsed()} return true */ @Override - @Test - @DisabledIf("isExternalServerUsed") - public void - getTableMetadata_WhenIncludeMetadataIsEnabled_ShouldReturnCorrectMetadataWithTransactionMetadataColumns() - throws ExecutionException { - super - .getTableMetadata_WhenIncludeMetadataIsEnabled_ShouldReturnCorrectMetadataWithTransactionMetadataColumns(); + protected AdminTestUtils getAdminTestUtils(String testName) { + throw new UnsupportedOperationException(); } @Override @@ -92,16 +61,4 @@ public void getNamespaceNames_ShouldReturnCreatedNamespaces() {} @Override public void upgrade_WhenMetadataTableExistsButNotNamespacesTable_ShouldCreateNamespacesTableAndImportExistingNamespaces() {} - - @Override - protected AdminTestUtils getAdminTestUtils(String testName) { - throw new UnsupportedOperationException(); - } - - @SuppressWarnings("unused") - private boolean isExternalServerUsed() { - // An external server is used, so we don't have access to the configuration to connect to the - // underlying storage which makes it impossible to run these tests - return isExternalServerUsed; - } } diff --git a/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitIntegrationTestWithServer.java b/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitIntegrationTestWithServer.java index ca1f53433f..eb75888087 100644 --- a/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitIntegrationTestWithServer.java +++ b/server/src/integration-test/java/com/scalar/db/server/ConsensusCommitIntegrationTestWithServer.java @@ -1,23 +1,15 @@ package com.scalar.db.server; -import com.scalar.db.config.DatabaseConfig; -import com.scalar.db.exception.transaction.TransactionException; import com.scalar.db.transaction.consensuscommit.ConsensusCommitConfig; import com.scalar.db.transaction.consensuscommit.ConsensusCommitIntegrationTestBase; import com.scalar.db.transaction.consensuscommit.Coordinator; import java.io.IOException; import java.util.Properties; import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.DisabledIf; public class ConsensusCommitIntegrationTestWithServer extends ConsensusCommitIntegrationTestBase { - private static final String PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED = "60053"; - private ScalarDbServer server; - private ScalarDbServer serverWithIncludeMetadataEnabled; - private boolean isExternalServerUsed; @Override protected void initialize(String testName) throws IOException { @@ -32,13 +24,6 @@ protected void initialize(String testName) throws IOException { server = new ScalarDbServer(properties); server.start(); - - properties.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); - properties.setProperty(ServerConfig.PORT, PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED); - serverWithIncludeMetadataEnabled = new ScalarDbServer(properties); - serverWithIncludeMetadataEnabled.start(); - } else { - isExternalServerUsed = true; } } @@ -47,14 +32,6 @@ protected Properties getProps(String testName) { return ServerEnv.getClient1Properties(testName); } - @Override - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties(testName); - properties.setProperty( - DatabaseConfig.CONTACT_PORT, PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED); - return properties; - } - @AfterAll @Override public void afterAll() throws Exception { @@ -62,51 +39,5 @@ public void afterAll() throws Exception { if (server != null) { server.shutdown(); } - if (serverWithIncludeMetadataEnabled != null) { - serverWithIncludeMetadataEnabled.shutdown(); - } - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - super.scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns(); - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - super.scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns(); - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - super.get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns(); - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - super.get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns(); - } - - @SuppressWarnings("unused") - private boolean isExternalServerUsed() { - // An external server is used, so we don't have access to the configuration to connect to the - // underlying storage which makes it impossible to run these tests - return isExternalServerUsed; } } diff --git a/server/src/integration-test/java/com/scalar/db/server/TwoPhaseConsensusCommitIntegrationTestWithServer.java b/server/src/integration-test/java/com/scalar/db/server/TwoPhaseConsensusCommitIntegrationTestWithServer.java index 0b71618c95..7830a55b3c 100644 --- a/server/src/integration-test/java/com/scalar/db/server/TwoPhaseConsensusCommitIntegrationTestWithServer.java +++ b/server/src/integration-test/java/com/scalar/db/server/TwoPhaseConsensusCommitIntegrationTestWithServer.java @@ -1,25 +1,17 @@ package com.scalar.db.server; -import com.scalar.db.config.DatabaseConfig; -import com.scalar.db.exception.transaction.TransactionException; import com.scalar.db.transaction.consensuscommit.ConsensusCommitConfig; import com.scalar.db.transaction.consensuscommit.Coordinator; import com.scalar.db.transaction.consensuscommit.TwoPhaseConsensusCommitIntegrationTestBase; import java.io.IOException; import java.util.Properties; import org.junit.jupiter.api.AfterAll; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.DisabledIf; public class TwoPhaseConsensusCommitIntegrationTestWithServer extends TwoPhaseConsensusCommitIntegrationTestBase { - private static final String PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED = "60053"; - private ScalarDbServer server1; private ScalarDbServer server2; - private ScalarDbServer serverWithIncludeMetadataEnabled; - private boolean isExternalServerUsed; @Override protected void initialize(String testName) throws IOException { @@ -31,13 +23,6 @@ protected void initialize(String testName) throws IOException { server2 = new ScalarDbServer(modifyProperties(properties2, testName)); server2.start(); - - properties1.setProperty(ConsensusCommitConfig.INCLUDE_METADATA_ENABLED, "true"); - properties1.setProperty(ServerConfig.PORT, PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED); - serverWithIncludeMetadataEnabled = new ScalarDbServer(properties1); - serverWithIncludeMetadataEnabled.start(); - } else { - isExternalServerUsed = true; } } @@ -61,14 +46,6 @@ protected Properties getProps2(String testName) { return ServerEnv.getClient2Properties(testName); } - @Override - protected Properties getPropsWithIncludeMetadataEnabled(String testName) { - Properties properties = getProperties1(testName); - properties.setProperty( - DatabaseConfig.CONTACT_PORT, PORT_FOR_SERVER_WITH_INCLUDE_METADATA_ENABLED); - return properties; - } - @AfterAll @Override public void afterAll() throws Exception { @@ -79,51 +56,5 @@ public void afterAll() throws Exception { if (server2 != null) { server2.shutdown(); } - if (serverWithIncludeMetadataEnabled != null) { - serverWithIncludeMetadataEnabled.shutdown(); - } - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - super.scan_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns(); - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - super.scan_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns(); - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns() - throws TransactionException { - super.get_WithIncludeMetadataEnabled_ShouldReturnTransactionMetadataColumns(); - } - - /** This test is disabled if {@link #isExternalServerUsed()} return true */ - @Override - @Test - @DisabledIf("isExternalServerUsed") - public void get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns() - throws TransactionException { - super.get_WithIncludeMetadataEnabledAndProjections_ShouldReturnProjectedColumns(); - } - - @SuppressWarnings("unused") - private boolean isExternalServerUsed() { - // An external server is used, so we don't have access to the configuration to connect to the - // underlying storage which makes it impossible to run these tests - return isExternalServerUsed; } }