This is an automated email from the ASF dual-hosted git repository.
anovikov pushed a commit to branch ignite-19921
in repository https://gitbox.apache.org/repos/asf/ignite-extensions.git
The following commit(s) were added to refs/heads/ignite-19921 by this push:
new 13469165 IGNITE-19921 Add thin client support for Spring Session.
13469165 is described below
commit 13469165624ca93ef636ba1a0dc4e992d9a18fce
Author: Andrey Novikov <[email protected]>
AuthorDate: Thu Jul 6 15:30:55 2023 +0700
IGNITE-19921 Add thin client support for Spring Session.
---
.../sessions/IgniteHttpSessionConfiguration.java | 70 +++-
.../sessions/IgniteIndexedSessionRepository.java | 134 +++-----
.../spring/sessions/SpringSessionIgnite.java | 3 +-
.../spring/sessions/proxy/ClientSessionProxy.java | 67 ++++
.../spring/sessions/proxy/IgniteSessionProxy.java | 67 ++++
.../ignite/spring/sessions/proxy/SessionProxy.java | 102 ++++++
...bstractIgniteIndexedSessionRepositoryITest.java | 240 -------------
...AbstractIgniteIndexedSessionRepositoryTest.java | 212 ++++++++++++
...mbeddedIgniteIndexedSessionRepositoryTest.java} | 45 ++-
... IgniteClientIndexedSessionRepositoryTest.java} | 53 ++-
.../IgniteHttpSessionConfigurationTest.java | 194 +++++------
.../IgniteIndexedSessionRepositoryTest.java | 372 ++++++++++-----------
...{IgniteITestUtils.java => IgniteTestUtils.java} | 4 +-
13 files changed, 904 insertions(+), 659 deletions(-)
diff --git
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfiguration.java
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfiguration.java
index d08a7d18..eeb8167c 100644
---
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfiguration.java
+++
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfiguration.java
@@ -17,11 +17,18 @@ package org.apache.ignite.spring.sessions;
* limitations under the License.
*/
+import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
-
import org.apache.ignite.Ignite;
+import org.apache.ignite.cache.query.SqlFieldsQuery;
+import org.apache.ignite.client.IgniteClient;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.util.typedef.internal.U;
+import org.apache.ignite.spring.sessions.proxy.ClientSessionProxy;
+import org.apache.ignite.spring.sessions.proxy.IgniteSessionProxy;
+import org.apache.ignite.spring.sessions.proxy.SessionProxy;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
@@ -61,7 +68,7 @@ public class IgniteHttpSessionConfiguration extends
SpringHttpSessionConfigurati
private SaveMode saveMode = SaveMode.ON_SET_ATTRIBUTE;
/** */
- private Ignite ignite;
+ private SessionProxy sessions;
/** */
private ApplicationEventPublisher applicationEventPublisher;
@@ -113,13 +120,20 @@ public class IgniteHttpSessionConfiguration extends
SpringHttpSessionConfigurati
* @param ignite Ignite instance provider.
*/
@Autowired
- public void setIgnite(@SpringSessionIgnite ObjectProvider<Ignite>
springSessionIgnite,
- ObjectProvider<Ignite> ignite) {
- Ignite igniteToUse = springSessionIgnite.getIfAvailable();
- if (igniteToUse == null)
- igniteToUse = ignite.getObject();
+ public void setSessions(
+ @SpringSessionIgnite ObjectProvider<Object> springSessionIgnite,
+ ObjectProvider<Ignite> ignite,
+ ObjectProvider<IgniteClient> cli
+ ) {
+ Object connObj = springSessionIgnite.getIfAvailable();
+
+ if (connObj == null)
+ connObj = ignite.getIfAvailable();
- this.ignite = igniteToUse;
+ if (connObj == null)
+ connObj = cli.getIfAvailable();
+
+ this.sessions = createSessionProxy(connObj);
}
/**
@@ -150,7 +164,7 @@ public class IgniteHttpSessionConfiguration extends
SpringHttpSessionConfigurati
/**
* @param importMetadata Annotation metadata.
*/
- @Override @SuppressWarnings("deprecation") public void
setImportMetadata(AnnotationMetadata importMetadata) {
+ @Override public void setImportMetadata(AnnotationMetadata importMetadata)
{
Map<String, Object> attributeMap = importMetadata
.getAnnotationAttributes(EnableIgniteHttpSession.class.getName());
AnnotationAttributes attributes =
AnnotationAttributes.fromMap(attributeMap);
@@ -163,16 +177,46 @@ public class IgniteHttpSessionConfiguration extends
SpringHttpSessionConfigurati
this.saveMode = attributes.getEnum("saveMode");
}
+ /** */
+ private SessionProxy createSessionProxy(Object connObj) {
+ List<SqlFieldsQuery> initQueries = Arrays.asList(
+ new SqlFieldsQuery("CREATE TABLE IF NOT EXISTS IgniteSession (" +
+ " id VARCHAR PRIMARY KEY," +
+ " delegate OTHER," +
+ " principal VARCHAR" +
+ ") WITH
\"template=replicated,atomicity=atomic,value_type=org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository$IgniteSession,cache_name="
+ sessionMapName + "\""),
+ new SqlFieldsQuery("CREATE INDEX IF NOT EXISTS
ignitesession_principal_idx ON IgniteSession (principal);")
+ );
+
+ if (connObj instanceof IgniteEx) {
+ IgniteEx ignite = (IgniteEx)connObj;
+
+ for (SqlFieldsQuery qry : initQueries)
+ U.closeQuiet(ignite.context().query().querySqlFields(qry,
true));
+
+ return new IgniteSessionProxy(ignite.cache(sessionMapName));
+ }
+
+ if (connObj instanceof IgniteClient) {
+ IgniteClient cli = (IgniteClient)connObj;
+
+ for (SqlFieldsQuery qry : initQueries)
+ cli.query(qry).getAll();
+
+ return new ClientSessionProxy(cli.cache(sessionMapName));
+ }
+
+ throw new IllegalArgumentException(
+ "Object " + connObj + " can not be used to connect to the Ignite
cluster.");
+ }
+
/** */
private IgniteIndexedSessionRepository
createIgniteIndexedSessionRepository() {
- IgniteIndexedSessionRepository sessionRepository = new
IgniteIndexedSessionRepository(this.ignite);
+ IgniteIndexedSessionRepository sessionRepository = new
IgniteIndexedSessionRepository(this.sessions);
sessionRepository.setApplicationEventPublisher(this.applicationEventPublisher);
if (this.indexResolver != null)
sessionRepository.setIndexResolver(this.indexResolver);
- if (StringUtils.hasText(this.sessionMapName))
- sessionRepository.setSessionMapName(this.sessionMapName);
-
sessionRepository.setDefaultMaxInactiveInterval(this.maxInactiveIntervalInSeconds);
sessionRepository.setFlushMode(this.flushMode);
sessionRepository.setSaveMode(this.saveMode);
diff --git
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepository.java
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepository.java
index 0a679345..854f1600 100644
---
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepository.java
+++
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepository.java
@@ -26,7 +26,6 @@ import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;
-import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.cache.configuration.CacheEntryListenerConfiguration;
import javax.cache.configuration.Factory;
@@ -40,13 +39,9 @@ import javax.cache.event.CacheEntryRemovedListener;
import javax.cache.expiry.TouchedExpiryPolicy;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
-import org.apache.ignite.Ignite;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.cache.query.FieldsQueryCursor;
+import org.apache.ignite.cache.query.QueryCursor;
import org.apache.ignite.cache.query.SqlFieldsQuery;
-import org.apache.ignite.cache.query.annotations.QuerySqlField;
-import org.apache.ignite.configuration.CacheConfiguration;
-import org.apache.ignite.internal.GridDirectTransient;
+import org.apache.ignite.spring.sessions.proxy.SessionProxy;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.session.DelegatingIndexResolver;
import org.springframework.session.FindByIndexNameSessionRepository;
@@ -64,26 +59,21 @@ import org.springframework.util.Assert;
/**
* A {@link org.springframework.session.SessionRepository} implementation that
stores
- * sessions in Apache Ignite distributed {@link IgniteCache}.
+ * sessions in Apache Ignite distributed {@link SessionProxy}.
*
* <p>
* An example of how to create a new instance can be seen below:
- *
* <pre class="code">
* IgniteConfiguration config = new IgniteConfiguration();
- *
* // ... configure Ignite ...
- *
* Ignite ignite = IgnitionEx.start(config);
- *
* IgniteIndexedSessionRepository sessionRepository =
* new IgniteIndexedSessionRepository(ignite);
* </pre>
*
* In order to support finding sessions by principal name using
* {@link #findByIndexNameAndIndexValue(String, String)} method, custom
configuration of
- * {@link IgniteCache} supplied to this implementation is required.
- *
+ * {@link SessionProxy} supplied to this implementation is required.
* This implementation listens for events on the Ignite-backed
SessionRepository and
* translates those events into the corresponding Spring Session events.
Publish the
* Spring Session events with the given {@link ApplicationEventPublisher}.
@@ -111,9 +101,6 @@ public class IgniteIndexedSessionRepository
/** */
private static final Log logger =
LogFactory.getLog(IgniteIndexedSessionRepository.class);
- /** */
- private final Ignite ignite;
-
/** */
private ApplicationEventPublisher eventPublisher = (event) -> {
};
@@ -127,9 +114,6 @@ public class IgniteIndexedSessionRepository
/** */
private IndexResolver<Session> indexResolver = new
DelegatingIndexResolver<>(new PrincipalNameIndexResolver<>());
- /** */
- private String sessionMapName = DEFAULT_SESSION_MAP_NAME;
-
/** */
private FlushMode flushMode = FlushMode.ON_SAVE;
@@ -137,49 +121,41 @@ public class IgniteIndexedSessionRepository
private SaveMode saveMode = SaveMode.ON_SET_ATTRIBUTE;
/** */
- private IgniteCache<String, IgniteSession> sessions;
+ private final SessionProxy sessions;
/** */
private CacheEntryListenerConfiguration<String, IgniteSession>
listenerConfiguration;
/**
* Create a new {@link IgniteIndexedSessionRepository} instance.
- * @param ignite the {@link Ignite} instance to use for managing sessions
+ * @param sessions the {@link SessionProxy} instance to use for managing
sessions
*/
- public IgniteIndexedSessionRepository(Ignite ignite) {
- Assert.notNull(ignite, "Ignite must not be null");
- this.ignite = ignite;
- }
-
- /** */
- @PostConstruct
- public void init() {
- final CacheConfiguration<String, IgniteSession> configuration = new
CacheConfiguration<String, IgniteSession>(
- this.sessionMapName).setIndexedTypes(String.class,
IgniteSession.class);
-
- if (this.defaultMaxInactiveInterval != null)
- configuration.setExpiryPolicyFactory(TouchedExpiryPolicy
- .factoryOf(new
javax.cache.expiry.Duration(TimeUnit.SECONDS,
this.defaultMaxInactiveInterval)));
-
- this.sessions = this.ignite.getOrCreateCache(configuration);
-
+ public IgniteIndexedSessionRepository(SessionProxy sessions) {
+ Assert.notNull(sessions, "Session proxy must not be null");
+ this.sessions = sessions;
+
this.listenerConfiguration = new
CacheEntryListenerConfiguration<String, IgniteSession>() {
+ /** {@inheritDoc} */
@Override public Factory<CacheEntryListener<? super String, ?
super IgniteSession>> getCacheEntryListenerFactory() {
- return (Factory<CacheEntryListener<? super String, ? super
IgniteSession>>)() -> IgniteIndexedSessionRepository.this;
+ return () -> IgniteIndexedSessionRepository.this;
}
+ /** {@inheritDoc} */
@Override public boolean isOldValueRequired() {
return true;
}
+ /** {@inheritDoc} */
@Override public Factory<CacheEntryEventFilter<? super String, ?
super IgniteSession>> getCacheEntryEventFilterFactory() {
return null;
}
+ /** {@inheritDoc} */
@Override public boolean isSynchronous() {
return false;
}
};
+
this.sessions.registerCacheEntryListener(this.listenerConfiguration);
}
@@ -220,15 +196,6 @@ public class IgniteIndexedSessionRepository
this.indexResolver = indexResolver;
}
- /**
- * Set the name of map used to store sessions.
- * @param sessionMapName the session map name
- */
- public void setSessionMapName(String sessionMapName) {
- Assert.hasText(sessionMapName, "Map name must not be empty");
- this.sessionMapName = sessionMapName;
- }
-
/**
* Sets the flush mode. Default flush mode is {@link FlushMode#ON_SAVE}.
* @param flushMode the new flush mode
@@ -247,7 +214,7 @@ public class IgniteIndexedSessionRepository
this.saveMode = saveMode;
}
- /** */
+ /** {@inheritDoc} */
@Override public IgniteSession createSession() {
MapSession cached = new MapSession();
if (this.defaultMaxInactiveInterval != null)
@@ -258,7 +225,7 @@ public class IgniteIndexedSessionRepository
return session;
}
- /** */
+ /** {@inheritDoc} */
@Override public void save(IgniteSession session) {
if (session.isNew)
ttlSessions(session.getMaxInactiveInterval()).put(session.getId(),
session);
@@ -269,17 +236,15 @@ public class IgniteIndexedSessionRepository
ttlSessions(session.getMaxInactiveInterval()).put(session.getId(),
session);
}
else if (session.hasChanges()) {
- if (session.maxInactiveIntervalChanged) {
+ if (session.maxInactiveIntervalChanged)
ttlSessions(session.getMaxInactiveInterval()).replace(session.getId(), session);
- }
- else {
+ else
this.sessions.replace(session.getId(), session);
- }
}
session.clearChangeFlags();
}
- /** */
+ /** {@inheritDoc} */
@Override public IgniteSession findById(String id) {
IgniteSession saved = this.sessions.get(id);
if (saved == null)
@@ -293,17 +258,17 @@ public class IgniteIndexedSessionRepository
return saved;
}
- /** */
+ /** {@inheritDoc} */
@Override public void deleteById(String id) {
this.sessions.remove(id);
}
- /** */
+ /** {@inheritDoc} */
@Override public Map<String, IgniteSession>
findByIndexNameAndIndexValue(String indexName, String indexValue) {
if (!PRINCIPAL_NAME_INDEX_NAME.equals(indexName))
return Collections.emptyMap();
- final FieldsQueryCursor<List<?>> cursor = this.sessions
+ final QueryCursor<List<?>> cursor = this.sessions
.query(new SqlFieldsQuery("SELECT * FROM IgniteSession WHERE
principal='" + indexValue + "'"));
if (cursor == null)
@@ -314,16 +279,16 @@ public class IgniteIndexedSessionRepository
Map<String, IgniteSession> sessionMap = new HashMap<>(sessions.size());
sessions.forEach((List<?> res) -> {
- final MapSession session = (MapSession)res.get(0);
+ final MapSession session = (MapSession)res.get(1);
final IgniteSession value = new IgniteSession(session, false);
- value.principal = (String)res.get(1);
+ value.principal = (String)res.get(2);
sessionMap.put(session.getId(), value);
});
return sessionMap;
}
- /** */
+ /** {@inheritDoc} */
@Override public void onCreated(Iterable<CacheEntryEvent<? extends String,
? extends IgniteSession>> events)
throws CacheEntryListenerException {
events.forEach((event) -> {
@@ -337,7 +302,7 @@ public class IgniteIndexedSessionRepository
});
}
- /** */
+ /** {@inheritDoc} */
@Override public void onExpired(Iterable<CacheEntryEvent<? extends String,
? extends IgniteSession>> events)
throws CacheEntryListenerException {
events.forEach((event) -> {
@@ -348,7 +313,7 @@ public class IgniteIndexedSessionRepository
});
}
- /** */
+ /** {@inheritDoc} */
@Override public void onRemoved(Iterable<CacheEntryEvent<? extends String,
? extends IgniteSession>> events)
throws CacheEntryListenerException {
events.forEach((event) -> {
@@ -367,7 +332,7 @@ public class IgniteIndexedSessionRepository
* @param duration expiry duration for IgniteSession.
* @return cache with custom duration expiry policy.
*/
- private IgniteCache<String, IgniteSession> ttlSessions(Duration duration) {
+ private SessionProxy ttlSessions(Duration duration) {
return this.sessions.withExpiryPolicy(createPolicy(duration));
}
@@ -384,38 +349,29 @@ public class IgniteIndexedSessionRepository
* A custom implementation of {@link Session} that uses a {@link
MapSession} as the
* basis for its mapping. It keeps track if changes have been made since
last save.
*/
- final class IgniteSession implements Session {
-
+ public class IgniteSession implements Session {
/** */
- @QuerySqlField
private final MapSession delegate;
/** */
- @GridDirectTransient
private boolean isNew;
/** */
- @GridDirectTransient
private boolean sessionIdChanged;
/** */
- @GridDirectTransient
private boolean lastAccessedTimeChanged;
/** */
- @GridDirectTransient
private boolean maxInactiveIntervalChanged;
/** */
- @GridDirectTransient
private String originalId;
/** */
- @GridDirectTransient
private Map<String, Object> delta = new HashMap<>();
/** */
- @QuerySqlField(index = true)
private String principal;
/**
@@ -432,53 +388,53 @@ public class IgniteIndexedSessionRepository
}
- /** */
+ /** {@inheritDoc} */
@Override public void setLastAccessedTime(Instant lastAccessedTime) {
this.delegate.setLastAccessedTime(lastAccessedTime);
this.lastAccessedTimeChanged = true;
flushImmediateIfNecessary();
}
- /** */
+ /** {@inheritDoc} */
@Override public boolean isExpired() {
return this.delegate.isExpired();
}
- /** */
+ /** {@inheritDoc} */
@Override public Instant getCreationTime() {
return this.delegate.getCreationTime();
}
- /** */
+ /** {@inheritDoc} */
@Override public String getId() {
return this.delegate.getId();
}
- /** */
+ /** {@inheritDoc} */
@Override public String changeSessionId() {
String newSessionId = this.delegate.changeSessionId();
this.sessionIdChanged = true;
return newSessionId;
}
- /** */
+ /** {@inheritDoc} */
@Override public Instant getLastAccessedTime() {
return this.delegate.getLastAccessedTime();
}
- /** */
+ /** {@inheritDoc} */
@Override public void setMaxInactiveInterval(Duration interval) {
this.delegate.setMaxInactiveInterval(interval);
this.maxInactiveIntervalChanged = true;
flushImmediateIfNecessary();
}
- /** */
+ /** {@inheritDoc} */
@Override public Duration getMaxInactiveInterval() {
return this.delegate.getMaxInactiveInterval();
}
- /** */
+ /** {@inheritDoc} */
@Override public <T> T getAttribute(String attributeName) {
T attributeValue = this.delegate.getAttribute(attributeName);
if (attributeValue != null
@@ -488,12 +444,12 @@ public class IgniteIndexedSessionRepository
return attributeValue;
}
- /** */
+ /** {@inheritDoc} */
@Override public Set<String> getAttributeNames() {
return this.delegate.getAttributeNames();
}
- /** */
+ /** {@inheritDoc} */
@Override public void setAttribute(String attributeName, Object
attributeValue) {
this.delegate.setAttribute(attributeName, attributeValue);
this.delta.put(attributeName, attributeValue);
@@ -506,7 +462,7 @@ public class IgniteIndexedSessionRepository
flushImmediateIfNecessary();
}
- /** */
+ /** {@inheritDoc} */
@Override public void removeAttribute(String attributeName) {
setAttribute(attributeName, null);
}
@@ -536,7 +492,7 @@ public class IgniteIndexedSessionRepository
IgniteIndexedSessionRepository.this.save(this);
}
- /** */
+ /** {@inheritDoc} */
@Override public boolean equals(Object o) {
if (this == o)
return true;
@@ -548,7 +504,7 @@ public class IgniteIndexedSessionRepository
return this.delegate.equals(session.delegate);
}
- /** */
+ /** {@inheritDoc} */
@Override public int hashCode() {
return Objects.hash(this.delegate);
}
diff --git
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/SpringSessionIgnite.java
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/SpringSessionIgnite.java
index 82b51a43..f372556a 100644
---
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/SpringSessionIgnite.java
+++
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/SpringSessionIgnite.java
@@ -24,10 +24,11 @@ import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.apache.ignite.Ignite;
+import org.apache.ignite.client.IgniteClient;
import org.springframework.beans.factory.annotation.Qualifier;
/**
- * Qualifier annotation for a {@link Ignite} to be injected in
+ * Qualifier annotation for a {@link Ignite} or a {@link IgniteClient} to be
injected in
* {@link IgniteIndexedSessionRepository}.
*
*/
diff --git
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/ClientSessionProxy.java
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/ClientSessionProxy.java
new file mode 100644
index 00000000..c311f8b0
--- /dev/null
+++
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/ClientSessionProxy.java
@@ -0,0 +1,67 @@
+package org.apache.ignite.spring.sessions.proxy;
+
+import javax.cache.configuration.CacheEntryListenerConfiguration;
+import javax.cache.expiry.ExpiryPolicy;
+import org.apache.ignite.cache.query.Query;
+import org.apache.ignite.cache.query.QueryCursor;
+import org.apache.ignite.client.ClientCache;
+import
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.IgniteSession;
+
+/**
+ * Represents {@link SessionProxy} implementation that uses {@link
ClientCache} to perform session operations.
+ */
+public class ClientSessionProxy implements SessionProxy {
+ /** Client cache instance. */
+ private final ClientCache<String, IgniteSession> cache;
+
+ /**
+ * @param cache Client cache instance.
+ */
+ public ClientSessionProxy(ClientCache<String, IgniteSession> cache) {
+ this.cache = cache;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void registerCacheEntryListener(
+ CacheEntryListenerConfiguration<String, IgniteSession>
cacheEntryListenerConfiguration
+ ) {
+ cache.registerCacheEntryListener(cacheEntryListenerConfiguration);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void deregisterCacheEntryListener(
+ CacheEntryListenerConfiguration<String, IgniteSession>
cacheEntryListenerConfiguration
+ ) {
+ cache.deregisterCacheEntryListener(cacheEntryListenerConfiguration);
+ }
+
+ /** {@inheritDoc} */
+ @Override public SessionProxy withExpiryPolicy(ExpiryPolicy expirePlc) {
+ return new ClientSessionProxy(cache.withExpirePolicy(expirePlc));
+ }
+
+ /** {@inheritDoc} */
+ @Override public IgniteSession get(String key) {
+ return cache.get(key);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void put(String key, IgniteSession val) {
+ cache.put(key, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean remove(String key) {
+ return cache.remove(key);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean replace(String key, IgniteSession val) {
+ return cache.replace(key, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public <R> QueryCursor<R> query(Query<R> qry) {
+ return cache.query(qry);
+ }
+}
diff --git
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/IgniteSessionProxy.java
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/IgniteSessionProxy.java
new file mode 100644
index 00000000..51e1494d
--- /dev/null
+++
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/IgniteSessionProxy.java
@@ -0,0 +1,67 @@
+package org.apache.ignite.spring.sessions.proxy;
+
+import javax.cache.configuration.CacheEntryListenerConfiguration;
+import javax.cache.expiry.ExpiryPolicy;
+import org.apache.ignite.IgniteCache;
+import org.apache.ignite.cache.query.Query;
+import org.apache.ignite.cache.query.QueryCursor;
+import
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.IgniteSession;
+
+/**
+ * Represents {@link SessionProxy} implementation that uses {@link
IgniteCache} to perform session operations.
+ */
+public class IgniteSessionProxy implements SessionProxy {
+ /** Ignite cache instance. */
+ private final IgniteCache<String, IgniteSession> cache;
+
+ /**
+ * @param cache Ignite cache instance.
+ */
+ public IgniteSessionProxy(IgniteCache<String, IgniteSession> cache) {
+ this.cache = cache;
+ }
+
+ /** {@inheritDoc} */
+ @Override public void registerCacheEntryListener(
+ CacheEntryListenerConfiguration<String, IgniteSession>
cacheEntryListenerConfiguration
+ ) {
+ cache.registerCacheEntryListener(cacheEntryListenerConfiguration);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void deregisterCacheEntryListener(
+ CacheEntryListenerConfiguration<String, IgniteSession>
cacheEntryListenerConfiguration
+ ) {
+ cache.deregisterCacheEntryListener(cacheEntryListenerConfiguration);
+ }
+
+ /** {@inheritDoc} */
+ @Override public SessionProxy withExpiryPolicy(ExpiryPolicy expirePlc) {
+ return new IgniteSessionProxy(cache.withExpiryPolicy(expirePlc));
+ }
+
+ /** {@inheritDoc} */
+ @Override public IgniteSession get(String key) {
+ return cache.get(key);
+ }
+
+ /** {@inheritDoc} */
+ @Override public void put(String key, IgniteSession val) {
+ cache.put(key, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean remove(String key) {
+ return cache.remove(key);
+ }
+
+ /** {@inheritDoc} */
+ @Override public boolean replace(String key, IgniteSession val) {
+ return cache.replace(key, val);
+ }
+
+ /** {@inheritDoc} */
+ @Override public <R> QueryCursor<R> query(Query<R> qry) {
+ return cache.query(qry);
+ }
+}
diff --git
a/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/SessionProxy.java
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/SessionProxy.java
new file mode 100644
index 00000000..97c2f1ac
--- /dev/null
+++
b/modules/spring-session-ext/src/main/java/org/apache/ignite/spring/sessions/proxy/SessionProxy.java
@@ -0,0 +1,102 @@
+package org.apache.ignite.spring.sessions.proxy;
+
+import javax.cache.Cache;
+import javax.cache.CacheException;
+import javax.cache.configuration.CacheEntryListenerConfiguration;
+import javax.cache.event.CacheEntryListener;
+import javax.cache.expiry.ExpiryPolicy;
+import javax.cache.integration.CacheWriter;
+import org.apache.ignite.cache.query.Query;
+import org.apache.ignite.cache.query.QueryCursor;
+import org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository;
+
+/** Represents Ignite client-independent session operations. */
+public interface SessionProxy {
+ /**
+ * Registers a {@link CacheEntryListener}. The supplied {@link
CacheEntryListenerConfiguration} is used to
+ * instantiate a listener and apply it to those events specified in the
configuration.
+ *
+ * @param cacheEntryListenerConfiguration a factory and related
configuration for creating the listener.
+ * @throws IllegalArgumentException is the same
CacheEntryListenerConfiguration is used more than once or
+ * if some unsupported by thin client properties are set.
+ * @see CacheEntryListener
+ */
+ public void
registerCacheEntryListener(CacheEntryListenerConfiguration<String,
IgniteIndexedSessionRepository.IgniteSession> cacheEntryListenerConfiguration);
+
+ /**
+ * Deregisters a listener, using the {@link
CacheEntryListenerConfiguration} that was used to register it.
+ *
+ * @param cacheEntryListenerConfiguration the factory and related
configuration that was used to create the
+ * listener.
+ */
+ public void
deregisterCacheEntryListener(CacheEntryListenerConfiguration<String,
IgniteIndexedSessionRepository.IgniteSession> cacheEntryListenerConfiguration);
+
+ /**
+ * Returns cache with the specified expired policy set. This policy will
be used for each operation invoked on
+ * the returned cache.
+ *
+ * @param expirePlc Expire policy.
+ * @return Cache instance with the specified expiry policy set.
+ */
+ public SessionProxy withExpiryPolicy(ExpiryPolicy expirePlc);
+
+ /**
+ * Gets an entry from the cache.
+ *
+ * @param key the key whose associated value is to be returned
+ * @return the element, or null, if it does not exist.
+ */
+ public IgniteIndexedSessionRepository.IgniteSession get(String key);
+
+ /**
+ * Associates the specified value with the specified key in the cache.
+ *
+ * @param key key with which the specified value is to be associated
+ * @param val value to be associated with the specified key.
+ */
+ public void put(String key, IgniteIndexedSessionRepository.IgniteSession
val);
+
+ /**
+ * Removes the mapping for a key from this cache if it is present.
+ *
+ * @param key Key whose mapping is to be removed from the cache.
+ * @return <tt>false</tt> if there was no matching key.
+ */
+ public boolean remove(String key);
+
+ /**
+ * Atomically replaces the entry for a key only if currently mapped to some
+ * value.
+ * <p>
+ * This is equivalent to
+ * <pre><code>
+ * if (cache.containsKey(key)) {
+ * cache.put(key, value);
+ * return true;
+ * } else {
+ * return false;
+ * }</code></pre>
+ * except that the action is performed atomically.
+ *
+ * @param key the key with which the specified value is associated
+ * @param val the value to be associated with the specified key
+ * @return <tt>true</tt> if the value was replaced
+ * @throws NullPointerException if key is null or if value is null
+ * @throws CacheException if there is a problem during the replace
+ * @throws ClassCastException if the implementation is configured to
perform
+ * runtime-type-checking, and the key or
value
+ * types are incompatible with those that
have been
+ * configured for the {@link Cache}
+ * @see CacheWriter#write
+ */
+ public boolean replace(String key,
IgniteIndexedSessionRepository.IgniteSession val);
+
+ /**
+ * Execute SQL query and get cursor to iterate over results.
+ *
+ * @param <R> Type of query data.
+ * @param qry SQL query.
+ * @return Query result cursor.
+ */
+ public <R> QueryCursor<R> query(Query<R> qry);
+}
diff --git
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/AbstractIgniteIndexedSessionRepositoryITest.java
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/AbstractIgniteIndexedSessionRepositoryITest.java
deleted file mode 100644
index eb0e1f67..00000000
---
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/AbstractIgniteIndexedSessionRepositoryITest.java
+++ /dev/null
@@ -1,240 +0,0 @@
-package org.apache.ignite.spring.sessions;
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import java.time.Duration;
-import org.apache.ignite.Ignite;
-import org.apache.ignite.IgniteCache;
-import
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.IgniteSession;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import
org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
-import org.springframework.security.core.Authentication;
-import org.springframework.security.core.authority.AuthorityUtils;
-import org.springframework.security.core.context.SecurityContext;
-import org.springframework.security.core.context.SecurityContextHolder;
-import org.springframework.session.FindByIndexNameSessionRepository;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Base class for {@link IgniteIndexedSessionRepository} integration tests.
- */
-abstract class AbstractIgniteIndexedSessionRepositoryITest {
- /** */
- private static final String SPRING_SECURITY_CONTEXT =
"SPRING_SECURITY_CONTEXT";
-
- /** */
- @Autowired
- private Ignite ignite;
-
- /** */
- @Autowired
- private IgniteIndexedSessionRepository repository;
-
- /** */
- @Test
- void createAndDestroySession() {
- IgniteIndexedSessionRepository.IgniteSession sessionToSave =
this.repository.createSession();
- String sessionId = sessionToSave.getId();
-
- IgniteCache<String, IgniteIndexedSessionRepository.IgniteSession>
cache = this.ignite
-
.getOrCreateCache(IgniteIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME);
-
- assertThat(cache.size()).isEqualTo(0);
-
- this.repository.save(sessionToSave);
-
- assertThat(cache.size()).isEqualTo(1);
- assertThat(cache.get(sessionId)).isEqualTo(sessionToSave);
-
- this.repository.deleteById(sessionId);
-
- assertThat(cache.size()).isEqualTo(0);
- }
-
- /** */
- @Test
- void changeSessionIdWhenOnlyChangeId() {
- String attrName = "changeSessionId";
- String attrValue = "changeSessionId-value";
- IgniteSession toSave = this.repository.createSession();
- toSave.setAttribute(attrName, attrValue);
-
- this.repository.save(toSave);
-
- IgniteSession findById = this.repository.findById(toSave.getId());
-
-
assertThat(findById.<String>getAttribute(attrName)).isEqualTo(attrValue);
-
- String originalFindById = findById.getId();
- String changeSessionId = findById.changeSessionId();
-
- this.repository.save(findById);
-
- assertThat(this.repository.findById(originalFindById)).isNull();
-
- IgniteSession findByChangeSessionId =
this.repository.findById(changeSessionId);
-
-
assertThat(findByChangeSessionId.<String>getAttribute(attrName)).isEqualTo(attrValue);
-
- this.repository.deleteById(changeSessionId);
- }
-
- /** */
- @Test
- void changeSessionIdWhenChangeTwice() {
- IgniteSession toSave = this.repository.createSession();
-
- this.repository.save(toSave);
-
- String originalId = toSave.getId();
- String changeId1 = toSave.changeSessionId();
- String changeId2 = toSave.changeSessionId();
-
- this.repository.save(toSave);
-
- assertThat(this.repository.findById(originalId)).isNull();
- assertThat(this.repository.findById(changeId1)).isNull();
- assertThat(this.repository.findById(changeId2)).isNotNull();
-
- this.repository.deleteById(changeId2);
- }
-
- /** */
- @Test
- void changeSessionIdWhenSetAttributeOnChangedSession() {
- String attrName = "changeSessionId";
- String attrValue = "changeSessionId-value";
-
- IgniteSession toSave = this.repository.createSession();
-
- this.repository.save(toSave);
-
- IgniteSession findById = this.repository.findById(toSave.getId());
-
- findById.setAttribute(attrName, attrValue);
-
- String originalFindById = findById.getId();
- String changeSessionId = findById.changeSessionId();
-
- this.repository.save(findById);
-
- assertThat(this.repository.findById(originalFindById)).isNull();
-
- IgniteSession findByChangeSessionId =
this.repository.findById(changeSessionId);
-
-
assertThat(findByChangeSessionId.<String>getAttribute(attrName)).isEqualTo(attrValue);
-
- this.repository.deleteById(changeSessionId);
- }
-
- /** */
- @Test
- void changeSessionIdWhenHasNotSaved() {
- IgniteSession toSave = this.repository.createSession();
- String originalId = toSave.getId();
- toSave.changeSessionId();
-
- this.repository.save(toSave);
-
- assertThat(this.repository.findById(toSave.getId())).isNotNull();
- assertThat(this.repository.findById(originalId)).isNull();
-
- this.repository.deleteById(toSave.getId());
- }
-
- /** */
- @Test
- void attemptToUpdateSessionAfterDelete() {
- IgniteSession session = this.repository.createSession();
- String sessionId = session.getId();
- this.repository.save(session);
- session = this.repository.findById(sessionId);
- session.setAttribute("attributeName", "attributeValue");
- this.repository.deleteById(sessionId);
- this.repository.save(session);
-
- assertThat(this.repository.findById(sessionId)).isNull();
- }
-
- /** */
- @Test
- void expireSession() {
- IgniteSession session = this.repository.createSession();
- String sessionId = session.getId();
-
- session.setMaxInactiveInterval(Duration.ofNanos(0));
-
- this.repository.save(session);
- assertThat(this.repository.findById(sessionId)).isNull();
- }
-
- /** */
- @Test
- void createAndUpdateSession() {
- IgniteSession session = this.repository.createSession();
- String sessionId = session.getId();
-
- this.repository.save(session);
-
- session = this.repository.findById(sessionId);
- session.setAttribute("attributeName", "attributeValue");
-
- this.repository.save(session);
-
- assertThat(this.repository.findById(sessionId)).isNotNull();
- }
-
- /** */
- @Test
- void createSessionWithSecurityContextAndFindById() {
- IgniteSession session = this.repository.createSession();
- String sessionId = session.getId();
-
- Authentication authentication = new
UsernamePasswordAuthenticationToken("saves-" + System.currentTimeMillis(),
- "password", AuthorityUtils.createAuthorityList("ROLE_USER"));
- SecurityContext securityContext =
SecurityContextHolder.createEmptyContext();
- securityContext.setAuthentication(authentication);
- session.setAttribute(SPRING_SECURITY_CONTEXT, securityContext);
-
- this.repository.save(session);
-
- assertThat(this.repository.findById(sessionId)).isNotNull();
- }
-
- /** */
- @Test
- void createSessionWithSecurityContextAndFindByPrincipal() {
- IgniteSession session = this.repository.createSession();
-
- String username = "saves-" + System.currentTimeMillis();
- Authentication authentication = new
UsernamePasswordAuthenticationToken(username, "password",
- AuthorityUtils.createAuthorityList("ROLE_USER"));
- SecurityContext securityContext =
SecurityContextHolder.createEmptyContext();
- securityContext.setAuthentication(authentication);
- session.setAttribute(SPRING_SECURITY_CONTEXT, securityContext);
-
- this.repository.save(session);
-
- assertThat(this.repository
-
.findByIndexNameAndIndexValue(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME,
username))
- .hasSize(1);
- }
-
-}
diff --git
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/AbstractIgniteIndexedSessionRepositoryTest.java
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/AbstractIgniteIndexedSessionRepositoryTest.java
new file mode 100644
index 00000000..e721a017
--- /dev/null
+++
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/AbstractIgniteIndexedSessionRepositoryTest.java
@@ -0,0 +1,212 @@
+package org.apache.ignite.spring.sessions;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.time.Duration;
+import
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.IgniteSession;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import
org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.authority.AuthorityUtils;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.session.FindByIndexNameSessionRepository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Base class for {@link IgniteIndexedSessionRepository} integration tests.
+ */
+abstract class AbstractIgniteIndexedSessionRepositoryTest {
+ /** */
+ private static final String SPRING_SECURITY_CONTEXT =
"SPRING_SECURITY_CONTEXT";
+
+ /** */
+ @Autowired
+ protected IgniteIndexedSessionRepository repo;
+
+ /** */
+ @Test
+ void changeSessionIdWhenOnlyChangeId() {
+ String attrName = "changeSessionId";
+ String attrVal = "changeSessionId-value";
+ IgniteSession toSave = repo.createSession();
+ toSave.setAttribute(attrName, attrVal);
+
+ repo.save(toSave);
+
+ IgniteSession findById = repo.findById(toSave.getId());
+
+ assertThat(findById.<String>getAttribute(attrName)).isEqualTo(attrVal);
+
+ String originalFindById = findById.getId();
+ String changeSesId = findById.changeSessionId();
+
+ repo.save(findById);
+
+ assertThat(repo.findById(originalFindById)).isNull();
+
+ IgniteSession findByChangeSesId = repo.findById(changeSesId);
+
+
assertThat(findByChangeSesId.<String>getAttribute(attrName)).isEqualTo(attrVal);
+
+ repo.deleteById(changeSesId);
+ }
+
+ /** */
+ @Test
+ void changeSessionIdWhenChangeTwice() {
+ IgniteSession toSave = repo.createSession();
+
+ repo.save(toSave);
+
+ String originalId = toSave.getId();
+ String changeId1 = toSave.changeSessionId();
+ String changeId2 = toSave.changeSessionId();
+
+ repo.save(toSave);
+
+ assertThat(repo.findById(originalId)).isNull();
+ assertThat(repo.findById(changeId1)).isNull();
+ assertThat(repo.findById(changeId2)).isNotNull();
+
+ repo.deleteById(changeId2);
+ }
+
+ /** */
+ @Test
+ void changeSessionIdWhenSetAttributeOnChangedSession() {
+ String attrName = "changeSessionId";
+ String attrVal = "changeSessionId-value";
+
+ IgniteSession toSave = repo.createSession();
+
+ repo.save(toSave);
+
+ IgniteSession findById = repo.findById(toSave.getId());
+
+ findById.setAttribute(attrName, attrVal);
+
+ String originalFindById = findById.getId();
+ String changeSesId = findById.changeSessionId();
+
+ repo.save(findById);
+
+ assertThat(repo.findById(originalFindById)).isNull();
+
+ IgniteSession findByChangeSesId = repo.findById(changeSesId);
+
+
assertThat(findByChangeSesId.<String>getAttribute(attrName)).isEqualTo(attrVal);
+
+ repo.deleteById(changeSesId);
+ }
+
+ /** */
+ @Test
+ void changeSessionIdWhenHasNotSaved() {
+ IgniteSession toSave = repo.createSession();
+ String originalId = toSave.getId();
+ toSave.changeSessionId();
+
+ repo.save(toSave);
+
+ assertThat(repo.findById(toSave.getId())).isNotNull();
+ assertThat(repo.findById(originalId)).isNull();
+
+ repo.deleteById(toSave.getId());
+ }
+
+ /** */
+ @Test
+ void attemptToUpdateSessionAfterDelete() {
+ IgniteSession ses = repo.createSession();
+ String sesId = ses.getId();
+ repo.save(ses);
+ ses = repo.findById(sesId);
+ ses.setAttribute("attributeName", "attributeValue");
+ repo.deleteById(sesId);
+ repo.save(ses);
+
+ assertThat(repo.findById(sesId)).isNull();
+ }
+
+ /** */
+ @Test
+ void expireSession() {
+ IgniteSession ses = repo.createSession();
+ String sesId = ses.getId();
+
+ ses.setMaxInactiveInterval(Duration.ofNanos(0));
+
+ repo.save(ses);
+ assertThat(repo.findById(sesId)).isNull();
+ }
+
+ /** */
+ @Test
+ void createAndUpdateSession() {
+ IgniteSession ses = repo.createSession();
+ String sesId = ses.getId();
+
+ repo.save(ses);
+
+ ses = repo.findById(sesId);
+ ses.setAttribute("attributeName", "attributeValue");
+
+ repo.save(ses);
+
+ assertThat(repo.findById(sesId)).isNotNull();
+ }
+
+ /** */
+ @Test
+ void createSessionWithSecurityContextAndFindById() {
+ IgniteSession ses = repo.createSession();
+ String sesId = ses.getId();
+
+ Authentication authentication = new
UsernamePasswordAuthenticationToken("saves-" + System.currentTimeMillis(),
+ "password", AuthorityUtils.createAuthorityList("ROLE_USER"));
+ SecurityContext securityCtx =
SecurityContextHolder.createEmptyContext();
+ securityCtx.setAuthentication(authentication);
+ ses.setAttribute(SPRING_SECURITY_CONTEXT, securityCtx);
+
+ repo.save(ses);
+
+ assertThat(repo.findById(sesId)).isNotNull();
+ }
+
+ /** */
+ @Test
+ void createSessionWithSecurityContextAndFindByPrincipal() {
+ IgniteSession ses = repo.createSession();
+
+ String username = "saves-" + System.currentTimeMillis();
+ Authentication authentication = new
UsernamePasswordAuthenticationToken(username, "password",
+ AuthorityUtils.createAuthorityList("ROLE_USER"));
+ SecurityContext securityCtx =
SecurityContextHolder.createEmptyContext();
+ securityCtx.setAuthentication(authentication);
+ ses.setAttribute(SPRING_SECURITY_CONTEXT, securityCtx);
+
+ repo.save(ses);
+
+ assertThat(repo
+
.findByIndexNameAndIndexValue(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME,
username))
+ .hasSize(1);
+ }
+}
diff --git
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryITest.java
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryTest.java
similarity index 58%
copy from
modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryITest.java
copy to
modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryTest.java
index d0940aee..da45d84b 100644
---
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryITest.java
+++
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryTest.java
@@ -18,23 +18,35 @@ package org.apache.ignite.spring.sessions;
*/
import org.apache.ignite.Ignite;
+import org.apache.ignite.IgniteCache;
import org.apache.ignite.Ignition;
+import
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.IgniteSession;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
+import static
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
- * Integration tests for {@link IgniteIndexedSessionRepository} using embedded
topology.
+ * Integration tests for {@link IgniteIndexedSessionRepository} using embedded
Ignite instance.
*/
@ExtendWith(SpringExtension.class)
@ContextConfiguration
@WebAppConfiguration
-public class EmbeddedIgniteIndexedSessionRepositoryITest extends
AbstractIgniteIndexedSessionRepositoryITest {
+public class EmbeddedIgniteIndexedSessionRepositoryTest extends
AbstractIgniteIndexedSessionRepositoryTest {
+ /** */
+ @Autowired
+ private Ignite ignite;
+
/** */
@BeforeAll
static void setUpClass() {
@@ -47,17 +59,40 @@ public class EmbeddedIgniteIndexedSessionRepositoryITest
extends AbstractIgniteI
Ignition.stopAll(true);
}
+ /** */
+ @BeforeEach
+ void setUp() {
+ ignite.cache(DEFAULT_SESSION_MAP_NAME).clear();
+ }
+
/** */
@EnableIgniteHttpSession
@Configuration
static class IgniteSessionConfig {
-
/** */
@Bean
Ignite ignite() {
- return IgniteITestUtils.embeddedIgniteServer();
+ return IgniteTestUtils.embeddedIgniteServer();
}
-
}
+ /** */
+ @Test
+ void createAndDestroySession() {
+ IgniteSession sesToSave = repo.createSession();
+ String sesId = sesToSave.getId();
+
+ IgniteCache<String, IgniteSession> cache =
ignite.getOrCreateCache(DEFAULT_SESSION_MAP_NAME);
+
+ assertThat(cache.size()).isEqualTo(0);
+
+ repo.save(sesToSave);
+
+ assertThat(cache.size()).isEqualTo(1);
+ assertThat(cache.get(sesId)).isEqualTo(sesToSave);
+
+ repo.deleteById(sesId);
+
+ assertThat(cache.size()).isEqualTo(0);
+ }
}
diff --git
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryITest.java
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteClientIndexedSessionRepositoryTest.java
similarity index 52%
rename from
modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryITest.java
rename to
modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteClientIndexedSessionRepositoryTest.java
index d0940aee..11942838 100644
---
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/EmbeddedIgniteIndexedSessionRepositoryITest.java
+++
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteClientIndexedSessionRepositoryTest.java
@@ -17,28 +17,44 @@ package org.apache.ignite.spring.sessions;
* limitations under the License.
*/
-import org.apache.ignite.Ignite;
import org.apache.ignite.Ignition;
+import org.apache.ignite.client.ClientCache;
+import org.apache.ignite.client.IgniteClient;
+import org.apache.ignite.configuration.ClientConfiguration;
+import
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.IgniteSession;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.web.WebAppConfiguration;
+import static
org.apache.ignite.configuration.ClientConnectorConfiguration.DFLT_PORT;
+import static
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME;
+import static org.assertj.core.api.Assertions.assertThat;
+
/**
- * Integration tests for {@link IgniteIndexedSessionRepository} using embedded
topology.
+ * Integration tests for {@link IgniteIndexedSessionRepository} using embedded
Ignite instance.
*/
@ExtendWith(SpringExtension.class)
@ContextConfiguration
@WebAppConfiguration
-public class EmbeddedIgniteIndexedSessionRepositoryITest extends
AbstractIgniteIndexedSessionRepositoryITest {
+public class IgniteClientIndexedSessionRepositoryTest extends
AbstractIgniteIndexedSessionRepositoryTest {
+ /** */
+ @Autowired
+ private IgniteClient cli;
+
/** */
@BeforeAll
static void setUpClass() {
Ignition.stopAll(true);
+
+ IgniteTestUtils.embeddedIgniteServer();
}
/** */
@@ -47,17 +63,40 @@ public class EmbeddedIgniteIndexedSessionRepositoryITest
extends AbstractIgniteI
Ignition.stopAll(true);
}
+ /** */
+ @BeforeEach
+ void setUp() {
+ cli.cache(DEFAULT_SESSION_MAP_NAME).clear();
+ }
+
/** */
@EnableIgniteHttpSession
@Configuration
static class IgniteSessionConfig {
-
/** */
@Bean
- Ignite ignite() {
- return IgniteITestUtils.embeddedIgniteServer();
+ IgniteClient ignite() {
+ return Ignition.startClient(new
ClientConfiguration().setAddresses("127.0.0.1:" + DFLT_PORT));
}
-
}
+ /** */
+ @Test
+ void createAndDestroySession() {
+ IgniteSession sesToSave = repo.createSession();
+ String sesId = sesToSave.getId();
+
+ ClientCache<String, IgniteSession> cache =
cli.cache(DEFAULT_SESSION_MAP_NAME);
+
+ assertThat(cache.size()).isEqualTo(0);
+
+ repo.save(sesToSave);
+
+ assertThat(cache.size()).isEqualTo(1);
+ assertThat(cache.get(sesId)).isEqualTo(sesToSave);
+
+ repo.deleteById(sesId);
+
+ assertThat(cache.size()).isEqualTo(0);
+ }
}
diff --git
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfigurationTest.java
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfigurationTest.java
index ce0308c5..24bb0437 100644
---
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfigurationTest.java
+++
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteHttpSessionConfigurationTest.java
@@ -19,10 +19,13 @@ package org.apache.ignite.spring.sessions;
import org.apache.ignite.Ignite;
import org.apache.ignite.IgniteCache;
-import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.cache.query.FieldsQueryCursor;
+import org.apache.ignite.cache.query.SqlFieldsQuery;
+import org.apache.ignite.internal.GridKernalContext;
+import org.apache.ignite.internal.IgniteEx;
+import org.apache.ignite.internal.processors.query.GridQueryProcessor;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentMatchers;
import org.springframework.beans.factory.BeanCreationException;
import
org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
@@ -34,12 +37,14 @@ import org.springframework.session.IndexResolver;
import org.springframework.session.SaveMode;
import org.springframework.session.Session;
import org.springframework.session.config.SessionRepositoryCustomizer;
-import org.springframework.test.util.ReflectionTestUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
+import static org.springframework.test.util.ReflectionTestUtils.getField;
/**
* Tests for {@link IgniteHttpSessionConfiguration}.
@@ -52,13 +57,13 @@ public class IgniteHttpSessionConfigurationTest {
private static final int MAX_INACTIVE_INTERVAL_IN_SECONDS = 600;
/** */
- private AnnotationConfigApplicationContext context = new
AnnotationConfigApplicationContext();
+ private AnnotationConfigApplicationContext ctx = new
AnnotationConfigApplicationContext();
/** */
@AfterEach
void closeContext() {
- if (this.context != null)
- this.context.close();
+ if (this.ctx != null)
+ this.ctx.close();
}
/** */
@@ -73,7 +78,7 @@ public class IgniteHttpSessionConfigurationTest {
void defaultConfiguration() {
registerAndRefresh(DefaultConfiguration.class);
-
assertThat(this.context.getBean(IgniteIndexedSessionRepository.class)).isNotNull();
+
assertThat(this.ctx.getBean(IgniteIndexedSessionRepository.class)).isNotNull();
}
/** */
@@ -81,10 +86,10 @@ public class IgniteHttpSessionConfigurationTest {
void customTableName() {
registerAndRefresh(CustomSessionMapNameConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- IgniteHttpSessionConfiguration configuration =
this.context.getBean(IgniteHttpSessionConfiguration.class);
- assertThat(repository).isNotNull();
- assertThat(ReflectionTestUtils.getField(configuration,
"sessionMapName")).isEqualTo(MAP_NAME);
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ IgniteHttpSessionConfiguration configuration =
this.ctx.getBean(IgniteHttpSessionConfiguration.class);
+ assertThat(repo).isNotNull();
+ assertThat(getField(configuration,
"sessionMapName")).isEqualTo(MAP_NAME);
}
/** */
@@ -92,10 +97,10 @@ public class IgniteHttpSessionConfigurationTest {
void setCustomSessionMapName() {
registerAndRefresh(BaseConfiguration.class,
CustomSessionMapNameSetConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- IgniteHttpSessionConfiguration configuration =
this.context.getBean(IgniteHttpSessionConfiguration.class);
- assertThat(repository).isNotNull();
- assertThat(ReflectionTestUtils.getField(configuration,
"sessionMapName")).isEqualTo(MAP_NAME);
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ IgniteHttpSessionConfiguration configuration =
this.ctx.getBean(IgniteHttpSessionConfiguration.class);
+ assertThat(repo).isNotNull();
+ assertThat(getField(configuration,
"sessionMapName")).isEqualTo(MAP_NAME);
}
/** */
@@ -103,9 +108,9 @@ public class IgniteHttpSessionConfigurationTest {
void setCustomMaxInactiveIntervalInSeconds() {
registerAndRefresh(BaseConfiguration.class,
CustomMaxInactiveIntervalInSecondsSetConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- assertThat(repository).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository,
"defaultMaxInactiveInterval"))
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ assertThat(repo).isNotNull();
+ assertThat(getField(repo, "defaultMaxInactiveInterval"))
.isEqualTo(MAX_INACTIVE_INTERVAL_IN_SECONDS);
}
@@ -114,9 +119,9 @@ public class IgniteHttpSessionConfigurationTest {
void customMaxInactiveIntervalInSeconds() {
registerAndRefresh(CustomMaxInactiveIntervalInSecondsConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- assertThat(repository).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository,
"defaultMaxInactiveInterval"))
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ assertThat(repo).isNotNull();
+ assertThat(getField(repo, "defaultMaxInactiveInterval"))
.isEqualTo(MAX_INACTIVE_INTERVAL_IN_SECONDS);
}
@@ -125,9 +130,9 @@ public class IgniteHttpSessionConfigurationTest {
void customFlushImmediately() {
registerAndRefresh(CustomFlushImmediatelyConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- assertThat(repository).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository,
"flushMode")).isEqualTo(FlushMode.IMMEDIATE);
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ assertThat(repo).isNotNull();
+ assertThat(getField(repo, "flushMode")).isEqualTo(FlushMode.IMMEDIATE);
}
/** */
@@ -135,16 +140,16 @@ public class IgniteHttpSessionConfigurationTest {
void setCustomFlushImmediately() {
registerAndRefresh(BaseConfiguration.class,
CustomFlushImmediatelySetConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- assertThat(repository).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository,
"flushMode")).isEqualTo(FlushMode.IMMEDIATE);
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ assertThat(repo).isNotNull();
+ assertThat(getField(repo, "flushMode")).isEqualTo(FlushMode.IMMEDIATE);
}
/** */
@Test
void customSaveModeAnnotation() {
registerAndRefresh(BaseConfiguration.class,
CustomSaveModeExpressionAnnotationConfiguration.class);
-
assertThat(this.context.getBean(IgniteIndexedSessionRepository.class)).hasFieldOrPropertyWithValue("saveMode",
+
assertThat(this.ctx.getBean(IgniteIndexedSessionRepository.class)).hasFieldOrPropertyWithValue("saveMode",
SaveMode.ALWAYS);
}
@@ -152,7 +157,7 @@ public class IgniteHttpSessionConfigurationTest {
@Test
void customSaveModeSetter() {
registerAndRefresh(BaseConfiguration.class,
CustomSaveModeExpressionSetterConfiguration.class);
-
assertThat(this.context.getBean(IgniteIndexedSessionRepository.class)).hasFieldOrPropertyWithValue("saveMode",
+
assertThat(this.ctx.getBean(IgniteIndexedSessionRepository.class)).hasFieldOrPropertyWithValue("saveMode",
SaveMode.ALWAYS);
}
@@ -161,12 +166,12 @@ public class IgniteHttpSessionConfigurationTest {
void qualifiedIgniteConfiguration() {
registerAndRefresh(QualifiedIgniteConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- Ignite ignite = this.context.getBean("qualifiedIgnite", Ignite.class);
- assertThat(repository).isNotNull();
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ Ignite ignite = this.ctx.getBean("qualifiedIgnite", Ignite.class);
+ assertThat(repo).isNotNull();
assertThat(ignite).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository, "sessions"))
-
.isEqualTo(QualifiedIgniteConfiguration.qualifiedIgniteSessions);
+ assertThat(getField(getField(repo, "sessions"), "cache"))
+ .isEqualTo(QualifiedIgniteConfiguration.qualifiedIgniteSessions);
}
/** */
@@ -174,12 +179,12 @@ public class IgniteHttpSessionConfigurationTest {
void primaryIgniteConfiguration() {
registerAndRefresh(PrimaryIgniteConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- Ignite ignite = this.context.getBean("primaryIgnite", Ignite.class);
- assertThat(repository).isNotNull();
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ Ignite ignite = this.ctx.getBean("primaryIgnite", Ignite.class);
+ assertThat(repo).isNotNull();
assertThat(ignite).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository, "sessions"))
- .isEqualTo(PrimaryIgniteConfiguration.primaryIgniteSessions);
+ assertThat(getField(getField(repo, "sessions"), "cache"))
+ .isEqualTo(PrimaryIgniteConfiguration.primaryIgniteSessions);
}
/** */
@@ -187,12 +192,12 @@ public class IgniteHttpSessionConfigurationTest {
void qualifiedAndPrimaryIgniteConfiguration() {
registerAndRefresh(QualifiedAndPrimaryIgniteConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- Ignite ignite = this.context.getBean("qualifiedIgnite", Ignite.class);
- assertThat(repository).isNotNull();
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ Ignite ignite = this.ctx.getBean("qualifiedIgnite", Ignite.class);
+ assertThat(repo).isNotNull();
assertThat(ignite).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository, "sessions"))
-
.isEqualTo(QualifiedAndPrimaryIgniteConfiguration.qualifiedIgniteSessions);
+ assertThat(getField(getField(repo, "sessions"), "cache"))
+
.isEqualTo(QualifiedAndPrimaryIgniteConfiguration.qualifiedIgniteSessions);
}
/** */
@@ -200,72 +205,67 @@ public class IgniteHttpSessionConfigurationTest {
void namedIgniteConfiguration() {
registerAndRefresh(NamedIgniteConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
- Ignite ignite = this.context.getBean("ignite", Ignite.class);
- assertThat(repository).isNotNull();
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+ Ignite ignite = this.ctx.getBean("ignite", Ignite.class);
+ assertThat(repo).isNotNull();
assertThat(ignite).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository, "sessions"))
- .isEqualTo(NamedIgniteConfiguration.igniteSessions);
+ assertThat(getField(getField(repo, "sessions"), "cache"))
+ .isEqualTo(NamedIgniteConfiguration.igniteSessions);
}
/** */
@Test
void multipleIgniteConfiguration() {
assertThatExceptionOfType(BeanCreationException.class)
- .isThrownBy(() ->
registerAndRefresh(MultipleIgniteConfiguration.class))
- .withMessageContaining("expected single matching bean but
found 2");
+ .isThrownBy(() ->
registerAndRefresh(MultipleIgniteConfiguration.class))
+ .withMessageContaining("expected single matching bean but found
2");
}
/** */
@Test
void customIndexResolverConfiguration() {
registerAndRefresh(CustomIndexResolverConfiguration.class);
- IgniteIndexedSessionRepository repository =
this.context.getBean(IgniteIndexedSessionRepository.class);
+ IgniteIndexedSessionRepository repo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
@SuppressWarnings("unchecked")
- IndexResolver<Session> indexResolver =
this.context.getBean(IndexResolver.class);
- assertThat(repository).isNotNull();
- assertThat(indexResolver).isNotNull();
- assertThat(repository).hasFieldOrPropertyWithValue("indexResolver",
indexResolver);
+ IndexResolver<Session> idxResolver =
this.ctx.getBean(IndexResolver.class);
+ assertThat(repo).isNotNull();
+ assertThat(idxResolver).isNotNull();
+ assertThat(repo).hasFieldOrPropertyWithValue("indexResolver",
idxResolver);
}
/** */
@Test
void sessionRepositoryCustomizer() {
registerAndRefresh(SessionRepositoryCustomizerConfiguration.class);
- IgniteIndexedSessionRepository sessionRepository =
this.context.getBean(IgniteIndexedSessionRepository.class);
-
assertThat(sessionRepository).hasFieldOrPropertyWithValue("defaultMaxInactiveInterval",
+ IgniteIndexedSessionRepository sesRepo =
this.ctx.getBean(IgniteIndexedSessionRepository.class);
+
assertThat(sesRepo).hasFieldOrPropertyWithValue("defaultMaxInactiveInterval",
MAX_INACTIVE_INTERVAL_IN_SECONDS);
}
/** */
private void registerAndRefresh(Class<?>... annotatedClasses) {
- this.context.register(annotatedClasses);
- this.context.refresh();
+ this.ctx.register(annotatedClasses);
+ this.ctx.refresh();
}
/** */
@Configuration
@EnableIgniteHttpSession
static class NoIgniteConfiguration {
-
+ // No-op.
}
/** */
static class BaseConfiguration {
-
/** */
@SuppressWarnings("unchecked")
- static IgniteCache<Object, Object> defaultIgniteSessions =
mock(IgniteCache.class);
+ static IgniteCache<Object, Object> dfltIgniteSessions =
mock(IgniteCache.class);
/** */
@Bean
Ignite defaultIgnite() {
- Ignite ignite = mock(Ignite.class);
-
given(ignite.getOrCreateCache(ArgumentMatchers.<CacheConfiguration<Object,
Object>>any()))
- .willReturn(defaultIgniteSessions);
- return ignite;
+ return mockedIgnite(dfltIgniteSessions);
}
-
}
/** */
@@ -346,7 +346,6 @@ public class IgniteHttpSessionConfigurationTest {
@Configuration
@EnableIgniteHttpSession
static class QualifiedIgniteConfiguration extends BaseConfiguration {
-
/** */
@SuppressWarnings("unchecked")
static IgniteCache<Object, Object> qualifiedIgniteSessions =
mock(IgniteCache.class);
@@ -355,19 +354,14 @@ public class IgniteHttpSessionConfigurationTest {
@Bean
@SpringSessionIgnite
Ignite qualifiedIgnite() {
- Ignite ignite = mock(Ignite.class);
-
given(ignite.getOrCreateCache(ArgumentMatchers.<CacheConfiguration<Object,
Object>>any()))
- .willReturn(qualifiedIgniteSessions);
- return ignite;
+ return mockedIgnite(qualifiedIgniteSessions);
}
-
}
/** */
@Configuration
@EnableIgniteHttpSession
static class PrimaryIgniteConfiguration extends BaseConfiguration {
-
/** */
@SuppressWarnings("unchecked")
static IgniteCache<Object, Object> primaryIgniteSessions =
mock(IgniteCache.class);
@@ -376,19 +370,14 @@ public class IgniteHttpSessionConfigurationTest {
@Bean
@Primary
Ignite primaryIgnite() {
- Ignite ignite = mock(Ignite.class);
-
given(ignite.getOrCreateCache(ArgumentMatchers.<CacheConfiguration<Object,
Object>>any()))
- .willReturn(primaryIgniteSessions);
- return ignite;
+ return mockedIgnite(primaryIgniteSessions);
}
-
}
/** */
@Configuration
@EnableIgniteHttpSession
static class QualifiedAndPrimaryIgniteConfiguration extends
BaseConfiguration {
-
/** */
@SuppressWarnings("unchecked")
static IgniteCache<Object, Object> qualifiedIgniteSessions =
mock(IgniteCache.class);
@@ -401,29 +390,21 @@ public class IgniteHttpSessionConfigurationTest {
@Bean
@SpringSessionIgnite
Ignite qualifiedIgnite() {
- Ignite ignite = mock(Ignite.class);
-
given(ignite.getOrCreateCache(ArgumentMatchers.<CacheConfiguration<Object,
Object>>any()))
- .willReturn(qualifiedIgniteSessions);
- return ignite;
+ return mockedIgnite(qualifiedIgniteSessions);
}
/** */
@Bean
@Primary
Ignite primaryIgnite() {
- Ignite ignite = mock(Ignite.class);
-
given(ignite.getOrCreateCache(ArgumentMatchers.<CacheConfiguration<Object,
Object>>any()))
- .willReturn(primaryIgniteSessions);
- return ignite;
+ return mockedIgnite(primaryIgniteSessions);
}
-
}
/** */
@Configuration
@EnableIgniteHttpSession
static class NamedIgniteConfiguration extends BaseConfiguration {
-
/** */
@SuppressWarnings("unchecked")
static IgniteCache<Object, Object> igniteSessions =
mock(IgniteCache.class);
@@ -431,19 +412,14 @@ public class IgniteHttpSessionConfigurationTest {
/** */
@Bean
Ignite ignite() {
- Ignite ignite = mock(Ignite.class);
-
given(ignite.getOrCreateCache(ArgumentMatchers.<CacheConfiguration<Object,
Object>>any()))
- .willReturn(igniteSessions);
- return ignite;
+ return mockedIgnite(igniteSessions);
}
-
}
/** */
@Configuration
@EnableIgniteHttpSession
static class MultipleIgniteConfiguration extends BaseConfiguration {
-
/** */
@SuppressWarnings("unchecked")
static IgniteCache<Object, Object> secondaryIgniteSessions =
mock(IgniteCache.class);
@@ -451,31 +427,24 @@ public class IgniteHttpSessionConfigurationTest {
/** */
@Bean
Ignite secondaryIgnite() {
- Ignite ignite = mock(Ignite.class);
-
given(ignite.getOrCreateCache(ArgumentMatchers.<CacheConfiguration<Object,
Object>>any()))
- .willReturn(secondaryIgniteSessions);
- return ignite;
+ return mockedIgnite(secondaryIgniteSessions);
}
-
}
/** */
@EnableIgniteHttpSession
static class CustomIndexResolverConfiguration extends BaseConfiguration {
-
/** */
@Bean
@SuppressWarnings("unchecked")
IndexResolver<Session> indexResolver() {
return mock(IndexResolver.class);
}
-
}
/** */
@EnableIgniteHttpSession
static class SessionRepositoryCustomizerConfiguration extends
BaseConfiguration {
-
/** */
@Bean
@Order(0)
@@ -491,4 +460,19 @@ public class IgniteHttpSessionConfigurationTest {
.setDefaultMaxInactiveInterval(MAX_INACTIVE_INTERVAL_IN_SECONDS);
}
}
+
+ /**
+ * @param cache Cache instance.
+ */
+ private static Ignite mockedIgnite(IgniteCache<Object, Object> cache) {
+ IgniteEx ignite = mock(IgniteEx.class);
+ GridKernalContext ctx = mock(GridKernalContext.class);
+ GridQueryProcessor qryProc = mock(GridQueryProcessor.class);
+
+ given(qryProc.querySqlFields(any(SqlFieldsQuery.class),
anyBoolean())).willReturn(mock(FieldsQueryCursor.class));
+ given(ctx.query()).willReturn(qryProc);
+ given(ignite.context()).willReturn(ctx);
+ given(ignite.cache(any())).willReturn(cache);
+ return ignite;
+ }
}
diff --git
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepositoryTest.java
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepositoryTest.java
index 34cdd087..3853c778 100644
---
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepositoryTest.java
+++
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteIndexedSessionRepositoryTest.java
@@ -20,21 +20,19 @@ package org.apache.ignite.spring.sessions;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.UUID;
import java.util.concurrent.TimeUnit;
import javax.cache.expiry.TouchedExpiryPolicy;
-import org.apache.ignite.Ignite;
-import org.apache.ignite.IgniteCache;
-import org.apache.ignite.cache.query.FieldsQueryCursor;
-import org.apache.ignite.configuration.CacheConfiguration;
+import org.apache.ignite.cache.query.Query;
+import org.apache.ignite.cache.query.QueryCursor;
import
org.apache.ignite.spring.sessions.IgniteIndexedSessionRepository.IgniteSession;
+import org.apache.ignite.spring.sessions.proxy.SessionProxy;
import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentMatchers;
import
org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.authority.AuthorityUtils;
@@ -42,6 +40,7 @@ import
org.springframework.session.FindByIndexNameSessionRepository;
import org.springframework.session.FlushMode;
import org.springframework.session.MapSession;
+import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static
org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.mockito.ArgumentMatchers.any;
@@ -60,347 +59,339 @@ public class IgniteIndexedSessionRepositoryTest {
private static final String SPRING_SECURITY_CONTEXT =
"SPRING_SECURITY_CONTEXT";
/** */
- private final Ignite ignite = mock(Ignite.class);
+ private final SessionProxy sessions = mock(SessionProxy.class);
/** */
- @SuppressWarnings("unchecked")
- private final IgniteCache<String, IgniteSession> sessions =
mock(IgniteCache.class);
-
- /** */
- private IgniteIndexedSessionRepository repository;
+ private IgniteIndexedSessionRepository repo;
/** */
@BeforeEach
void setUp() {
- given(this.ignite.<String, IgniteSession>getOrCreateCache(
- ArgumentMatchers.<CacheConfiguration<String,
IgniteSession>>any())).willReturn(this.sessions);
-
given(this.sessions.withExpiryPolicy(ArgumentMatchers.any())).willReturn(this.sessions);
- this.repository = new IgniteIndexedSessionRepository(this.ignite);
- this.repository.init();
+ given(sessions.withExpiryPolicy(any())).willReturn(sessions);
+
+ repo = new IgniteIndexedSessionRepository(sessions);
}
/** */
@Test
void constructorNullIgnite() {
assertThatIllegalArgumentException().isThrownBy(() -> new
IgniteIndexedSessionRepository(null))
- .withMessage("Ignite must not be null");
+ .withMessage("Session proxy must not be null");
}
/** */
@Test
void setSaveModeNull() {
- assertThatIllegalArgumentException().isThrownBy(() ->
this.repository.setSaveMode(null))
+ assertThatIllegalArgumentException().isThrownBy(() ->
repo.setSaveMode(null))
.withMessage("saveMode must not be null");
}
/** */
@Test
void createSessionDefaultMaxInactiveInterval() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession session = this.repository.createSession();
+ IgniteSession ses = repo.createSession();
- assertThat(session.getMaxInactiveInterval()).isEqualTo(new
MapSession().getMaxInactiveInterval());
- verifyNoMoreInteractions(this.sessions);
+ assertThat(ses.getMaxInactiveInterval()).isEqualTo(new
MapSession().getMaxInactiveInterval());
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void createSessionCustomMaxInactiveInterval() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
int interval = 1;
- this.repository.setDefaultMaxInactiveInterval(interval);
+ repo.setDefaultMaxInactiveInterval(interval);
- IgniteSession session = this.repository.createSession();
+ IgniteSession ses = repo.createSession();
-
assertThat(session.getMaxInactiveInterval()).isEqualTo(Duration.ofSeconds(interval));
- verifyNoMoreInteractions(this.sessions);
+
assertThat(ses.getMaxInactiveInterval()).isEqualTo(Duration.ofSeconds(interval));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveNewFlushModeOnSave() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession session = this.repository.createSession();
- verifyNoMoreInteractions(this.sessions);
+ IgniteSession ses = repo.createSession();
+ verifyNoMoreInteractions(sessions);
- this.repository.save(session);
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveNewFlushModeImmediate() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- this.repository.setFlushMode(FlushMode.IMMEDIATE);
+ repo.setFlushMode(FlushMode.IMMEDIATE);
- IgniteSession session = this.repository.createSession();
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- verifyNoMoreInteractions(this.sessions);
+ IgniteSession ses = repo.createSession();
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUpdatedAttributeFlushModeOnSave() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession session = this.repository.createSession();
- session.setAttribute("testName", "testValue");
- verifyNoMoreInteractions(this.sessions);
+ IgniteSession ses = repo.createSession();
+ ses.setAttribute("testName", "testValue");
+ verifyNoMoreInteractions(sessions);
- this.repository.save(session);
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUpdatedAttributeFlushModeImmediate() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- this.repository.setFlushMode(FlushMode.IMMEDIATE);
+ repo.setFlushMode(FlushMode.IMMEDIATE);
- IgniteSession session = this.repository.createSession();
- session.setAttribute("testName", "testValue");
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions, times(1)).replace(eq(session.getId()),
eq(session));
+ IgniteSession ses = repo.createSession();
+ ses.setAttribute("testName", "testValue");
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions, times(1)).replace(eq(ses.getId()), eq(ses));
- this.repository.save(session);
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void removeAttributeFlushModeOnSave() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession session = this.repository.createSession();
- session.removeAttribute("testName");
- verifyNoMoreInteractions(this.sessions);
+ IgniteSession ses = repo.createSession();
+ ses.removeAttribute("testName");
+ verifyNoMoreInteractions(sessions);
- this.repository.save(session);
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void removeAttributeFlushModeImmediate() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- this.repository.setFlushMode(FlushMode.IMMEDIATE);
+ repo.setFlushMode(FlushMode.IMMEDIATE);
- IgniteSession session = this.repository.createSession();
- session.removeAttribute("testName");
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions, times(1)).replace(eq(session.getId()),
eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
+ IgniteSession ses = repo.createSession();
+ ses.removeAttribute("testName");
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions, times(1)).replace(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
- this.repository.save(session);
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUpdatedLastAccessedTimeFlushModeOnSave() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession session = this.repository.createSession();
- session.setLastAccessedTime(Instant.now());
- verifyNoMoreInteractions(this.sessions);
+ IgniteSession ses = repo.createSession();
+ ses.setLastAccessedTime(Instant.now());
+ verifyNoMoreInteractions(sessions);
- this.repository.save(session);
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUpdatedLastAccessedTimeFlushModeImmediate() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- this.repository.setFlushMode(FlushMode.IMMEDIATE);
+ repo.setFlushMode(FlushMode.IMMEDIATE);
- IgniteSession session = this.repository.createSession();
- session.setLastAccessedTime(Instant.now());
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions, times(1)).replace(eq(session.getId()),
eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
+ IgniteSession ses = repo.createSession();
+ ses.setLastAccessedTime(Instant.now());
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions, times(1)).replace(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
- this.repository.save(session);
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUpdatedMaxInactiveIntervalInSecondsFlushModeOnSave() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession session = this.repository.createSession();
- session.setMaxInactiveInterval(Duration.ofSeconds(1));
- verifyNoMoreInteractions(this.sessions);
+ IgniteSession ses = repo.createSession();
+ ses.setMaxInactiveInterval(Duration.ofSeconds(1));
+ verifyNoMoreInteractions(sessions);
- this.repository.save(session);
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUpdatedMaxInactiveIntervalInSecondsFlushModeImmediate() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- this.repository.setFlushMode(FlushMode.IMMEDIATE);
+ repo.setFlushMode(FlushMode.IMMEDIATE);
- IgniteSession session = this.repository.createSession();
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
- String sessionId = session.getId();
- session.setMaxInactiveInterval(Duration.ofSeconds(1));
- verify(this.sessions, times(1)).put(eq(sessionId), eq(session));
- verify(this.sessions, times(1)).replace(eq(sessionId), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
+ IgniteSession ses = repo.createSession();
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
+ String sesId = ses.getId();
+ ses.setMaxInactiveInterval(Duration.ofSeconds(1));
+ verify(sessions, times(1)).put(eq(sesId), eq(ses));
+ verify(sessions, times(1)).replace(eq(sesId), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
- this.repository.save(session);
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUnchangedFlushModeOnSave() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession session = this.repository.createSession();
- this.repository.save(session);
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
+ IgniteSession ses = repo.createSession();
+ repo.save(ses);
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
- this.repository.save(session);
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void saveUnchangedFlushModeImmediate() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- this.repository.setFlushMode(FlushMode.IMMEDIATE);
+ repo.setFlushMode(FlushMode.IMMEDIATE);
- IgniteSession session = this.repository.createSession();
- verify(this.sessions, times(1)).put(eq(session.getId()), eq(session));
- verify(this.sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(session)));
+ IgniteSession ses = repo.createSession();
+ verify(sessions, times(1)).put(eq(ses.getId()), eq(ses));
+ verify(sessions,
times(1)).withExpiryPolicy(eq(createExpiryPolicy(ses)));
- this.repository.save(session);
- verifyNoMoreInteractions(this.sessions);
+ repo.save(ses);
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void getSessionNotFound() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- String sessionId = "testSessionId";
+ String sesId = "testSessionId";
- IgniteSession session = this.repository.findById(sessionId);
+ IgniteSession ses = repo.findById(sesId);
- assertThat(session).isNull();
- verify(this.sessions, times(1)).get(eq(sessionId));
- verifyNoMoreInteractions(this.sessions);
+ assertThat(ses).isNull();
+ verify(sessions, times(1)).get(eq(sesId));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void getSessionExpired() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession expired = this.repository.new IgniteSession(new
MapSession(), true);
+ IgniteSession expired = repo.new IgniteSession(new MapSession(), true);
expired.setLastAccessedTime(Instant.now().minusSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS
+ 1));
- given(this.sessions.get(eq(expired.getId()))).willReturn(expired);
+ given(sessions.get(eq(expired.getId()))).willReturn(expired);
- IgniteSession session = this.repository.findById(expired.getId());
+ IgniteSession ses = repo.findById(expired.getId());
- assertThat(session).isNull();
- verify(this.sessions, times(1)).get(eq(expired.getId()));
- verify(this.sessions, times(1)).remove(eq(expired.getId()));
- verifyNoMoreInteractions(this.sessions);
+ assertThat(ses).isNull();
+ verify(sessions, times(1)).get(eq(expired.getId()));
+ verify(sessions, times(1)).remove(eq(expired.getId()));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void getSessionFound() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- IgniteSession saved = this.repository.new IgniteSession(new
MapSession(), true);
+ IgniteSession saved = repo.new IgniteSession(new MapSession(), true);
saved.setAttribute("savedName", "savedValue");
- given(this.sessions.get(eq(saved.getId()))).willReturn(saved);
+ given(sessions.get(eq(saved.getId()))).willReturn(saved);
- IgniteSession session = this.repository.findById(saved.getId());
+ IgniteSession ses = repo.findById(saved.getId());
- assertThat(session.getId()).isEqualTo(saved.getId());
-
assertThat(session.<String>getAttribute("savedName")).isEqualTo("savedValue");
- verify(this.sessions, times(1)).get(eq(saved.getId()));
- verifyNoMoreInteractions(this.sessions);
+ assertThat(ses.getId()).isEqualTo(saved.getId());
+
assertThat(ses.<String>getAttribute("savedName")).isEqualTo("savedValue");
+ verify(sessions, times(1)).get(eq(saved.getId()));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void delete() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- String sessionId = "testSessionId";
+ String sesId = "testSessionId";
- this.repository.deleteById(sessionId);
+ repo.deleteById(sesId);
- verify(this.sessions, times(1)).remove(eq(sessionId));
- verifyNoMoreInteractions(this.sessions);
+ verify(sessions, times(1)).remove(eq(sesId));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void findByIndexNameAndIndexValueUnknownIndexName() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
- String indexValue = "testIndexValue";
+ String idxVal = "testIndexValue";
- Map<String, IgniteSession> sessions =
this.repository.findByIndexNameAndIndexValue("testIndexName", indexValue);
+ Map<String, IgniteSession> sesMap =
repo.findByIndexNameAndIndexValue("testIndexName", idxVal);
- assertThat(sessions).isEmpty();
- verifyNoMoreInteractions(this.sessions);
+ assertThat(sesMap).isEmpty();
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void findByIndexNameAndIndexValuePrincipalIndexNameNotFound() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
String principal = "username";
- Map<String, IgniteSession> sessions = this.repository
+ Map<String, IgniteSession> sesMap = repo
.findByIndexNameAndIndexValue(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME,
principal);
- verify(this.sessions, times(1)).query(ArgumentMatchers
- .argThat((argument) -> ("SELECT * FROM IgniteSession WHERE
principal='" + principal + "'")
- .equals(argument.getSql())));
+ assertThat(sesMap).isEmpty();
- assertThat(sessions).isEmpty();
- verifyNoMoreInteractions(this.sessions);
+ verify(sessions, times(1)).query(any(Query.class));
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void findByIndexNameAndIndexValuePrincipalIndexNameFound() {
- verify(this.sessions,
times(1)).registerCacheEntryListener(ArgumentMatchers.any());
+ verify(sessions, times(1)).registerCacheEntryListener(any());
String principal = "username";
Authentication authentication = new
UsernamePasswordAuthenticationToken(principal, "notused",
@@ -410,66 +401,53 @@ public class IgniteIndexedSessionRepositoryTest {
final MapSession ses1 = new MapSession();
ses1.setAttribute(SPRING_SECURITY_CONTEXT, authentication);
- IgniteSession saved1 = this.repository.new IgniteSession(ses1, true);
- saved.add(Arrays.asList(ses1, authentication.getPrincipal()));
+ saved.add(asList(UUID.randomUUID().toString(), ses1,
authentication.getPrincipal()));
+
final MapSession ses2 = new MapSession();
ses2.setAttribute(SPRING_SECURITY_CONTEXT, authentication);
- IgniteSession saved2 = this.repository.new IgniteSession(ses2, true);
- saved.add(Arrays.asList(ses2, authentication.getPrincipal()));
-
- given(this.sessions.query(ArgumentMatchers.any())).willReturn(new
FieldsQueryCursor<List<?>>() {
- /** */
- @Override public String getFieldName(int idx) {
- return null;
- }
-
- /** */
- @Override public int getColumnsCount() {
- return 2;
- }
+ saved.add(asList(UUID.randomUUID().toString(), ses2,
authentication.getPrincipal()));
- /** */
+ given(sessions.<List<?>>query(any())).willReturn(new
QueryCursor<List<?>>() {
+ /** {@inheritDoc} */
@Override public List<List<?>> getAll() {
return (List)saved;
}
- /** */
+ /** {@inheritDoc} */
@Override public void close() {
}
- /** */
+ /** {@inheritDoc} */
@NotNull
@Override public Iterator<List<?>> iterator() {
return (Iterator)saved.iterator();
}
});
- Map<String, IgniteSession> sessions = this.repository
+ Map<String, IgniteSession> sesMap = repo
.findByIndexNameAndIndexValue(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME,
principal);
- assertThat(sessions).hasSize(2);
- verify(this.sessions, times(1)).query(any());
- verifyNoMoreInteractions(this.sessions);
+ assertThat(sesMap).hasSize(2);
+ verify(sessions, times(1)).query(any());
+ verifyNoMoreInteractions(sessions);
}
/** */
@Test
void getAttributeNamesAndRemove() {
- IgniteSession session = this.repository.createSession();
- session.setAttribute("attribute1", "value1");
- session.setAttribute("attribute2", "value2");
+ IgniteSession ses = repo.createSession();
+ ses.setAttribute("attribute1", "value1");
+ ses.setAttribute("attribute2", "value2");
- for (String attributeName : session.getAttributeNames()) {
- session.removeAttribute(attributeName);
- }
+ for (String attributeName : ses.getAttributeNames())
+ ses.removeAttribute(attributeName);
- assertThat(session.getAttributeNames()).isEmpty();
+ assertThat(ses.getAttributeNames()).isEmpty();
}
/** */
- private static TouchedExpiryPolicy createExpiryPolicy(IgniteSession
session) {
+ private static TouchedExpiryPolicy createExpiryPolicy(IgniteSession ses) {
return new TouchedExpiryPolicy(
- new javax.cache.expiry.Duration(TimeUnit.SECONDS,
session.getMaxInactiveInterval().getSeconds()));
+ new javax.cache.expiry.Duration(TimeUnit.SECONDS,
ses.getMaxInactiveInterval().getSeconds()));
}
-
}
diff --git
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteITestUtils.java
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteTestUtils.java
similarity index 94%
rename from
modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteITestUtils.java
rename to
modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteTestUtils.java
index b70fd142..c77f2ecc 100644
---
a/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteITestUtils.java
+++
b/modules/spring-session-ext/src/test/java/org/apache/ignite/spring/sessions/IgniteTestUtils.java
@@ -23,9 +23,9 @@ import org.apache.ignite.Ignition;
/**
* Utility class for Ignite integration tests.
*/
-final class IgniteITestUtils {
+final class IgniteTestUtils {
/** */
- private IgniteITestUtils() {
+ private IgniteTestUtils() {
}
/**
