This is an automated email from the ASF dual-hosted git repository.
jshao pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/gravitino.git
The following commit(s) were added to refs/heads/main by this push:
new 53bad8a11f [MINOR] fix(core): Fix UT for cache (#7463)
53bad8a11f is described below
commit 53bad8a11fd3a01db362bfa1aa755ea2cdd5d17a
Author: Lord of Abyss <[email protected]>
AuthorDate: Wed Jun 25 14:29:37 2025 +0800
[MINOR] fix(core): Fix UT for cache (#7463)
### What changes were proposed in this pull request?
Fix UT for cache.
| Class | Change Description | Purpose & Impact |
| --------------------- |
------------------------------------------------------ |
------------------------------------------------------------ |
| `CaffeineEntityCache` | Replace `estimatedSize()` with
`cacheIndex.size()` | Ensure accurate and deterministic cache size
reporting |
| `EntityCacheWeigher` | Make `MAX_WEIGHT` private and use
`@VisibleForTesting` | Prevent misuse, expose only to test code via
MockStatic |
| | Relax constructor visibility to `protected` | |
### Why are the changes needed?
MINOR
### Does this PR introduce _any_ user-facing change?
no
### How was this patch tested?
local test.
---------
Co-authored-by: Jerry Shao <[email protected]>
---
.../gravitino/cache/CaffeineEntityCache.java | 2 +-
.../apache/gravitino/cache/EntityCacheWeigher.java | 6 +-
.../gravitino/cache/TestCaffeineEntityCache.java | 561 ++++++++++++---------
3 files changed, 318 insertions(+), 251 deletions(-)
diff --git
a/core/src/main/java/org/apache/gravitino/cache/CaffeineEntityCache.java
b/core/src/main/java/org/apache/gravitino/cache/CaffeineEntityCache.java
index 7609f0efc8..c572427fd1 100644
--- a/core/src/main/java/org/apache/gravitino/cache/CaffeineEntityCache.java
+++ b/core/src/main/java/org/apache/gravitino/cache/CaffeineEntityCache.java
@@ -185,7 +185,7 @@ public class CaffeineEntityCache extends BaseEntityCache {
/** {@inheritDoc} */
@Override
public long size() {
- return cacheData.estimatedSize();
+ return cacheIndex.size();
}
/** {@inheritDoc} */
diff --git
a/core/src/main/java/org/apache/gravitino/cache/EntityCacheWeigher.java
b/core/src/main/java/org/apache/gravitino/cache/EntityCacheWeigher.java
index 8fe8c5e255..bdf32172b3 100644
--- a/core/src/main/java/org/apache/gravitino/cache/EntityCacheWeigher.java
+++ b/core/src/main/java/org/apache/gravitino/cache/EntityCacheWeigher.java
@@ -20,6 +20,7 @@
package org.apache.gravitino.cache;
import com.github.benmanes.caffeine.cache.Weigher;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import java.util.List;
@@ -53,10 +54,11 @@ public class EntityCacheWeigher implements
Weigher<EntityCacheKey, List<Entity>>
Entity.EntityType.METALAKE, METALAKE_WEIGHT,
Entity.EntityType.CATALOG, CATALOG_WEIGHT,
Entity.EntityType.SCHEMA, SCHEMA_WEIGHT);
- public static long MAX_WEIGHT =
+ private static long MAX_WEIGHT =
2 * (METALAKE_WEIGHT * 10 + CATALOG_WEIGHT * (10 * 200) + SCHEMA_WEIGHT
* (10 * 200 * 1000));
- private EntityCacheWeigher() {}
+ @VisibleForTesting
+ protected EntityCacheWeigher() {}
/**
* Returns the maximum weight that can be stored in the cache.
diff --git
a/core/src/test/java/org/apache/gravitino/cache/TestCaffeineEntityCache.java
b/core/src/test/java/org/apache/gravitino/cache/TestCaffeineEntityCache.java
index d355425808..489c3c044d 100644
--- a/core/src/test/java/org/apache/gravitino/cache/TestCaffeineEntityCache.java
+++ b/core/src/test/java/org/apache/gravitino/cache/TestCaffeineEntityCache.java
@@ -19,16 +19,20 @@
package org.apache.gravitino.cache;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.awaitility.Awaitility.await;
+import static org.mockito.Mockito.mockStatic;
+
import com.github.benmanes.caffeine.cache.Cache;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Sets;
import java.util.List;
+import java.util.concurrent.TimeUnit;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.gravitino.Config;
import org.apache.gravitino.Configs;
import org.apache.gravitino.Entity;
-import org.apache.gravitino.NameIdentifier;
import org.apache.gravitino.Namespace;
import org.apache.gravitino.SupportsRelationOperations;
import org.apache.gravitino.meta.BaseMetalake;
@@ -43,29 +47,15 @@ import org.apache.gravitino.meta.TableEntity;
import org.apache.gravitino.meta.TagEntity;
import org.apache.gravitino.meta.TopicEntity;
import org.apache.gravitino.meta.UserEntity;
-import org.apache.gravitino.utils.NameIdentifierUtil;
import org.apache.gravitino.utils.TestUtil;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
+import org.mockito.MockedStatic;
@TestInstance(TestInstance.Lifecycle.PER_METHOD)
public class TestCaffeineEntityCache {
- private static NameIdentifier ident1;
- private static NameIdentifier ident2;
- private static NameIdentifier ident3;
- private static NameIdentifier ident4;
- private static NameIdentifier ident5;
- private static NameIdentifier ident6;
- private static NameIdentifier ident7;
- private static NameIdentifier ident8;
- private static NameIdentifier ident9;
- private static NameIdentifier ident10;
- private static NameIdentifier ident11;
- private static NameIdentifier ident12;
- private static NameIdentifier ident13;
-
// Test Entities.
private static SchemaEntity entity1;
private static SchemaEntity entity2;
@@ -95,14 +85,46 @@ public class TestCaffeineEntityCache {
}
@BeforeAll
- static void init() {
- initTestNameIdentifier();
- initTestEntities();
+ static void initTestEntities() {
+ entity1 =
+ TestUtil.getTestSchemaEntity(
+ 1L, "schema1", Namespace.of("metalake1", "catalog1"),
"test_schema1");
+ entity2 =
+ TestUtil.getTestSchemaEntity(
+ 2L, "schema2", Namespace.of("metalake2", "catalog2"),
"test_schema2");
+ entity3 =
+ TestUtil.getTestTableEntity(3L, "table1", Namespace.of("metalake1",
"catalog1", "schema1"));
+ entity4 =
+ TestUtil.getTestTableEntity(4L, "table2", Namespace.of("metalake1",
"catalog2", "schema1"));
+ entity5 =
+ TestUtil.getTestTableEntity(5L, "table3", Namespace.of("metalake1",
"catalog1", "schema2"));
+ entity6 =
+ TestUtil.getTestCatalogEntity(
+ 6L, "catalog1", Namespace.of("metalake1"), "hive", "test_catalog");
+ entity7 = TestUtil.getTestMetalake(7L, "metalake1", "test_metalake1");
+
+ entity8 = TestUtil.getTestUserEntity(8L, "user1", "metalake1",
ImmutableList.of(12L));
+ entity9 = TestUtil.getTestUserEntity(9L, "user2", "metalake1",
ImmutableList.of(12L));
+
+ entity10 = TestUtil.getTestGroupEntity(10L, "group1", "metalake2",
ImmutableList.of("role2"));
+ entity11 = TestUtil.getTestGroupEntity(11L, "group2", "metalake2",
ImmutableList.of("role2"));
+
+ entity12 = TestUtil.getTestRoleEntity(12L, "role1", "metalake1");
+ entity13 = TestUtil.getTestRoleEntity(13L, "role2", "metalake2");
+ }
+
+ @Test
+ void testEnableStats() {
+ Config config = new Config() {};
+ config.set(Configs.CACHE_STATS_ENABLED, true);
+ EntityCache cache = new CaffeineEntityCache(config);
+
+ Assertions.assertDoesNotThrow(() -> cache.put(entity1));
}
@Test
void testPutAllTypeInCache() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
BaseMetalake testMetalake = TestUtil.getTestMetalake();
CatalogEntity testCatalogEntity = TestUtil.getTestCatalogEntity();
@@ -193,7 +215,7 @@ public class TestCaffeineEntityCache {
@Test
void testPutSameIdentifierEntities() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
UserEntity testUserEntity = TestUtil.getTestUserEntity();
TableEntity testTableEntity =
@@ -211,7 +233,7 @@ public class TestCaffeineEntityCache {
@Test
void testPutAndGet() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
@@ -236,30 +258,34 @@ public class TestCaffeineEntityCache {
SupportsRelationOperations.Type.ROLE_GROUP_REL,
ImmutableList.of(entity10, entity11));
- Assertions.assertTrue(cache.contains(ident1, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident2, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident3, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident4, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident5, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident6, Entity.EntityType.CATALOG));
- Assertions.assertTrue(cache.contains(ident7, Entity.EntityType.METALAKE));
+ Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
entity1.type()));
+ Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
entity2.type()));
+ Assertions.assertTrue(cache.contains(entity3.nameIdentifier(),
entity3.type()));
+ Assertions.assertTrue(cache.contains(entity4.nameIdentifier(),
entity4.type()));
+ Assertions.assertTrue(cache.contains(entity5.nameIdentifier(),
entity5.type()));
+ Assertions.assertTrue(cache.contains(entity6.nameIdentifier(),
entity6.type()));
+ Assertions.assertTrue(cache.contains(entity7.nameIdentifier(),
entity7.type()));
- Assertions.assertTrue(cache.contains(ident8, Entity.EntityType.USER));
- Assertions.assertTrue(cache.contains(ident9, Entity.EntityType.USER));
- Assertions.assertTrue(cache.contains(ident10, Entity.EntityType.GROUP));
- Assertions.assertTrue(cache.contains(ident11, Entity.EntityType.GROUP));
+ Assertions.assertTrue(cache.contains(entity8.nameIdentifier(),
entity8.type()));
+ Assertions.assertTrue(cache.contains(entity9.nameIdentifier(),
entity9.type()));
+ Assertions.assertTrue(cache.contains(entity10.nameIdentifier(),
entity10.type()));
+ Assertions.assertTrue(cache.contains(entity11.nameIdentifier(),
entity11.type()));
Assertions.assertTrue(
cache.contains(
- ident12, Entity.EntityType.ROLE,
SupportsRelationOperations.Type.ROLE_USER_REL));
+ entity12.nameIdentifier(),
+ entity12.type(),
+ SupportsRelationOperations.Type.ROLE_USER_REL));
Assertions.assertTrue(
cache.contains(
- ident13, Entity.EntityType.ROLE,
SupportsRelationOperations.Type.ROLE_GROUP_REL));
+ entity13.nameIdentifier(),
+ entity13.type(),
+ SupportsRelationOperations.Type.ROLE_GROUP_REL));
}
@Test
void testGetIfPresent() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
@@ -270,42 +296,48 @@ public class TestCaffeineEntityCache {
SupportsRelationOperations.Type.ROLE_USER_REL,
ImmutableList.of(entity8, entity9));
- Assertions.assertTrue(cache.getIfPresent(ident1,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident2,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident3,
Entity.EntityType.TABLE).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity1.nameIdentifier(),
entity1.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity2.nameIdentifier(),
entity2.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity3.nameIdentifier(),
entity3.type()).isPresent());
Assertions.assertTrue(
cache
.getIfPresent(
- SupportsRelationOperations.Type.ROLE_USER_REL, ident12,
Entity.EntityType.ROLE)
+ SupportsRelationOperations.Type.ROLE_USER_REL,
+ entity12.nameIdentifier(),
+ entity12.type())
.isPresent());
Assertions.assertEquals(cache.size(), 4);
- Assertions.assertFalse(cache.getIfPresent(ident4,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident5,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident6,
Entity.EntityType.CATALOG).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident7,
Entity.EntityType.METALAKE).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity4.nameIdentifier(),
entity4.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity5.nameIdentifier(),
entity5.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity6.nameIdentifier(),
entity6.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity7.nameIdentifier(),
entity7.type()).isPresent());
}
@Test
void testContains() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
cache.put(entity3);
- Assertions.assertTrue(cache.contains(ident1, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident2, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident3, Entity.EntityType.TABLE));
- Assertions.assertFalse(cache.contains(ident4, Entity.EntityType.TABLE));
- Assertions.assertFalse(cache.contains(ident5, Entity.EntityType.TABLE));
- Assertions.assertFalse(cache.contains(ident6, Entity.EntityType.CATALOG));
- Assertions.assertFalse(cache.contains(ident7, Entity.EntityType.METALAKE));
+ Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
entity1.type()));
+ Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
entity2.type()));
+ Assertions.assertTrue(cache.contains(entity3.nameIdentifier(),
entity3.type()));
+ Assertions.assertFalse(cache.contains(entity4.nameIdentifier(),
entity4.type()));
+ Assertions.assertFalse(cache.contains(entity5.nameIdentifier(),
entity5.type()));
+ Assertions.assertFalse(cache.contains(entity6.nameIdentifier(),
entity6.type()));
+ Assertions.assertFalse(cache.contains(entity7.nameIdentifier(),
entity7.type()));
}
@Test
void testSize() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
@@ -316,7 +348,7 @@ public class TestCaffeineEntityCache {
@Test
void testClear() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
Assertions.assertDoesNotThrow(cache::clear);
cache.put(entity1);
@@ -342,28 +374,39 @@ public class TestCaffeineEntityCache {
cache.clear();
Assertions.assertEquals(0, cache.size());
- Assertions.assertFalse(cache.getIfPresent(ident1,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident2,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident3,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident4,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident5,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident6,
Entity.EntityType.CATALOG).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident7,
Entity.EntityType.METALAKE).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity1.nameIdentifier(),
entity1.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity2.nameIdentifier(),
entity2.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity3.nameIdentifier(),
entity3.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity4.nameIdentifier(),
entity4.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity5.nameIdentifier(),
entity5.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity6.nameIdentifier(),
entity6.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity7.nameIdentifier(),
entity7.type()).isPresent());
Assertions.assertFalse(
cache
.getIfPresent(
- SupportsRelationOperations.Type.ROLE_USER_REL, ident12,
Entity.EntityType.ROLE)
+ SupportsRelationOperations.Type.ROLE_USER_REL,
+ entity12.nameIdentifier(),
+ entity12.type())
.isPresent());
Assertions.assertFalse(
cache
.getIfPresent(
- SupportsRelationOperations.Type.ROLE_GROUP_REL, ident13,
Entity.EntityType.ROLE)
+ SupportsRelationOperations.Type.ROLE_GROUP_REL,
+ entity13.nameIdentifier(),
+ entity13.type())
.isPresent());
}
@Test
void testInvalidateMetalake() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
@@ -390,27 +433,29 @@ public class TestCaffeineEntityCache {
Assertions.assertEquals(13, cache.size());
- cache.invalidate(ident7, Entity.EntityType.METALAKE);
+ cache.invalidate(entity7.nameIdentifier(), entity7.type());
Assertions.assertEquals(4, cache.size());
- Assertions.assertTrue(cache.contains(ident10, Entity.EntityType.GROUP));
- Assertions.assertTrue(cache.contains(ident11, Entity.EntityType.GROUP));
+ Assertions.assertTrue(cache.contains(entity10.nameIdentifier(),
entity10.type()));
+ Assertions.assertTrue(cache.contains(entity11.nameIdentifier(),
entity11.type()));
Assertions.assertTrue(
cache.contains(
- ident13, Entity.EntityType.ROLE,
SupportsRelationOperations.Type.ROLE_GROUP_REL));
- Assertions.assertTrue(cache.getIfPresent(ident2,
Entity.EntityType.SCHEMA).isPresent());
-
- Assertions.assertFalse(cache.contains(ident1, Entity.EntityType.SCHEMA));
- Assertions.assertFalse(cache.contains(ident3, Entity.EntityType.TABLE));
- Assertions.assertFalse(cache.contains(ident4, Entity.EntityType.TABLE));
- Assertions.assertFalse(cache.contains(ident5, Entity.EntityType.TABLE));
- Assertions.assertFalse(cache.contains(ident6, Entity.EntityType.TABLE));
- Assertions.assertFalse(cache.contains(ident7, Entity.EntityType.TABLE));
+ entity13.nameIdentifier(),
+ entity13.type(),
+ SupportsRelationOperations.Type.ROLE_GROUP_REL));
+ Assertions.assertTrue(cache.getIfPresent(entity2.nameIdentifier(),
entity2.type()).isPresent());
+
+ Assertions.assertFalse(cache.contains(entity1.nameIdentifier(),
entity1.type()));
+ Assertions.assertFalse(cache.contains(entity3.nameIdentifier(),
entity3.type()));
+ Assertions.assertFalse(cache.contains(entity4.nameIdentifier(),
entity4.type()));
+ Assertions.assertFalse(cache.contains(entity5.nameIdentifier(),
entity5.type()));
+ Assertions.assertFalse(cache.contains(entity6.nameIdentifier(),
entity6.type()));
+ Assertions.assertFalse(cache.contains(entity7.nameIdentifier(),
entity7.type()));
}
@Test
void testInvalidateCatalog() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
@@ -421,30 +466,34 @@ public class TestCaffeineEntityCache {
cache.put(entity7);
Assertions.assertEquals(7, cache.size());
- Assertions.assertTrue(cache.contains(ident1, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident2, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident3, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident4, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident5, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident6, Entity.EntityType.CATALOG));
- Assertions.assertTrue(cache.contains(ident7, Entity.EntityType.METALAKE));
-
- cache.invalidate(ident6, Entity.EntityType.CATALOG);
+ Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
entity1.type()));
+ Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
entity2.type()));
+ Assertions.assertTrue(cache.contains(entity3.nameIdentifier(),
entity3.type()));
+ Assertions.assertTrue(cache.contains(entity4.nameIdentifier(),
entity4.type()));
+ Assertions.assertTrue(cache.contains(entity5.nameIdentifier(),
entity5.type()));
+ Assertions.assertTrue(cache.contains(entity6.nameIdentifier(),
entity6.type()));
+ Assertions.assertTrue(cache.contains(entity7.nameIdentifier(),
entity7.type()));
+
+ cache.invalidate(entity6.nameIdentifier(), entity6.type());
Assertions.assertEquals(3, cache.size());
- Assertions.assertTrue(cache.getIfPresent(ident7,
Entity.EntityType.METALAKE).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident4,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident2,
Entity.EntityType.SCHEMA).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity7.nameIdentifier(),
entity7.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity4.nameIdentifier(),
entity4.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity2.nameIdentifier(),
entity2.type()).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident1,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident3,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident5,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident6,
Entity.EntityType.TABLE).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity1.nameIdentifier(),
entity1.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity3.nameIdentifier(),
entity3.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity5.nameIdentifier(),
entity5.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity6.nameIdentifier(),
entity6.type()).isPresent());
}
@Test
void testInvalidateSchema() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
@@ -455,31 +504,33 @@ public class TestCaffeineEntityCache {
cache.put(entity7);
Assertions.assertEquals(7, cache.size());
- Assertions.assertTrue(cache.contains(ident1, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident2, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident3, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident4, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident5, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident6, Entity.EntityType.CATALOG));
- Assertions.assertTrue(cache.contains(ident7, Entity.EntityType.METALAKE));
+ Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
entity1.type()));
+ Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
entity2.type()));
+ Assertions.assertTrue(cache.contains(entity3.nameIdentifier(),
entity3.type()));
+ Assertions.assertTrue(cache.contains(entity4.nameIdentifier(),
entity4.type()));
+ Assertions.assertTrue(cache.contains(entity5.nameIdentifier(),
entity5.type()));
+ Assertions.assertTrue(cache.contains(entity6.nameIdentifier(),
entity6.type()));
+ Assertions.assertTrue(cache.contains(entity7.nameIdentifier(),
entity7.type()));
- cache.invalidate(ident1, Entity.EntityType.SCHEMA);
+ cache.invalidate(entity1.nameIdentifier(), entity1.type());
Assertions.assertEquals(5, cache.size());
- Assertions.assertTrue(cache.getIfPresent(ident2,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident4,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident5,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident6,
Entity.EntityType.CATALOG).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident7,
Entity.EntityType.METALAKE).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity2.nameIdentifier(),
entity2.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity4.nameIdentifier(),
entity4.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity5.nameIdentifier(),
entity5.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity6.nameIdentifier(),
entity6.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity7.nameIdentifier(),
entity7.type()).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident1,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertFalse(cache.getIfPresent(ident3,
Entity.EntityType.TABLE).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity1.nameIdentifier(),
entity1.type()).isPresent());
+ Assertions.assertFalse(
+ cache.getIfPresent(entity3.nameIdentifier(),
entity3.type()).isPresent());
}
@Test
void testInvalidateTable() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
cache.put(entity2);
@@ -490,30 +541,30 @@ public class TestCaffeineEntityCache {
cache.put(entity7);
Assertions.assertEquals(7, cache.size());
- Assertions.assertTrue(cache.contains(ident1, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident2, Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(ident3, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident4, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident5, Entity.EntityType.TABLE));
- Assertions.assertTrue(cache.contains(ident6, Entity.EntityType.CATALOG));
- Assertions.assertTrue(cache.contains(ident7, Entity.EntityType.METALAKE));
+ Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
entity1.type()));
+ Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
entity2.type()));
+ Assertions.assertTrue(cache.contains(entity3.nameIdentifier(),
entity3.type()));
+ Assertions.assertTrue(cache.contains(entity4.nameIdentifier(),
entity4.type()));
+ Assertions.assertTrue(cache.contains(entity5.nameIdentifier(),
entity5.type()));
+ Assertions.assertTrue(cache.contains(entity6.nameIdentifier(),
entity6.type()));
+ Assertions.assertTrue(cache.contains(entity7.nameIdentifier(),
entity7.type()));
- cache.invalidate(ident3, Entity.EntityType.TABLE);
+ cache.invalidate(entity3.nameIdentifier(), entity3.type());
Assertions.assertEquals(6, cache.size());
- Assertions.assertTrue(cache.getIfPresent(ident1,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident2,
Entity.EntityType.SCHEMA).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident4,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident5,
Entity.EntityType.TABLE).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident6,
Entity.EntityType.CATALOG).isPresent());
- Assertions.assertTrue(cache.getIfPresent(ident7,
Entity.EntityType.METALAKE).isPresent());
-
- Assertions.assertFalse(cache.contains(ident3, Entity.EntityType.TABLE));
+ Assertions.assertTrue(cache.getIfPresent(entity1.nameIdentifier(),
entity1.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity2.nameIdentifier(),
entity2.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity4.nameIdentifier(),
entity4.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity5.nameIdentifier(),
entity5.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity6.nameIdentifier(),
entity6.type()).isPresent());
+ Assertions.assertTrue(cache.getIfPresent(entity7.nameIdentifier(),
entity7.type()).isPresent());
+
+ Assertions.assertFalse(cache.contains(entity3.nameIdentifier(),
entity3.type()));
}
@Test
void testPutRelationalEntitiesWithMerge() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
RoleEntity testRoleEntity = TestUtil.getTestRoleEntity();
GroupEntity testGroupEntity1 =
TestUtil.getTestGroupEntity(
@@ -568,7 +619,7 @@ public class TestCaffeineEntityCache {
"test model version",
ImmutableList.of("alias1", "alias2"));
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(testModelEntity);
Assertions.assertEquals(1, cache.size());
Assertions.assertTrue(cache.contains(testModelEntity.nameIdentifier(),
testModelEntity.type()));
@@ -583,7 +634,7 @@ public class TestCaffeineEntityCache {
@Test
void testPutSameRelationalEntities() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
RoleEntity testRoleEntity = TestUtil.getTestRoleEntity();
GroupEntity testGroupEntity =
TestUtil.getTestGroupEntity(
@@ -627,7 +678,7 @@ public class TestCaffeineEntityCache {
@Test
void testPutRelationalEntitiesWithEmptyList() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
RoleEntity testRoleEntity = TestUtil.getTestRoleEntity();
Assertions.assertDoesNotThrow(
@@ -642,7 +693,7 @@ public class TestCaffeineEntityCache {
@Test
void testPutRelationalEntitiesWithDifferentOrderButDeduplicated() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
RoleEntity testRoleEntity = TestUtil.getTestRoleEntity();
GroupEntity testGroupEntity1 =
TestUtil.getTestGroupEntity(
@@ -685,7 +736,7 @@ public class TestCaffeineEntityCache {
@Test
void testInvalidateRelationKeyAndRelatedEntities() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
RoleEntity role = TestUtil.getTestRoleEntity();
GroupEntity group = TestUtil.getTestGroupEntity();
UserEntity user = TestUtil.getTestUserEntity();
@@ -715,39 +766,44 @@ public class TestCaffeineEntityCache {
@Test
void testRemoveNonExistentEntity() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
Assertions.assertEquals(1, cache.size());
- Assertions.assertTrue(cache.contains(ident1, Entity.EntityType.SCHEMA));
+ Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
entity1.type()));
- Assertions.assertDoesNotThrow(() -> cache.invalidate(ident2,
Entity.EntityType.SCHEMA));
- Assertions.assertFalse(cache.invalidate(ident2, Entity.EntityType.SCHEMA));
+ Assertions.assertDoesNotThrow(() ->
cache.invalidate(entity2.nameIdentifier(), entity2.type()));
+ Assertions.assertFalse(cache.invalidate(entity2.nameIdentifier(),
entity2.type()));
- Assertions.assertDoesNotThrow(() -> cache.invalidate(ident7,
Entity.EntityType.METALAKE));
- Assertions.assertFalse(cache.invalidate(ident7,
Entity.EntityType.METALAKE));
+ Assertions.assertDoesNotThrow(() ->
cache.invalidate(entity7.nameIdentifier(), entity7.type()));
+ Assertions.assertFalse(cache.invalidate(entity7.nameIdentifier(),
entity7.type()));
}
@Test
- void testExpireByTime() throws InterruptedException {
- int waitTime = 3_000;
+ @SuppressWarnings("unchecked")
+ void testExpireByTime() {
long expireTime = 1_000L;
Config config = new Config() {};
config.set(Configs.CACHE_EXPIRATION_TIME, expireTime);
config.set(Configs.CACHE_WEIGHER_ENABLED, false);
- EntityCache cache = new CaffeineEntityCache(config);
+ EntityCache cache = new CaffeineEntityCache(config);
cache.put(entity1);
- Thread.sleep(waitTime);
- cache.put(entity2);
- Cache<EntityCacheKey, List<Entity>> caffeineObject =
- (Cache<EntityCacheKey, List<Entity>>) getCacheDataFrom(cache);
- caffeineObject.cleanUp();
+ await()
+ .atMost(3_000, MILLISECONDS)
+ .pollInterval(100, MILLISECONDS)
+ .until(
+ () -> {
+ cache.put(entity2);
+ Cache<EntityCacheKey, List<Entity>> internalCache =
+ (Cache<EntityCacheKey, List<Entity>>)
getCacheDataFrom(cache);
+ internalCache.cleanUp();
+ return !cache.contains(entity1.nameIdentifier(),
Entity.EntityType.SCHEMA);
+ });
- Assertions.assertEquals(1, cache.size());
Assertions.assertFalse(cache.contains(entity1.nameIdentifier(),
Entity.EntityType.SCHEMA));
Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
Entity.EntityType.SCHEMA));
}
@@ -755,51 +811,69 @@ public class TestCaffeineEntityCache {
@Test
void testExpireByWeightExceedMaxWeight() {
Config config = new Config() {};
- long oldMaxWeight = EntityCacheWeigher.MAX_WEIGHT;
- EntityCacheWeigher.MAX_WEIGHT = 75;
config.set(Configs.CACHE_WEIGHER_ENABLED, true);
- EntityCache cache = new CaffeineEntityCache(config);
- cache.put(entity7);
- Cache<EntityCacheKey, List<Entity>> caffeineObject =
- (Cache<EntityCacheKey, List<Entity>>) getCacheDataFrom(cache);
- caffeineObject.cleanUp();
+ try (MockedStatic<EntityCacheWeigher> mockedStatic =
mockStatic(EntityCacheWeigher.class)) {
+ mockedStatic.when(EntityCacheWeigher::getMaxWeight).thenReturn(75L);
+ mockedStatic.when(EntityCacheWeigher::getInstance).thenReturn(new
EntityCacheWeigher());
- Assertions.assertEquals(0, cache.size());
- Assertions.assertFalse(cache.contains(entity7.nameIdentifier(),
Entity.EntityType.METALAKE));
+ EntityCache cache = new CaffeineEntityCache(config);
+ cache.put(entity7);
- EntityCacheWeigher.MAX_WEIGHT = oldMaxWeight;
- }
+ Cache<EntityCacheKey, List<Entity>> caffeineObject =
+ (Cache<EntityCacheKey, List<Entity>>) getCacheDataFrom(cache);
- @Test
- void testExpireByWeight() {
- Config config = new Config() {};
- long maxWeight = EntityCacheWeigher.MAX_WEIGHT;
- EntityCacheWeigher.MAX_WEIGHT = 100;
- config.set(Configs.CACHE_WEIGHER_ENABLED, true);
- EntityCache cache = new CaffeineEntityCache(config);
+ await()
+ .atMost(1, TimeUnit.SECONDS)
+ .pollInterval(50, TimeUnit.MILLISECONDS)
+ .until(
+ () -> {
+ caffeineObject.cleanUp();
+ return !cache.contains(entity7.nameIdentifier(),
Entity.EntityType.METALAKE);
+ });
- cache.put(entity7);
- Assertions.assertEquals(1, cache.size());
- Assertions.assertTrue(cache.contains(entity7.nameIdentifier(),
Entity.EntityType.METALAKE));
-
- cache.put(entity1);
- cache.put(entity2);
- Cache<EntityCacheKey, List<Entity>> caffeineObject =
- (Cache<EntityCacheKey, List<Entity>>) getCacheDataFrom(cache);
- caffeineObject.cleanUp();
-
- Assertions.assertEquals(2, cache.size());
- Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
Entity.EntityType.SCHEMA));
- Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
Entity.EntityType.SCHEMA));
+ Assertions.assertEquals(0, cache.size());
+ Assertions.assertFalse(cache.contains(entity7.nameIdentifier(),
Entity.EntityType.METALAKE));
+ }
+ }
- EntityCacheWeigher.MAX_WEIGHT = maxWeight;
+ @Test
+ @SuppressWarnings("unchecked")
+ void testExpireByWeight() throws InterruptedException {
+ try (MockedStatic<EntityCacheWeigher> entityCacheWeigherMocked =
+ mockStatic(EntityCacheWeigher.class)) {
+
entityCacheWeigherMocked.when(EntityCacheWeigher::getMaxWeight).thenReturn(105L);
+ entityCacheWeigherMocked
+ .when(EntityCacheWeigher::getInstance)
+ .thenReturn(new EntityCacheWeigher());
+ Config config = new Config() {};
+ config.set(Configs.CACHE_WEIGHER_ENABLED, true);
+
+ EntityCache cache = new CaffeineEntityCache(config);
+ cache.put(entity7);
+ Assertions.assertEquals(1, cache.size());
+ Assertions.assertTrue(cache.contains(entity7.nameIdentifier(),
entity7.type()));
+
+ cache.put(entity1);
+ cache.put(entity2);
+ cache.getIfPresent(entity1.nameIdentifier(), entity1.type());
+ cache.getIfPresent(entity2.nameIdentifier(), entity2.type());
+
+ Cache<EntityCacheKey, List<Entity>> caffeineObject =
+ (Cache<EntityCacheKey, List<Entity>>) getCacheDataFrom(cache);
+ caffeineObject.cleanUp();
+ await()
+ .atMost(1500, MILLISECONDS)
+ .pollInterval(50, MILLISECONDS)
+ .until(() -> !cache.contains(entity7.nameIdentifier(),
entity7.type()));
+ }
}
@Test
void testExpireBySize() {
Config config = new Config() {};
config.set(Configs.CACHE_WEIGHER_ENABLED, false);
+ config.set(Configs.CACHE_EXPIRATION_TIME, 0L);
config.set(Configs.CACHE_MAX_ENTRIES, 1);
EntityCache cache = new CaffeineEntityCache(config);
@@ -808,18 +882,24 @@ public class TestCaffeineEntityCache {
cache.put(entity1);
caffeineObject.cleanUp();
+ await()
+ .atMost(500, MILLISECONDS)
+ .until(() -> cache.contains(entity1.nameIdentifier(),
Entity.EntityType.SCHEMA));
Assertions.assertEquals(1, cache.size());
- Assertions.assertTrue(cache.contains(entity1.nameIdentifier(),
Entity.EntityType.SCHEMA));
cache.put(entity2);
caffeineObject.cleanUp();
+ await()
+ .atMost(500, MILLISECONDS)
+ .until(() -> cache.contains(entity2.nameIdentifier(), entity2.type()));
Assertions.assertEquals(1, cache.size());
- Assertions.assertTrue(cache.contains(entity2.nameIdentifier(),
Entity.EntityType.SCHEMA));
cache.put(entity3);
caffeineObject.cleanUp();
+ await()
+ .atMost(500, MILLISECONDS)
+ .until(() -> cache.contains(entity3.nameIdentifier(), entity3.type()));
Assertions.assertEquals(1, cache.size());
- Assertions.assertTrue(cache.contains(entity3.nameIdentifier(),
Entity.EntityType.TABLE));
}
@Test
@@ -827,29 +907,38 @@ public class TestCaffeineEntityCache {
int metalakeWeight =
EntityCacheWeigher.getInstance()
.weigh(
- EntityCacheKey.of(ident7, Entity.EntityType.METALAKE),
ImmutableList.of(entity7));
+ EntityCacheKey.of(entity7.nameIdentifier(), entity7.type()),
+ ImmutableList.of(entity7));
Assertions.assertEquals(100, metalakeWeight);
int catalogWeight =
EntityCacheWeigher.getInstance()
- .weigh(EntityCacheKey.of(ident6, Entity.EntityType.CATALOG),
ImmutableList.of(entity6));
+ .weigh(
+ EntityCacheKey.of(entity6.nameIdentifier(), entity6.type()),
+ ImmutableList.of(entity6));
Assertions.assertEquals(75, catalogWeight);
int schemaWeight =
EntityCacheWeigher.getInstance()
- .weigh(EntityCacheKey.of(ident1, Entity.EntityType.SCHEMA),
ImmutableList.of(entity1));
+ .weigh(
+ EntityCacheKey.of(entity1.nameIdentifier(), entity1.type()),
+ ImmutableList.of(entity1));
Assertions.assertEquals(50, schemaWeight);
int tableWeight =
EntityCacheWeigher.getInstance()
- .weigh(EntityCacheKey.of(ident3, Entity.EntityType.TABLE),
ImmutableList.of(entity3));
+ .weigh(
+ EntityCacheKey.of(entity3.nameIdentifier(), entity3.type()),
+ ImmutableList.of(entity3));
Assertions.assertEquals(15, tableWeight);
int multiUserWeight =
EntityCacheWeigher.getInstance()
.weigh(
EntityCacheKey.of(
- ident12, Entity.EntityType.ROLE,
SupportsRelationOperations.Type.ROLE_USER_REL),
+ entity12.nameIdentifier(),
+ entity12.type(),
+ SupportsRelationOperations.Type.ROLE_USER_REL),
ImmutableList.of(entity8, entity9));
Assertions.assertEquals(30, multiUserWeight);
@@ -857,16 +946,17 @@ public class TestCaffeineEntityCache {
@Test
void testGetIfPresentWithNull() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
cache.put(entity1);
Assertions.assertThrows(
IllegalArgumentException.class, () -> cache.getIfPresent(null,
Entity.EntityType.SCHEMA));
- Assertions.assertThrows(IllegalArgumentException.class, () ->
cache.getIfPresent(ident1, null));
+ Assertions.assertThrows(
+ IllegalArgumentException.class, () ->
cache.getIfPresent(entity1.nameIdentifier(), null));
Assertions.assertThrows(
IllegalArgumentException.class,
- () -> cache.getIfPresent(null, ident12, Entity.EntityType.ROLE));
+ () -> cache.getIfPresent(null, entity12.nameIdentifier(),
entity12.type()));
Assertions.assertThrows(
IllegalArgumentException.class,
() ->
@@ -874,19 +964,24 @@ public class TestCaffeineEntityCache {
SupportsRelationOperations.Type.ROLE_USER_REL, null,
Entity.EntityType.ROLE));
Assertions.assertThrows(
IllegalArgumentException.class,
- () ->
cache.getIfPresent(SupportsRelationOperations.Type.ROLE_USER_REL, ident12,
null));
+ () ->
+ cache.getIfPresent(
+ SupportsRelationOperations.Type.ROLE_USER_REL,
entity12.nameIdentifier(), null));
Assertions.assertThrows(
IllegalArgumentException.class,
- () ->
cache.getIfPresent(SupportsRelationOperations.Type.ROLE_USER_REL, ident12,
null));
+ () ->
+ cache.getIfPresent(
+ SupportsRelationOperations.Type.ROLE_USER_REL,
entity12.nameIdentifier(), null));
}
@Test
void testContainsWithNull() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
Assertions.assertThrows(
IllegalArgumentException.class, () -> cache.contains(null,
Entity.EntityType.SCHEMA));
- Assertions.assertThrows(IllegalArgumentException.class, () ->
cache.contains(ident7, null));
+ Assertions.assertThrows(
+ IllegalArgumentException.class, () ->
cache.contains(entity7.nameIdentifier(), null));
Assertions.assertThrows(
IllegalArgumentException.class,
@@ -895,19 +990,22 @@ public class TestCaffeineEntityCache {
null, Entity.EntityType.ROLE,
SupportsRelationOperations.Type.ROLE_USER_REL));
Assertions.assertThrows(
IllegalArgumentException.class,
- () -> cache.contains(ident12, null,
SupportsRelationOperations.Type.ROLE_USER_REL));
+ () ->
+ cache.contains(
+ entity12.nameIdentifier(), null,
SupportsRelationOperations.Type.ROLE_USER_REL));
Assertions.assertThrows(
IllegalArgumentException.class,
- () -> cache.contains(ident12, Entity.EntityType.ROLE, null));
+ () -> cache.contains(entity12.nameIdentifier(), entity12.type(),
null));
}
@Test
void testInvalidateWithNull() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
Assertions.assertThrows(
IllegalArgumentException.class, () -> cache.invalidate(null,
Entity.EntityType.CATALOG));
- Assertions.assertThrows(IllegalArgumentException.class, () ->
cache.invalidate(ident7, null));
+ Assertions.assertThrows(
+ IllegalArgumentException.class, () ->
cache.invalidate(entity7.nameIdentifier(), null));
Assertions.assertThrows(
IllegalArgumentException.class,
@@ -916,15 +1014,17 @@ public class TestCaffeineEntityCache {
null, Entity.EntityType.ROLE,
SupportsRelationOperations.Type.ROLE_USER_REL));
Assertions.assertThrows(
IllegalArgumentException.class,
- () -> cache.invalidate(ident12, null,
SupportsRelationOperations.Type.ROLE_USER_REL));
+ () ->
+ cache.invalidate(
+ entity12.nameIdentifier(), null,
SupportsRelationOperations.Type.ROLE_USER_REL));
Assertions.assertThrows(
IllegalArgumentException.class,
- () -> cache.invalidate(ident12, Entity.EntityType.ROLE, null));
+ () -> cache.invalidate(entity12.nameIdentifier(), entity12.type(),
null));
}
@Test
void testPutWithNull() {
- EntityCache cache = new CaffeineEntityCache(new Config() {});
+ EntityCache cache = getNormalCache();
Assertions.assertThrows(IllegalArgumentException.class, () ->
cache.put(null));
@@ -940,64 +1040,29 @@ public class TestCaffeineEntityCache {
IllegalArgumentException.class,
() ->
cache.put(
- ident12, null, SupportsRelationOperations.Type.ROLE_USER_REL,
ImmutableList.of()));
+ entity12.nameIdentifier(),
+ null,
+ SupportsRelationOperations.Type.ROLE_USER_REL,
+ ImmutableList.of()));
Assertions.assertThrows(
IllegalArgumentException.class,
- () -> cache.put(ident12, Entity.EntityType.ROLE, null,
ImmutableList.of()));
+ () -> cache.put(entity12.nameIdentifier(), entity12.type(), null,
ImmutableList.of()));
Assertions.assertThrows(
IllegalArgumentException.class,
() ->
cache.put(
- ident12,
+ entity12.nameIdentifier(),
Entity.EntityType.ROLE,
SupportsRelationOperations.Type.ROLE_USER_REL,
null));
}
- private static void initTestNameIdentifier() {
- ident1 = NameIdentifier.of("metalake1", "catalog1", "schema1");
- ident2 = NameIdentifier.of("metalake2", "catalog2", "schema2");
- ident3 = NameIdentifier.of("metalake1", "catalog1", "schema1", "table1");
- ident4 = NameIdentifier.of("metalake1", "catalog2", "schema1", "table2");
- ident5 = NameIdentifier.of("metalake1", "catalog1", "schema2", "table3");
- ident6 = NameIdentifier.of("metalake1", "catalog1");
- ident7 = NameIdentifier.of("metalake1");
-
- ident8 = NameIdentifierUtil.ofUser("metalake1", "user1");
- ident9 = NameIdentifierUtil.ofUser("metalake1", "user2");
-
- ident10 = NameIdentifierUtil.ofGroup("metalake2", "group1");
- ident11 = NameIdentifierUtil.ofGroup("metalake2", "group2");
-
- ident12 = NameIdentifierUtil.ofRole("metalake1", "role1");
- ident13 = NameIdentifierUtil.ofRole("metalake2", "role2");
- }
-
- private static void initTestEntities() {
- entity1 =
- TestUtil.getTestSchemaEntity(
- 1L, "schema1", Namespace.of("metalake1", "catalog1"),
"test_schema1");
- entity2 =
- TestUtil.getTestSchemaEntity(
- 2L, "schema2", Namespace.of("metalake2", "catalog2"),
"test_schema2");
- entity3 =
- TestUtil.getTestTableEntity(3L, "table1", Namespace.of("metalake1",
"catalog1", "schema1"));
- entity4 =
- TestUtil.getTestTableEntity(4L, "table2", Namespace.of("metalake1",
"catalog2", "schema1"));
- entity5 =
- TestUtil.getTestTableEntity(5L, "table3", Namespace.of("metalake1",
"catalog1", "schema2"));
- entity6 =
- TestUtil.getTestCatalogEntity(
- 6L, "catalog1", Namespace.of("metalake1"), "hive", "test_catalog");
- entity7 = TestUtil.getTestMetalake(7L, "metalake1", "test_metalake1");
-
- entity8 = TestUtil.getTestUserEntity(8L, "user1", "metalake1",
ImmutableList.of(12L));
- entity9 = TestUtil.getTestUserEntity(9L, "user2", "metalake1",
ImmutableList.of(12L));
-
- entity10 = TestUtil.getTestGroupEntity(10L, "group1", "metalake2",
ImmutableList.of("role2"));
- entity11 = TestUtil.getTestGroupEntity(11L, "group2", "metalake2",
ImmutableList.of("role2"));
+ private EntityCache getNormalCache() {
+ Config config = new Config() {};
+ config.set(Configs.CACHE_EXPIRATION_TIME, 0L);
+ config.set(Configs.CACHE_WEIGHER_ENABLED, false);
+ config.set(Configs.CACHE_MAX_ENTRIES, 1000000);
- entity12 = TestUtil.getTestRoleEntity(12L, "role1", "metalake1");
- entity13 = TestUtil.getTestRoleEntity(13L, "role2", "metalake2");
+ return new CaffeineEntityCache(config);
}
}
