From efb151b7d5374a89205d8faca058f7126134b02a Mon Sep 17 00:00:00 2001 From: Thomas Vitale Date: Sat, 27 Jan 2024 18:17:17 +0100 Subject: [PATCH] refactor: Align naming for tenant information Signed-off-by: Thomas Vitale --- .../cache/DefaultTenantKeyGenerator.java | 2 +- .../context/TenantContextHolder.java | 22 +++++++------- .../HolderTenantContextEventListener.java | 2 +- .../events/MdcTenantContextEventListener.java | 16 +++++----- ...ObservationTenantContextEventListener.java | 20 ++++++------- .../events/TenantContextAttachedEvent.java | 4 +-- .../events/TenantContextClosedEvent.java | 4 +-- .../resolvers/FixedTenantResolver.java | 16 +++++----- .../context/resolvers/TenantResolver.java | 2 +- .../core/multitenancy/events/TenantEvent.java | 12 ++++---- .../exceptions/TenantResolutionException.java | 4 +-- .../cache/DefaultTenantKeyGeneratorTests.java | 4 +-- .../context/TenantContextHolderTests.java | 30 ++++++++++--------- ...HolderTenantContextEventListenerTests.java | 14 ++++----- .../MdcTenantContextEventListenerTests.java | 4 +-- ...vationTenantContextEventListenerTests.java | 28 ++++++++--------- .../resolvers/FixedTenantResolverTests.java | 18 +++++------ .../multitenancy/events/TenantEventTests.java | 12 ++++---- .../TenantResolutionExceptionTests.java | 2 +- .../FixedTenantResolutionProperties.java | 10 +++---- .../MultitenancyCoreAutoConfiguration.java | 2 +- .../HttpTenantResolutionConfiguration.java | 2 +- ...MultitenancyWebAutoConfigurationTests.java | 4 +-- .../context/filters/TenantContextFilter.java | 16 +++++----- .../resolvers/CookieTenantResolver.java | 2 +- .../resolvers/HeaderTenantResolver.java | 2 +- .../resolvers/HttpRequestTenantResolver.java | 2 +- .../filters/TenantContextFilterTests.java | 8 ++--- .../resolvers/CookieTenantResolverTests.java | 6 ++-- .../resolvers/HeaderTenantResolverTests.java | 6 ++-- 30 files changed, 139 insertions(+), 137 deletions(-) diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGenerator.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGenerator.java index ea97192..1ebf49f 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGenerator.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGenerator.java @@ -16,7 +16,7 @@ public final class DefaultTenantKeyGenerator implements TenantKeyGenerator { @Override public Object generate(Object target, Method method, Object... params) { - return SimpleKeyGenerator.generateKey(TenantContextHolder.getRequiredTenantId(), params); + return SimpleKeyGenerator.generateKey(TenantContextHolder.getRequiredTenantIdentifier(), params); } } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/TenantContextHolder.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/TenantContextHolder.java index e44465f..a081f27 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/TenantContextHolder.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/TenantContextHolder.java @@ -17,33 +17,33 @@ public final class TenantContextHolder { private static final Logger log = LoggerFactory.getLogger(TenantContextHolder.class); - private static final ThreadLocal tenantId = new ThreadLocal<>(); + private static final ThreadLocal tenantIdentifier = new ThreadLocal<>(); private TenantContextHolder() { } - public static void setTenantId(final String tenant) { - Assert.hasText(tenant, "tenantId cannot be empty"); + public static void setTenantIdentifier(String tenant) { + Assert.hasText(tenant, "tenant cannot be empty"); log.trace("Setting current tenant to: {}", tenant); - tenantId.set(tenant); + tenantIdentifier.set(tenant); } @Nullable - public static String getTenantId() { - return tenantId.get(); + public static String getTenantIdentifier() { + return tenantIdentifier.get(); } - public static String getRequiredTenantId() { - var tenantId = getTenantId(); - if (!StringUtils.hasText(tenantId)) { + public static String getRequiredTenantIdentifier() { + var tenant = getTenantIdentifier(); + if (!StringUtils.hasText(tenant)) { throw new TenantNotFoundException("No tenant found in the current context"); } - return tenantId; + return tenant; } public static void clear() { log.trace("Clearing current tenant"); - tenantId.remove(); + tenantIdentifier.remove(); } } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListener.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListener.java index d4bc355..bd990a0 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListener.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListener.java @@ -15,7 +15,7 @@ public final class HolderTenantContextEventListener implements TenantEventListen @Override public void onApplicationEvent(TenantEvent tenantEvent) { if (tenantEvent instanceof TenantContextAttachedEvent event) { - TenantContextHolder.setTenantId(event.getTenantId()); + TenantContextHolder.setTenantIdentifier(event.getTenantIdentifier()); } else if (tenantEvent instanceof TenantContextClosedEvent) { TenantContextHolder.clear(); diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListener.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListener.java index 3e7fdb4..d5b369d 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListener.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListener.java @@ -14,26 +14,26 @@ */ public final class MdcTenantContextEventListener implements TenantEventListener { - public static final String DEFAULT_TENANT_ID_KEY = "tenantId"; + public static final String DEFAULT_TENANT_IDENTIFIER_KEY = "tenantId"; - private final String tenantIdKey; + private final String tenantIdentifierKey; public MdcTenantContextEventListener() { - this(DEFAULT_TENANT_ID_KEY); + this(DEFAULT_TENANT_IDENTIFIER_KEY); } - public MdcTenantContextEventListener(String tenantIdKey) { - Assert.hasText(tenantIdKey, "tenantIdKey cannot be empty"); - this.tenantIdKey = tenantIdKey; + public MdcTenantContextEventListener(String tenantIdentifierKey) { + Assert.hasText(tenantIdentifierKey, "tenantIdentifierKey cannot be empty"); + this.tenantIdentifierKey = tenantIdentifierKey; } @Override public void onApplicationEvent(TenantEvent tenantEvent) { if (tenantEvent instanceof TenantContextAttachedEvent event) { - MDC.put(tenantIdKey, event.getTenantId()); + MDC.put(tenantIdentifierKey, event.getTenantIdentifier()); } else if (tenantEvent instanceof TenantContextClosedEvent) { - MDC.remove(tenantIdKey); + MDC.remove(tenantIdentifierKey); } } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListener.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListener.java index 50955f5..c338250 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListener.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListener.java @@ -18,20 +18,20 @@ public class ObservationTenantContextEventListener implements TenantEventListene public static final Cardinality DEFAULT_CARDINALITY = Cardinality.HIGH; - public static final String DEFAULT_TENANT_ID_KEY = "tenant.id"; + public static final String DEFAULT_TENANT_IDENTIFIER_KEY = "tenant.id"; private final Cardinality cardinality; - private final String tenantIdKey; + private final String tenantIdentifierKey; public ObservationTenantContextEventListener() { - this(DEFAULT_TENANT_ID_KEY, DEFAULT_CARDINALITY); + this(DEFAULT_TENANT_IDENTIFIER_KEY, DEFAULT_CARDINALITY); } - public ObservationTenantContextEventListener(String tenantIdKey, Cardinality cardinality) { - Assert.hasText(tenantIdKey, "tenantIdKey cannot be empty"); + public ObservationTenantContextEventListener(String tenantIdentifierKey, Cardinality cardinality) { + Assert.hasText(tenantIdentifierKey, "tenantIdentifierKey cannot be empty"); Assert.notNull(cardinality, "cardinality cannot be null"); - this.tenantIdKey = tenantIdKey; + this.tenantIdentifierKey = tenantIdentifierKey; this.cardinality = cardinality; } @@ -48,10 +48,10 @@ private void onTenantContextAttached(TenantContextAttachedEvent event) { } switch (cardinality) { - case LOW -> - event.getObservationContext().addLowCardinalityKeyValue(KeyValue.of(tenantIdKey, event.getTenantId())); - case HIGH -> - event.getObservationContext().addHighCardinalityKeyValue(KeyValue.of(tenantIdKey, event.getTenantId())); + case LOW -> event.getObservationContext() + .addLowCardinalityKeyValue(KeyValue.of(tenantIdentifierKey, event.getTenantIdentifier())); + case HIGH -> event.getObservationContext() + .addHighCardinalityKeyValue(KeyValue.of(tenantIdentifierKey, event.getTenantIdentifier())); } } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextAttachedEvent.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextAttachedEvent.java index 848455e..d454a53 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextAttachedEvent.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextAttachedEvent.java @@ -18,8 +18,8 @@ public final class TenantContextAttachedEvent extends TenantEvent { @Nullable private Observation.Context observationContext; - public TenantContextAttachedEvent(String tenantId, Object object) { - super(tenantId, object); + public TenantContextAttachedEvent(String tenantIdentifier, Object object) { + super(tenantIdentifier, object); } @Nullable diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextClosedEvent.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextClosedEvent.java index 033162e..bd4487a 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextClosedEvent.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/events/TenantContextClosedEvent.java @@ -10,8 +10,8 @@ */ public final class TenantContextClosedEvent extends TenantEvent { - public TenantContextClosedEvent(String tenantId, Object object) { - super(tenantId, object); + public TenantContextClosedEvent(String tenantIdentifier, Object object) { + super(tenantIdentifier, object); } } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolver.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolver.java index 0b944c9..575eab5 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolver.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolver.java @@ -10,23 +10,23 @@ */ public final class FixedTenantResolver implements TenantResolver { - public static final String DEFAULT_FIXED_TENANT = "default"; + public static final String DEFAULT_FIXED_TENANT_IDENTIFIER = "default"; - private final String fixedTenantName; + private final String fixedTenantIdentifier; public FixedTenantResolver() { - fixedTenantName = DEFAULT_FIXED_TENANT; + fixedTenantIdentifier = DEFAULT_FIXED_TENANT_IDENTIFIER; } - public FixedTenantResolver(String tenantName) { - Assert.hasText(tenantName, "tenantName cannot be empty"); - this.fixedTenantName = tenantName; + public FixedTenantResolver(String tenantIdentifier) { + Assert.hasText(tenantIdentifier, "tenantIdentifier cannot be empty"); + this.fixedTenantIdentifier = tenantIdentifier; } @Override @NonNull - public String resolveTenantId(Object source) { - return fixedTenantName; + public String resolveTenantIdentifier(Object source) { + return fixedTenantIdentifier; } } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/TenantResolver.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/TenantResolver.java index a6c48bb..b581466 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/TenantResolver.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/context/resolvers/TenantResolver.java @@ -14,6 +14,6 @@ public interface TenantResolver { * Resolves a tenant identifier from the given source. */ @Nullable - String resolveTenantId(T source); + String resolveTenantIdentifier(T source); } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/events/TenantEvent.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/events/TenantEvent.java index f61704b..2d6b50e 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/events/TenantEvent.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/events/TenantEvent.java @@ -10,16 +10,16 @@ */ public abstract class TenantEvent extends ApplicationEvent { - private final String tenantId; + private final String tenantIdentifier; - public TenantEvent(String tenantId, Object source) { + public TenantEvent(String tenantIdentifier, Object source) { super(source); - Assert.hasText(tenantId, "tenantId cannot be empty"); - this.tenantId = tenantId; + Assert.hasText(tenantIdentifier, "tenantIdentifier cannot be empty"); + this.tenantIdentifier = tenantIdentifier; } - public String getTenantId() { - return tenantId; + public String getTenantIdentifier() { + return tenantIdentifier; } } diff --git a/arconia-core/src/main/java/io/arconia/core/multitenancy/exceptions/TenantResolutionException.java b/arconia-core/src/main/java/io/arconia/core/multitenancy/exceptions/TenantResolutionException.java index a4be8be..e473631 100644 --- a/arconia-core/src/main/java/io/arconia/core/multitenancy/exceptions/TenantResolutionException.java +++ b/arconia-core/src/main/java/io/arconia/core/multitenancy/exceptions/TenantResolutionException.java @@ -1,14 +1,14 @@ package io.arconia.core.multitenancy.exceptions; /** - * Thrown when the source of the operation didn't provide any tenant information. + * Thrown when an error occurred during the tenant resolution process. * * @author Thomas Vitale */ public class TenantResolutionException extends IllegalStateException { public TenantResolutionException() { - super("A tenant must be specified for the current operation"); + super("Error when trying to resolve the current tenant"); } public TenantResolutionException(String message) { diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGeneratorTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGeneratorTests.java index ad07024..704768d 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGeneratorTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/cache/DefaultTenantKeyGeneratorTests.java @@ -22,12 +22,12 @@ class DefaultTenantKeyGeneratorTests { void whenTenantContextDefinedThenGenerateCacheKey() { var objectToCache = new Object[] { "something" }; - TenantContextHolder.setTenantId("tenant1"); + TenantContextHolder.setTenantIdentifier("tenant1"); Object key1 = generateCacheKey(objectToCache); Object key2 = generateCacheKey(objectToCache); TenantContextHolder.clear(); - TenantContextHolder.setTenantId("tenant2"); + TenantContextHolder.setTenantIdentifier("tenant2"); Object key3 = generateCacheKey(objectToCache); TenantContextHolder.clear(); diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/TenantContextHolderTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/TenantContextHolderTests.java index dda7f74..f6c60e2 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/TenantContextHolderTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/TenantContextHolderTests.java @@ -16,41 +16,43 @@ class TenantContextHolderTests { @Test void setValidTenantContext() { - var tenantId = "acme"; - TenantContextHolder.setTenantId(tenantId); - assertThat(TenantContextHolder.getTenantId()).isEqualTo(tenantId); + var tenantIdentifier = "acme"; + TenantContextHolder.setTenantIdentifier(tenantIdentifier); + assertThat(TenantContextHolder.getTenantIdentifier()).isEqualTo(tenantIdentifier); } @Test void setNullTenantContext() { - assertThatThrownBy(() -> TenantContextHolder.setTenantId(null)).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantId cannot be empty"); + assertThatThrownBy(() -> TenantContextHolder.setTenantIdentifier(null)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("tenant cannot be empty"); } @Test void setEmptyTenantContext() { - assertThatThrownBy(() -> TenantContextHolder.setTenantId("")).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantId cannot be empty"); + assertThatThrownBy(() -> TenantContextHolder.setTenantIdentifier("")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessageContaining("tenant cannot be empty"); } @Test void clearTenantContext() { - var tenantId = "acme"; - TenantContextHolder.setTenantId(tenantId); + var tenantIdentifier = "acme"; + TenantContextHolder.setTenantIdentifier(tenantIdentifier); TenantContextHolder.clear(); - assertThat(TenantContextHolder.getTenantId()).isNull(); + assertThat(TenantContextHolder.getTenantIdentifier()).isNull(); } @Test void whenRequiredTenantContextPresentThenReturn() { - var tenantId = "acme"; - TenantContextHolder.setTenantId(tenantId); - assertThat(TenantContextHolder.getRequiredTenantId()).isEqualTo(tenantId); + var tenantIdentifier = "acme"; + TenantContextHolder.setTenantIdentifier(tenantIdentifier); + assertThat(TenantContextHolder.getRequiredTenantIdentifier()).isEqualTo(tenantIdentifier); } @Test void whenRequiredTenantContextMissingThenThrow() { - assertThatThrownBy(TenantContextHolder::getRequiredTenantId).isInstanceOf(TenantNotFoundException.class) + assertThatThrownBy(TenantContextHolder::getRequiredTenantIdentifier).isInstanceOf(TenantNotFoundException.class) .hasMessageContaining("No tenant found in the current context"); } diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListenerTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListenerTests.java index 8832c92..21e61ff 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListenerTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/HolderTenantContextEventListenerTests.java @@ -16,22 +16,22 @@ class HolderTenantContextEventListenerTests { @Test void whenContextIsAttached() { var listener = new HolderTenantContextEventListener(); - var tenantId = "acme"; + var tenantIdentifier = "acme"; - listener.onApplicationEvent(new TenantContextAttachedEvent(tenantId, this)); + listener.onApplicationEvent(new TenantContextAttachedEvent(tenantIdentifier, this)); - assertThat(TenantContextHolder.getTenantId()).isEqualTo(tenantId); + assertThat(TenantContextHolder.getTenantIdentifier()).isEqualTo(tenantIdentifier); } @Test void whenContextIsClosed() { var listener = new HolderTenantContextEventListener(); - var tenantId = "acme"; + var tenantIdentifier = "acme"; - listener.onApplicationEvent(new TenantContextAttachedEvent(tenantId, this)); - listener.onApplicationEvent(new TenantContextClosedEvent(tenantId, this)); + listener.onApplicationEvent(new TenantContextAttachedEvent(tenantIdentifier, this)); + listener.onApplicationEvent(new TenantContextClosedEvent(tenantIdentifier, this)); - assertThat(TenantContextHolder.getTenantId()).isNull(); + assertThat(TenantContextHolder.getTenantIdentifier()).isNull(); } } diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListenerTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListenerTests.java index dfb6276..6b66159 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListenerTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/MdcTenantContextEventListenerTests.java @@ -16,13 +16,13 @@ class MdcTenantContextEventListenerTests { @Test void whenNullCustomValueThenThrow() { assertThatThrownBy(() -> new MdcTenantContextEventListener(null)).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantIdKey cannot be empty"); + .hasMessageContaining("tenantIdentifierKey cannot be empty"); } @Test void whenEmptyCustomValueThenThrow() { assertThatThrownBy(() -> new MdcTenantContextEventListener("")).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantIdKey cannot be empty"); + .hasMessageContaining("tenantIdentifierKey cannot be empty"); } @Test diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListenerTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListenerTests.java index ae5a79f..5854ee5 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListenerTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/events/ObservationTenantContextEventListenerTests.java @@ -27,7 +27,7 @@ void whenEmptyTenantKeyThenThrow() { assertThatThrownBy(() -> new ObservationTenantContextEventListener("", ObservationTenantContextEventListener.Cardinality.HIGH)) .isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantIdKey cannot be empty"); + .hasMessageContaining("tenantIdentifierKey cannot be empty"); } @Test @@ -35,55 +35,55 @@ void whenNullTenantKeyThenThrow() { assertThatThrownBy(() -> new ObservationTenantContextEventListener(null, ObservationTenantContextEventListener.Cardinality.HIGH)) .isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantIdKey cannot be empty"); + .hasMessageContaining("tenantIdentifierKey cannot be empty"); } @Test void whenDefaultValueIsUsedAsKey() { - var tenantId = "acme"; + var tenantIdentifier = "acme"; var listener = new ObservationTenantContextEventListener(); var observationContext = new Observation.Context(); - var event = new TenantContextAttachedEvent(tenantId, this); + var event = new TenantContextAttachedEvent(tenantIdentifier, this); event.setObservationContext(observationContext); listener.onApplicationEvent(event); assertThat(observationContext - .getHighCardinalityKeyValue(ObservationTenantContextEventListener.DEFAULT_TENANT_ID_KEY)) - .isEqualTo(KeyValue.of(ObservationTenantContextEventListener.DEFAULT_TENANT_ID_KEY, tenantId)); + .getHighCardinalityKeyValue(ObservationTenantContextEventListener.DEFAULT_TENANT_IDENTIFIER_KEY)).isEqualTo( + KeyValue.of(ObservationTenantContextEventListener.DEFAULT_TENANT_IDENTIFIER_KEY, tenantIdentifier)); } @Test void whenCustomValueIsUsedAsKey() { var tenantKey = "tenant.identifier"; - var tenantId = "acme"; + var tenantIdentifier = "acme"; var listener = new ObservationTenantContextEventListener(tenantKey, ObservationTenantContextEventListener.DEFAULT_CARDINALITY); var observationContext = new Observation.Context(); - var event = new TenantContextAttachedEvent(tenantId, this); + var event = new TenantContextAttachedEvent(tenantIdentifier, this); event.setObservationContext(observationContext); listener.onApplicationEvent(event); assertThat(observationContext.getHighCardinalityKeyValue(tenantKey)) - .isEqualTo(KeyValue.of(tenantKey, tenantId)); + .isEqualTo(KeyValue.of(tenantKey, tenantIdentifier)); } @Test void whenCustomCardinalityIsUsed() { - var tenantId = "acme"; + var tenantIdentifier = "acme"; var listener = new ObservationTenantContextEventListener( - ObservationTenantContextEventListener.DEFAULT_TENANT_ID_KEY, + ObservationTenantContextEventListener.DEFAULT_TENANT_IDENTIFIER_KEY, ObservationTenantContextEventListener.Cardinality.LOW); var observationContext = new Observation.Context(); - var event = new TenantContextAttachedEvent(tenantId, this); + var event = new TenantContextAttachedEvent(tenantIdentifier, this); event.setObservationContext(observationContext); listener.onApplicationEvent(event); assertThat(observationContext - .getLowCardinalityKeyValue(ObservationTenantContextEventListener.DEFAULT_TENANT_ID_KEY)) - .isEqualTo(KeyValue.of(ObservationTenantContextEventListener.DEFAULT_TENANT_ID_KEY, tenantId)); + .getLowCardinalityKeyValue(ObservationTenantContextEventListener.DEFAULT_TENANT_IDENTIFIER_KEY)).isEqualTo( + KeyValue.of(ObservationTenantContextEventListener.DEFAULT_TENANT_IDENTIFIER_KEY, tenantIdentifier)); } } diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolverTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolverTests.java index 85f6162..691a8ae 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolverTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/context/resolvers/FixedTenantResolverTests.java @@ -15,29 +15,29 @@ class FixedTenantResolverTests { @Test void whenNullCustomValueThenThrow() { assertThatThrownBy(() -> new FixedTenantResolver(null)).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantName cannot be empty"); + .hasMessageContaining("tenantIdentifier cannot be empty"); } @Test void whenEmptyCustomValueThenThrow() { assertThatThrownBy(() -> new FixedTenantResolver("")).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantName cannot be empty"); + .hasMessageContaining("tenantIdentifier cannot be empty"); } @Test void whenDefaultIsUsedAsFixedTenant() { - var expectedTenantId = "default"; + var expectedTenantIdentifier = "default"; var fixedTenantResolver = new FixedTenantResolver(); - var actualTenantId = fixedTenantResolver.resolveTenantId(this); - assertThat(actualTenantId).isEqualTo(expectedTenantId); + var actualTenantIdentifier = fixedTenantResolver.resolveTenantIdentifier(this); + assertThat(actualTenantIdentifier).isEqualTo(expectedTenantIdentifier); } @Test void whenCustomValueIsUsedAsFixedTenant() { - var expectedTenantId = "beans"; - var fixedTenantResolver = new FixedTenantResolver(expectedTenantId); - var actualTenantId = fixedTenantResolver.resolveTenantId(this); - assertThat(actualTenantId).isEqualTo(expectedTenantId); + var expectedTenantIdentifier = "beans"; + var fixedTenantResolver = new FixedTenantResolver(expectedTenantIdentifier); + var actualTenantIdentifier = fixedTenantResolver.resolveTenantIdentifier(this); + assertThat(actualTenantIdentifier).isEqualTo(expectedTenantIdentifier); } } diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/events/TenantEventTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/events/TenantEventTests.java index 0d18c9d..6b8ddf3 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/events/TenantEventTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/events/TenantEventTests.java @@ -12,15 +12,15 @@ class TenantEventTests { @Test - void whenNullTenantIdThenThrow() { + void whenNullTenantIdentifierThenThrow() { assertThatThrownBy(() -> new TestTenantEvent(null, this)).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantId cannot be empty"); + .hasMessageContaining("tenantIdentifier cannot be empty"); } @Test - void whenEmptyTenantIdThenThrow() { + void whenEmptyTenantIdentifierThenThrow() { assertThatThrownBy(() -> new TestTenantEvent("", this)).isInstanceOf(IllegalArgumentException.class) - .hasMessageContaining("tenantId cannot be empty"); + .hasMessageContaining("tenantIdentifier cannot be empty"); } @Test @@ -30,8 +30,8 @@ void whenNullSourceThenThrow() { static class TestTenantEvent extends TenantEvent { - public TestTenantEvent(String tenantId, Object source) { - super(tenantId, source); + public TestTenantEvent(String tenantIdentifier, Object source) { + super(tenantIdentifier, source); } } diff --git a/arconia-core/src/test/java/io/arconia/core/multitenancy/exceptions/TenantResolutionExceptionTests.java b/arconia-core/src/test/java/io/arconia/core/multitenancy/exceptions/TenantResolutionExceptionTests.java index 6793c21..05b5352 100644 --- a/arconia-core/src/test/java/io/arconia/core/multitenancy/exceptions/TenantResolutionExceptionTests.java +++ b/arconia-core/src/test/java/io/arconia/core/multitenancy/exceptions/TenantResolutionExceptionTests.java @@ -14,7 +14,7 @@ class TenantResolutionExceptionTests { @Test void whenDefaultMessage() { var exception = new TenantResolutionException(); - assertThat(exception).hasMessageContaining("A tenant must be specified for the current operation"); + assertThat(exception).hasMessageContaining("Error when trying to resolve the current tenant"); } @Test diff --git a/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/FixedTenantResolutionProperties.java b/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/FixedTenantResolutionProperties.java index d4c13ee..6bf8538 100644 --- a/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/FixedTenantResolutionProperties.java +++ b/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/FixedTenantResolutionProperties.java @@ -20,7 +20,7 @@ public class FixedTenantResolutionProperties { /** * Identifier of the fixed tenant to use in each context. */ - private String tenantId = "default"; + private String tenantIdentifier = "default"; public boolean isEnabled() { return enabled; @@ -30,12 +30,12 @@ public void setEnabled(boolean enabled) { this.enabled = enabled; } - public String getTenantId() { - return tenantId; + public String getTenantIdentifier() { + return tenantIdentifier; } - public void setTenantId(String tenantId) { - this.tenantId = tenantId; + public void setTenantIdentifier(String tenantIdentifier) { + this.tenantIdentifier = tenantIdentifier; } } diff --git a/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/MultitenancyCoreAutoConfiguration.java b/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/MultitenancyCoreAutoConfiguration.java index 206bde9..885100e 100644 --- a/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/MultitenancyCoreAutoConfiguration.java +++ b/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/core/multitenancy/MultitenancyCoreAutoConfiguration.java @@ -60,7 +60,7 @@ ObservationTenantContextEventListener observationTenantContextEventListener( @ConditionalOnProperty(prefix = FixedTenantResolutionProperties.CONFIG_PREFIX, value = "enabled", havingValue = "true") FixedTenantResolver fixedTenantResolver(FixedTenantResolutionProperties fixedTenantResolutionProperties) { - return new FixedTenantResolver(fixedTenantResolutionProperties.getTenantId()); + return new FixedTenantResolver(fixedTenantResolutionProperties.getTenantIdentifier()); } @Bean diff --git a/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/web/multitenancy/HttpTenantResolutionConfiguration.java b/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/web/multitenancy/HttpTenantResolutionConfiguration.java index f526568..311103a 100644 --- a/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/web/multitenancy/HttpTenantResolutionConfiguration.java +++ b/arconia-spring-boot-autoconfigure/src/main/java/io/arconia/autoconfigure/web/multitenancy/HttpTenantResolutionConfiguration.java @@ -32,7 +32,7 @@ public class HttpTenantResolutionConfiguration { @ConditionalOnProperty(prefix = FixedTenantResolutionProperties.CONFIG_PREFIX, value = "enabled", havingValue = "true") HttpRequestTenantResolver fixedHttpRequestTenantResolver(FixedTenantResolver fixedTenantResolver) { - return fixedTenantResolver::resolveTenantId; + return fixedTenantResolver::resolveTenantIdentifier; } @Bean diff --git a/arconia-spring-boot-autoconfigure/src/test/java/io/arconia/autoconfigure/web/multitenancy/MultitenancyWebAutoConfigurationTests.java b/arconia-spring-boot-autoconfigure/src/test/java/io/arconia/autoconfigure/web/multitenancy/MultitenancyWebAutoConfigurationTests.java index bffe902..1c51d5a 100644 --- a/arconia-spring-boot-autoconfigure/src/test/java/io/arconia/autoconfigure/web/multitenancy/MultitenancyWebAutoConfigurationTests.java +++ b/arconia-spring-boot-autoconfigure/src/test/java/io/arconia/autoconfigure/web/multitenancy/MultitenancyWebAutoConfigurationTests.java @@ -66,11 +66,11 @@ void httpRequestTenantResolverCookie() { void httpRequestTenantResolverFixed() { contextRunner .withPropertyValues("arconia.multitenancy.resolution.fixed.enabled=true", - "arconia.multitenancy.resolution.fixed.tenant-id=myTenant") + "arconia.multitenancy.resolution.fixed.tenant-identifier=myTenant") .run(context -> { assertThat(context).hasSingleBean(HttpRequestTenantResolver.class); var httpRequestTenantResolver = context.getBean(HttpRequestTenantResolver.class); - assertThat(httpRequestTenantResolver.resolveTenantId(new MockHttpServletRequest())) + assertThat(httpRequestTenantResolver.resolveTenantIdentifier(new MockHttpServletRequest())) .isEqualTo("myTenant"); }); } diff --git a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/filters/TenantContextFilter.java b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/filters/TenantContextFilter.java index b94213e..607914f 100644 --- a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/filters/TenantContextFilter.java +++ b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/filters/TenantContextFilter.java @@ -44,18 +44,18 @@ public TenantContextFilter(HttpRequestTenantResolver httpRequestTenantResolver, @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { - var tenantId = httpRequestTenantResolver.resolveTenantId(request); - if (!StringUtils.hasText(tenantId)) { + var tenantIdentifier = httpRequestTenantResolver.resolveTenantIdentifier(request); + if (!StringUtils.hasText(tenantIdentifier)) { throw new TenantResolutionException( "A tenant identifier must be specified for HTTP requests to: " + request.getRequestURI()); } - publishTenantContextAttachedEvent(tenantId, request); + publishTenantContextAttachedEvent(tenantIdentifier, request); try { filterChain.doFilter(request, response); } finally { - publishTenantContextClosedEvent(tenantId, request); + publishTenantContextClosedEvent(tenantIdentifier, request); } } @@ -64,15 +64,15 @@ protected boolean shouldNotFilter(HttpServletRequest request) { return tenantContextIgnorePathMatcher.matches(request); } - private void publishTenantContextAttachedEvent(String tenantId, HttpServletRequest request) { - var tenantContextAttachedEvent = new TenantContextAttachedEvent(tenantId, request); + private void publishTenantContextAttachedEvent(String tenantIdentifier, HttpServletRequest request) { + var tenantContextAttachedEvent = new TenantContextAttachedEvent(tenantIdentifier, request); var observationContext = ServerHttpObservationFilter.findObservationContext(request); observationContext.ifPresent(tenantContextAttachedEvent::setObservationContext); tenantEventPublisher.publishTenantEvent(tenantContextAttachedEvent); } - private void publishTenantContextClosedEvent(String tenantId, HttpServletRequest request) { - var tenantContextClosedEvent = new TenantContextClosedEvent(tenantId, request); + private void publishTenantContextClosedEvent(String tenantIdentifier, HttpServletRequest request) { + var tenantContextClosedEvent = new TenantContextClosedEvent(tenantIdentifier, request); tenantEventPublisher.publishTenantEvent(tenantContextClosedEvent); } diff --git a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolver.java b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolver.java index c1e614b..f87af99 100644 --- a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolver.java +++ b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolver.java @@ -30,7 +30,7 @@ public CookieTenantResolver(String tenantCookieName) { @Override @Nullable - public String resolveTenantId(HttpServletRequest request) { + public String resolveTenantIdentifier(HttpServletRequest request) { Assert.notNull(request, "request cannot be null"); return Arrays.stream(request.getCookies()) .filter(cookie -> cookie.getName().equals(tenantCookieName)) diff --git a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolver.java b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolver.java index 83c9d49..d0475f5 100644 --- a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolver.java +++ b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolver.java @@ -26,7 +26,7 @@ public HeaderTenantResolver(String tenantHeaderName) { @Override @Nullable - public String resolveTenantId(HttpServletRequest request) { + public String resolveTenantIdentifier(HttpServletRequest request) { Assert.notNull(request, "request cannot be null"); return request.getHeader(tenantHeaderName); } diff --git a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HttpRequestTenantResolver.java b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HttpRequestTenantResolver.java index 11363aa..28c0f3d 100644 --- a/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HttpRequestTenantResolver.java +++ b/arconia-web/src/main/java/io/arconia/web/multitenancy/context/resolvers/HttpRequestTenantResolver.java @@ -17,6 +17,6 @@ public interface HttpRequestTenantResolver extends TenantResolver (TenantContextAttachedEvent) event) - .matches(event -> event.getTenantId().equals(tenantId)) + .matches(event -> event.getTenantIdentifier().equals(tenantIdentifier)) .matches(event -> event.getSource().equals(request)) .matches(event -> event.getObservationContext() != null); assertThat(tenantEventArgumentCaptor.getAllValues().get(tenantEventArgumentCaptor.getAllValues().size() - 1)) .isExactlyInstanceOf(TenantContextClosedEvent.class) .extracting(event -> (TenantContextClosedEvent) event) - .matches(event -> event.getTenantId().equals(tenantId)) + .matches(event -> event.getTenantIdentifier().equals(tenantIdentifier)) .matches(event -> event.getSource().equals(request)); } diff --git a/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolverTests.java b/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolverTests.java index d5b3980..d6ce0ee 100644 --- a/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolverTests.java +++ b/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/CookieTenantResolverTests.java @@ -34,7 +34,7 @@ void whenDefaultCookieIsUsed() { var request = new MockHttpServletRequest(); request.setCookies(new Cookie(CookieTenantResolver.DEFAULT_COOKIE_NAME, expectedTenantId)); - var actualTenantId = cookieTenantResolver.resolveTenantId(request); + var actualTenantId = cookieTenantResolver.resolveTenantIdentifier(request); assertThat(actualTenantId).isEqualTo(expectedTenantId); } @@ -47,7 +47,7 @@ void whenCustomCookieIsUsed() { var request = new MockHttpServletRequest(); request.setCookies(new Cookie(cookieName, expectedTenantId)); - var actualTenantId = cookieTenantResolver.resolveTenantId(request); + var actualTenantId = cookieTenantResolver.resolveTenantIdentifier(request); assertThat(actualTenantId).isEqualTo(expectedTenantId); } @@ -56,7 +56,7 @@ void whenCustomCookieIsUsed() { void whenNullRequestThenThrow() { var cookieTenantResolver = new CookieTenantResolver(); - assertThatThrownBy(() -> cookieTenantResolver.resolveTenantId(null)) + assertThatThrownBy(() -> cookieTenantResolver.resolveTenantIdentifier(null)) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("request cannot be null"); } diff --git a/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolverTests.java b/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolverTests.java index 823b2bf..55de576 100644 --- a/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolverTests.java +++ b/arconia-web/src/test/java/io/arconia/web/multitenancy/context/resolvers/HeaderTenantResolverTests.java @@ -32,7 +32,7 @@ void whenDefaultHeaderIsUsed() { var request = new MockHttpServletRequest(); request.addHeader(HeaderTenantResolver.DEFAULT_HEADER_NAME, expectedTenantId); - var actualTenantId = headerTenantResolver.resolveTenantId(request); + var actualTenantId = headerTenantResolver.resolveTenantIdentifier(request); assertThat(actualTenantId).isEqualTo(expectedTenantId); } @@ -45,7 +45,7 @@ void whenCustomHeaderIsUsed() { var request = new MockHttpServletRequest(); request.addHeader(headerName, expectedTenantId); - var actualTenantId = headerTenantResolver.resolveTenantId(request); + var actualTenantId = headerTenantResolver.resolveTenantIdentifier(request); assertThat(actualTenantId).isEqualTo(expectedTenantId); } @@ -54,7 +54,7 @@ void whenCustomHeaderIsUsed() { void whenNullRequestThenThrow() { var headerTenantResolver = new HeaderTenantResolver(); - assertThatThrownBy(() -> headerTenantResolver.resolveTenantId(null)) + assertThatThrownBy(() -> headerTenantResolver.resolveTenantIdentifier(null)) .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("request cannot be null"); }