You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by am...@apache.org on 2024/02/15 16:27:43 UTC
(ignite-3) 02/03: Add tests
This is an automated email from the ASF dual-hosted git repository.
amashenkov pushed a commit to branch ignite-21535
in repository https://gitbox.apache.org/repos/asf/ignite-3.git
commit 1a4ad96cef2b8d89a509d208e3dbc623a902b309
Author: amashenkov <an...@gmail.com>
AuthorDate: Thu Feb 15 19:05:03 2024 +0300
Add tests
---
.../catalog/CatalogManagerRecoveryTest.java | 73 +++++++++----
.../internal/catalog/CatalogManagerSelfTest.java | 115 +++++++++++++++++++--
.../internal/catalog/BaseCatalogManagerTest.java | 15 +++
.../ignite/internal/catalog/CatalogTestUtils.java | 91 +++++++++++++++-
.../table/distributed/TableManagerTest.java | 33 ++++++
5 files changed, 293 insertions(+), 34 deletions(-)
diff --git a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerRecoveryTest.java b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerRecoveryTest.java
index e1a53b1f27..953ec87c07 100644
--- a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerRecoveryTest.java
+++ b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerRecoveryTest.java
@@ -22,18 +22,32 @@ import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.INDEX_NA
import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.INDEX_NAME_2;
import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.TABLE_NAME;
import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.TABLE_NAME_2;
+import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.TABLE_NAME_3;
+import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.dropIndexCommand;
+import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.dropTableCommand;
import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.simpleIndex;
import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.simpleTable;
import static org.apache.ignite.internal.catalog.BaseCatalogManagerTest.startBuildingIndexCommand;
+import static org.apache.ignite.internal.testframework.matchers.CompletableFutureMatcher.willBe;
import static org.apache.ignite.internal.testframework.matchers.CompletableFutureMatcher.willCompleteSuccessfully;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
import java.nio.file.Path;
import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.catalog.CatalogTestUtils.TestUpdateHandlerInterceptor;
+import org.apache.ignite.internal.catalog.storage.SnapshotEntry;
+import org.apache.ignite.internal.catalog.storage.VersionedUpdate;
import org.apache.ignite.internal.hlc.HybridClock;
import org.apache.ignite.internal.hlc.HybridClockImpl;
import org.apache.ignite.internal.hlc.HybridTimestamp;
@@ -42,13 +56,13 @@ import org.apache.ignite.internal.metastorage.impl.StandaloneMetaStorageManager;
import org.apache.ignite.internal.metastorage.server.KeyValueStorage;
import org.apache.ignite.internal.metastorage.server.TestRocksDbKeyValueStorage;
import org.apache.ignite.internal.testframework.BaseIgniteAbstractTest;
-import org.apache.ignite.internal.testframework.IgniteTestUtils;
import org.apache.ignite.internal.testframework.WorkDirectory;
import org.apache.ignite.internal.testframework.WorkDirectoryExtension;
import org.apache.ignite.internal.util.IgniteUtils;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mockito;
/** For {@link CatalogManager} testing on recovery. */
@ExtendWith(WorkDirectoryExtension.class)
@@ -64,6 +78,8 @@ public class CatalogManagerRecoveryTest extends BaseIgniteAbstractTest {
private CatalogManager catalogManager;
+ private TestUpdateHandlerInterceptor interceptor;
+
@AfterEach
void tearDown() throws Exception {
IgniteUtils.stopAll(catalogManager, metaStorageManager);
@@ -100,6 +116,10 @@ public class CatalogManagerRecoveryTest extends BaseIgniteAbstractTest {
createAndStartComponents();
+ // Check recovery events.
+ verify(interceptor, times(2)).handle(any(VersionedUpdate.class), any(), anyLong());
+ verify(interceptor, Mockito.never()).handle(any(SnapshotEntry.class), any(), anyLong());
+
// Let's check that the versions for the points in time at which they were created are in place.
assertThat(catalogManager.activeCatalogVersion(time0), equalTo(catalogVersion0));
assertThat(catalogManager.activeCatalogVersion(time1), equalTo(catalogVersion1));
@@ -111,40 +131,47 @@ public class CatalogManagerRecoveryTest extends BaseIgniteAbstractTest {
// Let's create a couple of versions of the catalog.
assertThat(catalogManager.execute(simpleTable(TABLE_NAME)), willCompleteSuccessfully());
+ assertThat(catalogManager.execute(simpleIndex(TABLE_NAME, INDEX_NAME)), willCompleteSuccessfully());
assertThat(catalogManager.execute(simpleTable(TABLE_NAME_2)), willCompleteSuccessfully());
+ assertThat(catalogManager.execute(simpleIndex(TABLE_NAME, INDEX_NAME_2)), willCompleteSuccessfully());
+ assertThat(catalogManager.execute(dropTableCommand(TABLE_NAME_2)), willCompleteSuccessfully());
+ assertThat(catalogManager.execute(dropIndexCommand(INDEX_NAME_2)), willCompleteSuccessfully());
- int catalogVersion0 = catalogManager.latestCatalogVersion();
- long time0 = catalogManager.catalog(catalogVersion0).time();
+ // Save version, which will be earliest version after snapshot.
+ int earliestVersion = catalogManager.latestCatalogVersion();
+ long earliestVersionActivationTime = catalogManager.catalog(earliestVersion).time();
+ long snapshotTime = clock.nowLong();
- assertThat(catalogVersion0, greaterThan(catalogManager.earliestCatalogVersion()));
+ assertThat(catalogManager.execute(simpleTable(TABLE_NAME_3)), willCompleteSuccessfully());
- assertThat(catalogManager.execute(simpleIndex(TABLE_NAME, INDEX_NAME)), willCompleteSuccessfully());
- assertThat(catalogManager.execute(simpleIndex(TABLE_NAME_2, INDEX_NAME_2)), willCompleteSuccessfully());
+ int latestVersion = catalogManager.latestCatalogVersion();
+ long latestVersionActivationTime = catalogManager.catalog(latestVersion).time();
- int catalogVersion1 = catalogManager.latestCatalogVersion();
- long time1 = catalogManager.catalog(catalogVersion1).time();
+ // Compact catalog with ignoring snapshot event, then ensure earliest version wasn't changed
+ clearInvocations(interceptor);
+ interceptor.dropSnapshotEvents();
- // Compact catalog.
- assertThat(((CatalogManagerImpl) catalogManager).compactCatalog(time0), willCompleteSuccessfully());
+ assertThat(((CatalogManagerImpl) catalogManager).compactCatalog(snapshotTime), willBe(true));
- IgniteTestUtils.waitForCondition(() -> catalogManager.earliestCatalogVersion() == catalogVersion0, 2_000);
-
- // Let's check outdated versions are not reachable.
- assertThrows(IllegalStateException.class, () -> catalogManager.activeCatalogVersion(0));
- assertThrows(IllegalStateException.class, () -> catalogManager.activeCatalogVersion(time0 - 1));
- assertThat(catalogManager.activeCatalogVersion(time0), equalTo(catalogVersion0));
- assertThat(catalogManager.activeCatalogVersion(time1), equalTo(catalogVersion1));
+ verify(interceptor, timeout(2_000)).handle(any(SnapshotEntry.class), any(), anyLong());
+ assertThat(catalogManager.earliestCatalogVersion(), equalTo(0));
// We will restart and recover the components and also set the clock to the future.
stopComponents();
createAndStartComponents();
- // Let's check that the versions for the points in time at which they were created are in place.
+ // Check recovery events.
+ verify(interceptor).handle(any(SnapshotEntry.class), any(), anyLong());
+ verify(interceptor).handle(any(VersionedUpdate.class), any(), anyLong());
+
+ // Let's check Catalog was recovered from a snapshot and history starts from the expected version.
+ assertThat(catalogManager.earliestCatalogVersion(), equalTo(earliestVersion));
assertThrows(IllegalStateException.class, () -> catalogManager.activeCatalogVersion(0));
- assertThrows(IllegalStateException.class, () -> catalogManager.activeCatalogVersion(time0 - 1));
- assertThat(catalogManager.activeCatalogVersion(time0), equalTo(catalogVersion0));
- assertThat(catalogManager.activeCatalogVersion(time1), equalTo(catalogVersion1));
+ assertThrows(IllegalStateException.class, () -> catalogManager.activeCatalogVersion(earliestVersionActivationTime - 1));
+ assertThat(catalogManager.activeCatalogVersion(earliestVersionActivationTime), equalTo(earliestVersion));
+ assertThat(catalogManager.activeCatalogVersion(snapshotTime), equalTo(earliestVersion));
+ assertThat(catalogManager.activeCatalogVersion(latestVersionActivationTime), equalTo(latestVersion));
}
@Test
@@ -179,7 +206,9 @@ public class CatalogManagerRecoveryTest extends BaseIgniteAbstractTest {
metaStorageManager = StandaloneMetaStorageManager.create(keyValueStorage);
- catalogManager = CatalogTestUtils.createTestCatalogManager(NODE_NAME, clock, metaStorageManager);
+ interceptor = spy(new TestUpdateHandlerInterceptor());
+
+ catalogManager = CatalogTestUtils.createTestCatalogManagerWithInterceptor(NODE_NAME, clock, metaStorageManager, interceptor);
}
private void startComponentsAndDeployWatches() {
diff --git a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java
index 7600345f5c..70e50158ba 100644
--- a/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java
+++ b/modules/catalog/src/test/java/org/apache/ignite/internal/catalog/CatalogManagerSelfTest.java
@@ -118,6 +118,7 @@ import org.apache.ignite.internal.catalog.commands.RenameZoneCommand;
import org.apache.ignite.internal.catalog.commands.StartBuildingIndexCommand;
import org.apache.ignite.internal.catalog.descriptors.CatalogHashIndexDescriptor;
import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
+import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor.CatalogIndexDescriptorType;
import org.apache.ignite.internal.catalog.descriptors.CatalogIndexStatus;
import org.apache.ignite.internal.catalog.descriptors.CatalogObjectDescriptor;
import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor;
@@ -131,6 +132,8 @@ import org.apache.ignite.internal.catalog.events.CatalogEventParameters;
import org.apache.ignite.internal.catalog.events.CreateIndexEventParameters;
import org.apache.ignite.internal.catalog.events.CreateTableEventParameters;
import org.apache.ignite.internal.catalog.events.CreateZoneEventParameters;
+import org.apache.ignite.internal.catalog.events.DestroyIndexEventParameters;
+import org.apache.ignite.internal.catalog.events.DestroyTableEventParameters;
import org.apache.ignite.internal.catalog.events.DropColumnEventParameters;
import org.apache.ignite.internal.catalog.events.DropTableEventParameters;
import org.apache.ignite.internal.catalog.events.DropZoneEventParameters;
@@ -146,7 +149,6 @@ import org.apache.ignite.internal.catalog.storage.VersionedUpdate;
import org.apache.ignite.internal.event.EventListener;
import org.apache.ignite.internal.hlc.HybridTimestamp;
import org.apache.ignite.internal.lang.IgniteInternalException;
-import org.apache.ignite.internal.testframework.IgniteTestUtils;
import org.apache.ignite.sql.ColumnType;
import org.hamcrest.TypeSafeMatcher;
import org.jetbrains.annotations.Nullable;
@@ -393,6 +395,31 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
assertSame(schema, manager.activeSchema(clock.nowLong()));
}
+ @Test
+ void testReCreateTableWithSameName() {
+ assertThat(manager.execute(simpleTable(TABLE_NAME)), willBe(nullValue()));
+
+ int catalogVersion = manager.latestCatalogVersion();
+ CatalogTableDescriptor table1 = manager.table(TABLE_NAME, clock.nowLong());
+ assertNotNull(table1);
+
+ // Drop table.
+ assertThat(manager.execute(dropTableCommand(TABLE_NAME)), willBe(nullValue()));
+ assertNull(manager.table(TABLE_NAME, clock.nowLong()));
+
+ // Re-create table with same name.
+ assertThat(manager.execute(simpleTable(TABLE_NAME)), willBe(nullValue()));
+
+ CatalogTableDescriptor table2 = manager.table(TABLE_NAME, clock.nowLong());
+ assertNotNull(table2);
+
+ // Ensure these are different tables.
+ assertNotEquals(table1.id(), table2.id());
+
+ // Ensure table is available for historical queries.
+ manager.table(table1.id(), catalogVersion);
+ }
+
@Test
public void testAddColumn() {
assertThat(manager.execute(simpleTable(TABLE_NAME)), willBe(nullValue()));
@@ -1146,18 +1173,35 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
manager.listen(CatalogEvent.TABLE_CREATE, eventListener);
manager.listen(CatalogEvent.TABLE_DROP, eventListener);
+ manager.listen(CatalogEvent.TABLE_DESTROY, eventListener);
assertThat(manager.execute(simpleTable(TABLE_NAME)), willBe(nullValue()));
- verify(eventListener).notify(any(CreateTableEventParameters.class), isNull());
+ assertThat(manager.execute(simpleTable(TABLE_NAME_2)), willBe(nullValue()));
+ assertThat(manager.execute(simpleTable(TABLE_NAME_3)), willBe(nullValue()));
+ verify(eventListener, times(3)).notify(any(CreateTableEventParameters.class), isNull());
assertThat(manager.execute(dropTableCommand(TABLE_NAME)), willBe(nullValue()));
- verify(eventListener).notify(any(DropTableEventParameters.class), isNull());
+ assertThat(manager.execute(dropTableCommand(TABLE_NAME_2)), willBe(nullValue()));
+ verify(eventListener, times(2)).notify(any(DropTableEventParameters.class), isNull());
+
+ verifyNoMoreInteractions(eventListener);
+ clearInvocations(eventListener);
+ // Got 'destroy' event only after Catalog compaction.
+ assertThat(CatalogTestUtils.waitCatalogCompaction(manager, clock.nowLong()), equalTo(true));
+ verify(eventListener, times(2)).notify(any(DestroyTableEventParameters.class), isNull());
+
+ verifyNoMoreInteractions(eventListener);
+ clearInvocations();
+
+ // Expect no events if Catalog wasn't compacted.
+ assertThat(CatalogTestUtils.waitCatalogCompaction(manager, clock.nowLong()), equalTo(false));
verifyNoMoreInteractions(eventListener);
}
+ //TODO IGNITE-20121 check correct events fired when dropping index in various states.
@Test
- public void testCreateIndexEvents() {
+ public void testIndexEvents() {
CatalogCommand createIndexCmd = createHashIndexCommand(INDEX_NAME, List.of("ID"));
CatalogCommand dropIndexCmd = DropIndexCommand.builder().schemaName(SCHEMA_NAME).indexName(INDEX_NAME).build();
@@ -1170,6 +1214,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
manager.listen(CatalogEvent.INDEX_AVAILABLE, eventListener);
manager.listen(CatalogEvent.INDEX_STOPPING, eventListener);
manager.listen(CatalogEvent.INDEX_REMOVED, eventListener);
+ manager.listen(CatalogEvent.INDEX_DESTROY, eventListener);
// Try to create index without table.
assertThat(manager.execute(createIndexCmd), willThrow(TableNotFoundValidationException.class));
@@ -1178,7 +1223,9 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
// Create table with PK index.
assertThat(manager.execute(simpleTable(TABLE_NAME)), willCompleteSuccessfully());
verify(eventListener).notify(any(CreateIndexEventParameters.class), isNull());
+ verify(eventListener).notify(any(MakeIndexAvailableEventParameters.class), isNull());
+ verifyNoMoreInteractions(eventListener);
clearInvocations(eventListener);
// Create index.
@@ -1191,6 +1238,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
makeIndexAvailable(indexId(INDEX_NAME));
verify(eventListener).notify(any(MakeIndexAvailableEventParameters.class), isNull());
+ verifyNoMoreInteractions(eventListener);
clearInvocations(eventListener);
// Drop index.
@@ -1201,6 +1249,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
removeIndex(indexId(INDEX_NAME));
verify(eventListener).notify(any(RemoveIndexEventParameters.class), isNull());
+ verifyNoMoreInteractions(eventListener);
clearInvocations(eventListener);
// Drop table with pk index.
@@ -1210,6 +1259,18 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
assertThat(manager.execute(dropIndexCmd), willThrow(IndexNotFoundValidationException.class));
verify(eventListener).notify(any(RemoveIndexEventParameters.class), isNull());
+ verifyNoMoreInteractions(eventListener);
+ clearInvocations(eventListener);
+
+ // Got 'destroy' event only after Catalog compaction.
+ assertThat(CatalogTestUtils.waitCatalogCompaction(manager, clock.nowLong()), equalTo(true));
+ verify(eventListener, times(2 /* PK + secondary index */)).notify(any(DestroyIndexEventParameters.class), isNull());
+
+ clearInvocations();
+
+ // Expect no events if Catalog wasn't compacted.
+ assertThat(CatalogTestUtils.waitCatalogCompaction(manager, clock.nowLong()), equalTo(false));
+ verifyNoMoreInteractions(eventListener);
}
@Test
@@ -1619,6 +1680,41 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
assertEquals(pkIndexId, pkRemovedEventParameters.indexId());
}
+ @Test
+ void testReCreateIndexWithSameName() {
+ createSomeTable(TABLE_NAME);
+ createSomeIndex(TABLE_NAME, INDEX_NAME);
+
+ int catalogVersion = manager.latestCatalogVersion();
+ CatalogIndexDescriptor index1 = manager.index(INDEX_NAME, clock.nowLong());
+ assertNotNull(index1);
+
+ int indexId1 = index1.id();
+ startBuildingIndex(indexId1);
+ makeIndexAvailable(indexId1);
+
+ // Drop index.
+ dropIndex(INDEX_NAME);
+ removeIndex(indexId1);
+ assertNull(manager.index(INDEX_NAME, clock.nowLong()));
+
+ // Re-create index with same name.
+ createSomeSortedIndex(TABLE_NAME, INDEX_NAME);
+
+ CatalogIndexDescriptor index2 = manager.index(INDEX_NAME, clock.nowLong());
+ assertNotNull(index2);
+ assertThat(index2.indexType(), equalTo(CatalogIndexDescriptorType.SORTED));
+
+ // Ensure these are different indexes.
+ int indexId2 = index2.id();
+ assertNotEquals(indexId1, indexId2);
+
+ // Ensure dropped index is available for historical queries.
+ assertNotNull(manager.index(indexId1, catalogVersion));
+ assertThat(manager.index(indexId1, catalogVersion).indexType(), equalTo(CatalogIndexDescriptorType.HASH));
+ assertNull(manager.index(indexId2, catalogVersion));
+ }
+
@Test
void testLatestCatalogVersion() {
assertEquals(0, manager.latestCatalogVersion());
@@ -2457,7 +2553,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
}
@Test
- public void testCatalogCompaction() throws InterruptedException {
+ public void testCatalogCompaction() {
assertThat(manager.execute(simpleTable(TABLE_NAME)), willBe(nullValue()));
assertThat(manager.execute(simpleTable(TABLE_NAME_2)), willBe(nullValue()));
@@ -2468,9 +2564,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
assertThat(manager.execute(simpleIndex(TABLE_NAME, INDEX_NAME)), willBe(nullValue()));
assertThat(manager.execute(simpleIndex(TABLE_NAME, INDEX_NAME_2)), willBe(nullValue()));
- assertThat(manager.compactCatalog(timestamp), willCompleteSuccessfully());
-
- IgniteTestUtils.waitForCondition(() -> manager.earliestCatalogVersion() != 0, 2_000);
+ assertThat(CatalogTestUtils.waitCatalogCompaction(manager, timestamp), equalTo(true));
assertEquals(catalog.version(), manager.earliestCatalogVersion());
@@ -2482,6 +2576,9 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
assertThrows(IllegalStateException.class, () -> manager.activeCatalogVersion(catalog.time() - 1));
assertSame(catalog.version(), manager.activeCatalogVersion(catalog.time()));
assertSame(catalog.version(), manager.activeCatalogVersion(timestamp));
+
+ assertThat(manager.compactCatalog(timestamp), willBe(false));
+ assertEquals(catalog.version(), manager.earliestCatalogVersion());
}
@Test
@@ -2490,7 +2587,7 @@ public class CatalogManagerSelfTest extends BaseCatalogManagerTest {
long timestamp = clock.nowLong();
- assertThat(manager.compactCatalog(timestamp), willCompleteSuccessfully());
+ assertThat(manager.compactCatalog(timestamp), willBe(false));
assertEquals(0, manager.earliestCatalogVersion());
assertEquals(0, manager.latestCatalogVersion());
diff --git a/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/BaseCatalogManagerTest.java b/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/BaseCatalogManagerTest.java
index b02ccad23f..988d101d5e 100644
--- a/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/BaseCatalogManagerTest.java
+++ b/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/BaseCatalogManagerTest.java
@@ -38,6 +38,7 @@ import org.apache.ignite.internal.catalog.commands.CreateHashIndexCommand;
import org.apache.ignite.internal.catalog.commands.CreateSortedIndexCommand;
import org.apache.ignite.internal.catalog.commands.CreateTableCommand;
import org.apache.ignite.internal.catalog.commands.CreateTableCommandBuilder;
+import org.apache.ignite.internal.catalog.commands.DropIndexCommand;
import org.apache.ignite.internal.catalog.commands.DropTableCommand;
import org.apache.ignite.internal.catalog.commands.StartBuildingIndexCommand;
import org.apache.ignite.internal.catalog.descriptors.CatalogColumnCollation;
@@ -221,4 +222,18 @@ public abstract class BaseCatalogManagerTest extends BaseIgniteAbstractTest {
protected static CatalogCommand startBuildingIndexCommand(int indexId) {
return StartBuildingIndexCommand.builder().indexId(indexId).build();
}
+
+ protected static CatalogCommand dropTableCommand(String tableName) {
+ return DropTableCommand.builder()
+ .schemaName(DEFAULT_SCHEMA_NAME)
+ .tableName(tableName)
+ .build();
+ }
+
+ protected static CatalogCommand dropIndexCommand(String indexName) {
+ return DropIndexCommand.builder()
+ .schemaName(DEFAULT_SCHEMA_NAME)
+ .indexName(indexName)
+ .build();
+ }
}
diff --git a/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/CatalogTestUtils.java b/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/CatalogTestUtils.java
index 1b28c39c28..a06467a0de 100644
--- a/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/CatalogTestUtils.java
+++ b/modules/catalog/src/testFixtures/java/org/apache/ignite/internal/catalog/CatalogTestUtils.java
@@ -42,9 +42,12 @@ import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor;
import org.apache.ignite.internal.catalog.storage.SnapshotEntry;
import org.apache.ignite.internal.catalog.storage.UpdateLog;
+import org.apache.ignite.internal.catalog.storage.UpdateLog.OnUpdateHandler;
+import org.apache.ignite.internal.catalog.storage.UpdateLogEvent;
import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
import org.apache.ignite.internal.catalog.storage.VersionedUpdate;
import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.hlc.HybridTimestamp;
import org.apache.ignite.internal.lang.IgniteInternalException;
import org.apache.ignite.internal.metastorage.MetaStorageManager;
import org.apache.ignite.internal.metastorage.impl.StandaloneMetaStorageManager;
@@ -113,7 +116,6 @@ public class CatalogTestUtils {
public void beforeNodeStop() {
super.beforeNodeStop();
- clockWaiter.beforeNodeStop();
metastore.beforeNodeStop();
}
@@ -121,7 +123,6 @@ public class CatalogTestUtils {
public void stop() throws Exception {
super.stop();
- clockWaiter.stop();
metastore.stop();
}
};
@@ -161,6 +162,55 @@ public class CatalogTestUtils {
};
}
+ /**
+ * Creates a test implementation of {@link CatalogManager}.
+ *
+ * <p>NOTE: Uses {@link CatalogManagerImpl} under the hood and creates the internals it needs, may change in the future.
+ *
+ * @param nodeName Node name.
+ * @param clock Hybrid clock.
+ * @param metastore Meta storage manager.
+ */
+ public static CatalogManager createTestCatalogManagerWithInterceptor(
+ String nodeName,
+ HybridClock clock,
+ MetaStorageManager metastore,
+ UpdateHandlerInterceptor interceptor
+ ) {
+ var clockWaiter = new ClockWaiter(nodeName, clock);
+
+ UpdateLogImpl updateLog = new UpdateLogImpl(metastore) {
+ @Override
+ public void registerUpdateHandler(OnUpdateHandler handler) {
+ interceptor.registerUpdateHandler(handler);
+
+ super.registerUpdateHandler(interceptor);
+ }
+ };
+
+
+ return new CatalogManagerImpl(updateLog, clockWaiter) {
+ @Override
+ public CompletableFuture<Void> start() {
+ return allOf(clockWaiter.start(), super.start());
+ }
+
+ @Override
+ public void beforeNodeStop() {
+ super.beforeNodeStop();
+
+ clockWaiter.beforeNodeStop();
+ }
+
+ @Override
+ public void stop() throws Exception {
+ super.stop();
+
+ clockWaiter.stop();
+ }
+ };
+ }
+
/**
* Create the same {@link CatalogManager} as for normal operations, but with {@link UpdateLog} that
* simply notifies the manager without storing any updates in metastore.
@@ -300,7 +350,7 @@ public class CatalogTestUtils {
* @param timestamp Timestamp catalog should be compacted up to.
* @return {@code True} if a new snapshot has been successfully written, {@code false} otherwise.
*/
- static boolean waitCatalogCompaction(CatalogManager catalogManager, long timestamp) {
+ public static boolean waitCatalogCompaction(CatalogManager catalogManager, long timestamp) {
int version = catalogManager.activeCatalogVersion(timestamp);
CompletableFuture<Boolean> operationFuture = ((CatalogManagerImpl) catalogManager).compactCatalog(timestamp);
@@ -422,4 +472,39 @@ public class CatalogTestUtils {
.findFirst()
.orElse(null);
}
+
+ /**
+ * Update handler interceptor for test purposes.
+ */
+ public abstract static class UpdateHandlerInterceptor implements OnUpdateHandler {
+ private OnUpdateHandler delegate;
+
+ void registerUpdateHandler(OnUpdateHandler handler) {
+ this.delegate = handler;
+ }
+
+ protected OnUpdateHandler delegate() {
+ return delegate;
+ }
+ }
+
+ /**
+ * An interceptor, which allow dropping events.
+ */
+ public static class TestUpdateHandlerInterceptor extends UpdateHandlerInterceptor {
+ private volatile boolean dropEvents;
+
+ public void dropSnapshotEvents() {
+ this.dropEvents = true;
+ }
+
+ @Override
+ public CompletableFuture<Void> handle(UpdateLogEvent update, HybridTimestamp metaStorageUpdateTimestamp, long causalityToken) {
+ if (dropEvents && update instanceof SnapshotEntry) {
+ return nullCompletedFuture();
+ }
+
+ return delegate().handle(update, metaStorageUpdateTimestamp, causalityToken);
+ }
+ }
}
diff --git a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/TableManagerTest.java b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/TableManagerTest.java
index 6fa4e74c36..156c020722 100644
--- a/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/TableManagerTest.java
+++ b/modules/table/src/test/java/org/apache/ignite/internal/table/distributed/TableManagerTest.java
@@ -35,7 +35,9 @@ import static org.apache.ignite.sql.ColumnType.INT64;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -351,6 +353,37 @@ public class TableManagerTest extends IgniteAbstractTest {
assertEquals(0, tableManager.tables().size());
}
+ /**
+ * Tests create a table through public API right after another table with the same name was dropped.
+ *
+ * @throws Exception If failed.
+ */
+ @Test
+ public void testReCreateTableWithSameName() throws Exception {
+ mockManagersAndCreateTable(DYNAMIC_TABLE_NAME, tblManagerFut);
+
+ TableManager tableManager = tblManagerFut.join();
+
+ TableViewInternal table = (TableViewInternal) tableManager.table(DYNAMIC_TABLE_NAME);
+
+ assertNotNull(table);
+
+ int oldTableId = table.tableId();
+
+ dropTable(DYNAMIC_TABLE_NAME);
+ createTable(DYNAMIC_TABLE_NAME);
+
+ table = tableManager.tableView(DYNAMIC_TABLE_NAME);
+
+ assertNotNull(table);
+ assertNotEquals(oldTableId, table.tableId());
+
+ // TODO IGNITE-20680 ensure old table is available
+ // assertNotNull(tableManager.getTable(oldTableId));
+ assertNotNull(tableManager.getTable(table.tableId()));
+ assertNotSame(tableManager.getTable(oldTableId), tableManager.getTable(table.tableId()));
+ }
+
/**
* Tests a work of the public API for Table manager {@see org.apache.ignite.table.manager.IgniteTables} when the manager is stopping.
*/