findByIndexNameAndIndexValue(String indexName, String indexValue) {
+ Assert.notNull(this.sessionIdGenerator, "sessionIdGenerator not initialized.");
+ return Optional.ofNullable(this.mongoSessionConverter.getQueryForIndex(indexName, indexValue))
+ .map((query) -> this.mongoOperations.find(query, Document.class, this.collectionName))
+ .orElse(Collections.emptyList())
+ .stream()
+ .map((dbSession) -> MongoSessionUtils.convertToSession(this.mongoSessionConverter, dbSession))
+ .peek((session) -> session.setSessionIdGenerator(this.sessionIdGenerator))
+ .collect(Collectors.toMap(MongoSession::getId, (mapSession) -> mapSession));
+ }
+
+ @Override
+ public void deleteById(String id) {
+
+ Optional.ofNullable(findSession(id)).ifPresent((document) -> {
+ MongoSession session = MongoSessionUtils.convertToSession(this.mongoSessionConverter, document);
+ if (session != null) {
+ publishEvent(new SessionDeletedEvent(this, session));
+ }
+ this.mongoOperations.remove(document, this.collectionName);
+ });
+ }
+
+ @Override
+ public void afterPropertiesSet() {
+
+ IndexOperations indexOperations = this.mongoOperations.indexOps(this.collectionName);
+ this.mongoSessionConverter.ensureIndexes(indexOperations);
+ }
+
+ @Nullable private Document findSession(String id) {
+ return this.mongoOperations.findById(id, Document.class, this.collectionName);
+ }
+
+ @Override
+ public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
+ this.eventPublisher = eventPublisher;
+ }
+
+ private void publishEvent(ApplicationEvent event) {
+ if (this.eventPublisher == null) {
+ logger.error("Error publishing " + event + ". No event publisher set.");
+ } else {
+ try {
+ this.eventPublisher.publishEvent(event);
+ } catch (Throwable ex) {
+ logger.error("Error publishing " + event + ".", ex);
+ }
+ }
+ }
+
+ /**
+ * Set the maximum inactive interval in seconds between requests before newly created sessions will be invalidated.
+ * A negative time indicates that the session will never time out. The default is 30 minutes.
+ *
+ * @param defaultMaxInactiveInterval the default maxInactiveInterval
+ */
+ public void setDefaultMaxInactiveInterval(Duration defaultMaxInactiveInterval) {
+ Assert.notNull(defaultMaxInactiveInterval, "defaultMaxInactiveInterval must not be null");
+ this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;
+ }
+
+ /**
+ * Set the maximum inactive interval in seconds between requests before newly created sessions will be invalidated.
+ * A negative time indicates that the session will never time out. The default is 1800 (30 minutes).
+ *
+ * @param defaultMaxInactiveInterval the default maxInactiveInterval in seconds
+ * @deprecated since 3.0.0, in favor of {@link #setDefaultMaxInactiveInterval(Duration)}
+ */
+ @Deprecated(since = "3.0.0")
+ @SuppressWarnings("InlineMeSuggester")
+ public void setMaxInactiveIntervalInSeconds(Integer defaultMaxInactiveInterval) {
+ setDefaultMaxInactiveInterval(Duration.ofSeconds(defaultMaxInactiveInterval));
+ }
+
+ public void setCollectionName(final String collectionName) {
+ this.collectionName = collectionName;
+ }
+
+ public void setMongoSessionConverter(final AbstractMongoSessionConverter mongoSessionConverter) {
+ this.mongoSessionConverter = mongoSessionConverter;
+ }
+
+ /**
+ * Set the {@link SessionIdGenerator} to use to generate session ids.
+ *
+ * @param sessionIdGenerator the {@link SessionIdGenerator} to use
+ * @since 3.2
+ */
+ public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
+ Assert.notNull(sessionIdGenerator, "sessionIdGenerator cannot be null");
+ this.sessionIdGenerator = sessionIdGenerator;
+ }
+}
diff --git a/src/main/java/org/mongodb/spring/session/MongoSession.java b/src/main/java/org/mongodb/spring/session/MongoSession.java
new file mode 100644
index 0000000..4ce9dbb
--- /dev/null
+++ b/src/main/java/org/mongodb/spring/session/MongoSession.java
@@ -0,0 +1,255 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.springframework.lang.Nullable;
+import org.springframework.session.MapSession;
+import org.springframework.session.Session;
+import org.springframework.session.SessionIdGenerator;
+import org.springframework.session.UuidSessionIdGenerator;
+import org.springframework.util.Assert;
+
+/**
+ * Session object providing additional information about the datetime of expiration.
+ *
+ * @author Jakub Kubrynski
+ * @author Greg Turnquist
+ * @since 1.2
+ */
+public final class MongoSession implements Session {
+
+ /**
+ * Mongo doesn't support {@literal dot} in field names. We replace it with a unicode character from the Private Use
+ * Area.
+ *
+ * NOTE: This was originally stored in unicode format. Delomboking the code caused it to get converted to another
+ * encoding, which isn't supported on all systems, so we migrated back to unicode. The same character is being
+ * represented ensuring binary compatibility. See https://www.compart.com/en/unicode/U+F607
+ */
+ private static final char DOT_COVER_CHAR = '\uF607';
+
+ private String id;
+
+ private final String originalSessionId;
+
+ private long createdMillis = System.currentTimeMillis();
+
+ private long accessedMillis;
+
+ private long intervalSeconds;
+
+ private Date expireAt;
+
+ private final Map attrs = new HashMap<>();
+
+ private transient SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
+
+ /**
+ * Constructs a new instance using the provided session id.
+ *
+ * @param sessionId the session id to use
+ * @since 3.2
+ */
+ public MongoSession(String sessionId) {
+ this(sessionId, MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
+ }
+
+ public MongoSession() {
+ this(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
+ }
+
+ public MongoSession(long maxInactiveIntervalInSeconds) {
+ this(UuidSessionIdGenerator.getInstance().generate(), maxInactiveIntervalInSeconds);
+ }
+
+ public MongoSession(String id, long maxInactiveIntervalInSeconds) {
+ this.id = id;
+ this.originalSessionId = id;
+ this.intervalSeconds = maxInactiveIntervalInSeconds;
+ setLastAccessedTime(Instant.ofEpochMilli(this.createdMillis));
+ }
+
+ /**
+ * Constructs a new instance using the provided {@link SessionIdGenerator}.
+ *
+ * @param sessionIdGenerator the {@link SessionIdGenerator} to use
+ * @since 3.2
+ */
+ public MongoSession(SessionIdGenerator sessionIdGenerator) {
+ this(sessionIdGenerator.generate(), MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
+ this.sessionIdGenerator = sessionIdGenerator;
+ }
+
+ /**
+ * Constructs a new instance using the provided {@link SessionIdGenerator} and max inactive interval.
+ *
+ * @param sessionIdGenerator the {@link SessionIdGenerator} to use
+ * @param maxInactiveIntervalInSeconds the max inactive interval in seconds
+ * @since 3.2
+ */
+ MongoSession(SessionIdGenerator sessionIdGenerator, long maxInactiveIntervalInSeconds) {
+ this(sessionIdGenerator.generate(), maxInactiveIntervalInSeconds);
+ this.sessionIdGenerator = sessionIdGenerator;
+ }
+
+ static String coverDot(String attributeName) {
+ return attributeName.replace('.', DOT_COVER_CHAR);
+ }
+
+ static String uncoverDot(String attributeName) {
+ return attributeName.replace(DOT_COVER_CHAR, '.');
+ }
+
+ @Override
+ public String changeSessionId() {
+
+ String changedId = this.sessionIdGenerator.generate();
+ this.id = changedId;
+ return changedId;
+ }
+
+ @Override
+ @Nullable @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
+ public T getAttribute(String attributeName) {
+ return (T) this.attrs.get(coverDot(attributeName));
+ }
+
+ @Override
+ public Set getAttributeNames() {
+ return this.attrs.keySet().stream().map(MongoSession::uncoverDot).collect(Collectors.toSet());
+ }
+
+ @Override
+ public void setAttribute(String attributeName, Object attributeValue) {
+
+ if (attributeValue == null) {
+ removeAttribute(coverDot(attributeName));
+ } else {
+ this.attrs.put(coverDot(attributeName), attributeValue);
+ }
+ }
+
+ @Override
+ public void removeAttribute(String attributeName) {
+ this.attrs.remove(coverDot(attributeName));
+ }
+
+ @Override
+ public Instant getCreationTime() {
+ return Instant.ofEpochMilli(this.createdMillis);
+ }
+
+ void setCreationTime(long created) {
+ this.createdMillis = created;
+ }
+
+ @Override
+ public Instant getLastAccessedTime() {
+ return Instant.ofEpochMilli(this.accessedMillis);
+ }
+
+ @Override
+ public void setLastAccessedTime(Instant lastAccessedTime) {
+ this.accessedMillis = lastAccessedTime.toEpochMilli();
+ this.expireAt = Date.from(lastAccessedTime.plus(Duration.ofSeconds(this.intervalSeconds)));
+ }
+
+ @Override
+ public Duration getMaxInactiveInterval() {
+ return Duration.ofSeconds(this.intervalSeconds);
+ }
+
+ @Override
+ public void setMaxInactiveInterval(Duration interval) {
+ this.intervalSeconds = interval.toSeconds();
+ }
+
+ @Override
+ public boolean isExpired() {
+ return this.intervalSeconds >= 0 && Instant.now().isAfter(expireAt.toInstant());
+ }
+
+ @Override
+ public boolean equals(Object o) {
+
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ MongoSession that = (MongoSession) o;
+ return Objects.equals(this.id, that.id);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(this.id);
+ }
+
+ @Override
+ public String getId() {
+ return this.id;
+ }
+
+ Date getExpireAt() {
+ return this.expireAt;
+ }
+
+ void setExpireAt(final Date expireAt) {
+ this.expireAt = expireAt;
+ }
+
+ boolean hasChangedSessionId() {
+ return !getId().equals(this.originalSessionId);
+ }
+
+ String getOriginalSessionId() {
+ return this.originalSessionId;
+ }
+
+ /**
+ * Sets the session id.
+ *
+ * @param id the id to set
+ * @since 3.2
+ */
+ void setId(String id) {
+ this.id = id;
+ }
+
+ /**
+ * Sets the {@link SessionIdGenerator} to use.
+ *
+ * @param sessionIdGenerator the {@link SessionIdGenerator} to use
+ * @since 3.2
+ */
+ void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
+ Assert.notNull(sessionIdGenerator, "sessionIdGenerator cannot be null");
+ this.sessionIdGenerator = sessionIdGenerator;
+ }
+}
diff --git a/src/main/java/org/mongodb/spring/session/MongoSessionUtils.java b/src/main/java/org/mongodb/spring/session/MongoSessionUtils.java
new file mode 100644
index 0000000..415dc4b
--- /dev/null
+++ b/src/main/java/org/mongodb/spring/session/MongoSessionUtils.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session;
+
+import com.mongodb.ConnectionString;
+import com.mongodb.DBObject;
+import org.bson.Document;
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.lang.Nullable;
+
+/**
+ * Utility for MongoSession.
+ *
+ * @author Greg Turnquist
+ */
+final class MongoSessionUtils {
+
+ private static final String DEFAULT_URI = "mongodb://localhost:27017";
+ private static final String URI_SYSTEM_PROPERTY_NAME = "org.mongodb.test.uri";
+ public static final String DEFAULT_DATABASE_NAME = "MongoSpringSessionTest";
+
+ private MongoSessionUtils() {}
+
+ @Nullable static DBObject convertToDBObject(AbstractMongoSessionConverter mongoSessionConverter, MongoSession session) {
+
+ return (DBObject) mongoSessionConverter.convert(
+ session, TypeDescriptor.valueOf(MongoSession.class), TypeDescriptor.valueOf(DBObject.class));
+ }
+
+ @Nullable static MongoSession convertToSession(AbstractMongoSessionConverter mongoSessionConverter, Document session) {
+
+ return (MongoSession) mongoSessionConverter.convert(
+ session, TypeDescriptor.valueOf(Document.class), TypeDescriptor.valueOf(MongoSession.class));
+ }
+
+ static ConnectionString getConnectionString() {
+ String connectionString = System.getProperty(URI_SYSTEM_PROPERTY_NAME, DEFAULT_URI);
+ return new ConnectionString(connectionString);
+ }
+}
diff --git a/src/main/java/org/mongodb/spring/session/ReactiveMongoSessionRepository.java b/src/main/java/org/mongodb/spring/session/ReactiveMongoSessionRepository.java
new file mode 100644
index 0000000..e52cad8
--- /dev/null
+++ b/src/main/java/org/mongodb/spring/session/ReactiveMongoSessionRepository.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session;
+
+import java.time.Duration;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.bson.Document;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.context.ApplicationEvent;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.ApplicationEventPublisherAware;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.ReactiveMongoOperations;
+import org.springframework.data.mongodb.core.index.IndexOperations;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
+import org.springframework.session.MapSession;
+import org.springframework.session.ReactiveSessionRepository;
+import org.springframework.session.SessionIdGenerator;
+import org.springframework.session.UuidSessionIdGenerator;
+import org.springframework.session.events.SessionCreatedEvent;
+import org.springframework.session.events.SessionDeletedEvent;
+import org.springframework.util.Assert;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+
+/**
+ * A {@link ReactiveSessionRepository} implementation that uses Spring Data MongoDB.
+ *
+ * @author Greg Turnquist
+ * @author Vedran Pavic
+ * @since 2.2.0
+ */
+public class ReactiveMongoSessionRepository
+ implements ReactiveSessionRepository, ApplicationEventPublisherAware, InitializingBean {
+
+ /**
+ * The default time period in seconds in which a session will expire.
+ *
+ * @deprecated since 3.0.0 in favor of {@link MapSession#DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS}
+ */
+ @Deprecated
+ public static final int DEFAULT_INACTIVE_INTERVAL = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
+
+ /** The default collection name for storing session. */
+ public static final String DEFAULT_COLLECTION_NAME = "sessions";
+
+ private static final Log logger = LogFactory.getLog(ReactiveMongoSessionRepository.class);
+
+ private final ReactiveMongoOperations mongoOperations;
+
+ private Duration defaultMaxInactiveInterval = Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
+
+ private String collectionName = DEFAULT_COLLECTION_NAME;
+
+ private AbstractMongoSessionConverter mongoSessionConverter =
+ new JdkMongoSessionConverter(this.defaultMaxInactiveInterval);
+
+ @Nullable private MongoOperations blockingMongoOperations;
+
+ @Nullable private ApplicationEventPublisher eventPublisher;
+
+ private SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
+
+ public ReactiveMongoSessionRepository(ReactiveMongoOperations mongoOperations) {
+ this.mongoOperations = mongoOperations;
+ }
+
+ /**
+ * Creates a new {@link MongoSession} that is capable of being persisted by this {@link ReactiveSessionRepository}.
+ *
+ * This allows optimizations and customizations in how the {@link MongoSession} is persisted. For example, the
+ * implementation returned might keep track of the changes ensuring that only the delta needs to be persisted on a
+ * save.
+ *
+ * @return a new {@link MongoSession} that is capable of being persisted by this {@link ReactiveSessionRepository}
+ */
+ @Override
+ public Mono createSession() {
+ // @formatter:off
+ return Mono.fromSupplier(() -> this.sessionIdGenerator.generate())
+ .zipWith(Mono.just(this.defaultMaxInactiveInterval.toSeconds()))
+ .map((tuple) -> new MongoSession(tuple.getT1(), tuple.getT2()))
+ .doOnNext((mongoSession) -> mongoSession.setMaxInactiveInterval(this.defaultMaxInactiveInterval))
+ .doOnNext((mongoSession) -> mongoSession.setSessionIdGenerator(this.sessionIdGenerator))
+ .doOnNext((mongoSession) -> publishEvent(new SessionCreatedEvent(this, mongoSession)))
+ .switchIfEmpty(Mono.just(new MongoSession(this.sessionIdGenerator)))
+ .subscribeOn(Schedulers.boundedElastic())
+ .publishOn(Schedulers.parallel());
+ // @formatter:on
+ }
+
+ @Override
+ public Mono save(MongoSession session) {
+
+ return Mono //
+ .justOrEmpty(MongoSessionUtils.convertToDBObject(this.mongoSessionConverter, session)) //
+ .flatMap((dbObject) -> {
+ if (session.hasChangedSessionId()) {
+
+ return this.mongoOperations
+ .remove(
+ Query.query(Criteria.where("_id").is(session.getOriginalSessionId())),
+ this.collectionName) //
+ .then(this.mongoOperations.save(dbObject, this.collectionName));
+ } else {
+
+ return this.mongoOperations.save(dbObject, this.collectionName);
+ }
+ }) //
+ .then();
+ }
+
+ @Override
+ public Mono findById(String id) {
+
+ return findSession(id) //
+ .map((document) -> MongoSessionUtils.convertToSession(this.mongoSessionConverter, document)) //
+ .filter((mongoSession) -> !mongoSession.isExpired()) //
+ .doOnNext((mongoSession) -> mongoSession.setSessionIdGenerator(this.sessionIdGenerator))
+ .switchIfEmpty(Mono.defer(() -> this.deleteById(id).then(Mono.empty())));
+ }
+
+ @Override
+ public Mono deleteById(String id) {
+
+ return findSession(id) //
+ .flatMap((document) -> this.mongoOperations
+ .remove(document, this.collectionName) //
+ .then(Mono.just(document))) //
+ .map((document) -> MongoSessionUtils.convertToSession(this.mongoSessionConverter, document)) //
+ .doOnNext((mongoSession) -> publishEvent(new SessionDeletedEvent(this, mongoSession))) //
+ .then();
+ }
+
+ /**
+ * Do not use {@link org.springframework.data.mongodb.core.index.ReactiveIndexOperations} to ensure indexes exist.
+ * Instead, get a blocking {@link IndexOperations} and use that instead, if possible.
+ */
+ @Override
+ public void afterPropertiesSet() {
+
+ if (this.blockingMongoOperations != null) {
+
+ IndexOperations indexOperations = this.blockingMongoOperations.indexOps(this.collectionName);
+ this.mongoSessionConverter.ensureIndexes(indexOperations);
+ }
+ }
+
+ private Mono findSession(String id) {
+ return this.mongoOperations.findById(id, Document.class, this.collectionName);
+ }
+
+ @Override
+ public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
+ this.eventPublisher = eventPublisher;
+ }
+
+ private void publishEvent(ApplicationEvent event) {
+ if (this.eventPublisher == null) {
+ logger.error("Error publishing " + event + ". No event publisher set.");
+ } else {
+ try {
+ this.eventPublisher.publishEvent(event);
+ } catch (Throwable ex) {
+ logger.error("Error publishing " + event + ".", ex);
+ }
+ }
+ }
+
+ /**
+ * Set the maximum inactive interval in seconds between requests before newly created sessions will be invalidated.
+ * A negative time indicates that the session will never time out. The default is 30 minutes.
+ *
+ * @param defaultMaxInactiveInterval the default maxInactiveInterval
+ */
+ public void setDefaultMaxInactiveInterval(Duration defaultMaxInactiveInterval) {
+ Assert.notNull(defaultMaxInactiveInterval, "defaultMaxInactiveInterval must not be null");
+ this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;
+ }
+
+ /**
+ * Set the maximum inactive interval in seconds between requests before newly created sessions will be invalidated.
+ * A negative time indicates that the session will never time out. The default is 1800 (30 minutes).
+ *
+ * @param defaultMaxInactiveInterval the default maxInactiveInterval in seconds
+ * @deprecated since 3.0.0, in favor of {@link #setDefaultMaxInactiveInterval(Duration)}
+ */
+ @Deprecated(since = "3.0.0")
+ @SuppressWarnings("InlineMeSuggester")
+ public void setMaxInactiveIntervalInSeconds(Integer defaultMaxInactiveInterval) {
+ setDefaultMaxInactiveInterval(Duration.ofSeconds(defaultMaxInactiveInterval));
+ }
+
+ public String getCollectionName() {
+ return this.collectionName;
+ }
+
+ public void setCollectionName(final String collectionName) {
+ this.collectionName = collectionName;
+ }
+
+ public void setMongoSessionConverter(final AbstractMongoSessionConverter mongoSessionConverter) {
+ this.mongoSessionConverter = mongoSessionConverter;
+ }
+
+ public void setBlockingMongoOperations(final MongoOperations blockingMongoOperations) {
+ this.blockingMongoOperations = blockingMongoOperations;
+ }
+
+ public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
+ Assert.notNull(sessionIdGenerator, "sessionIdGenerator cannot be null");
+ this.sessionIdGenerator = sessionIdGenerator;
+ }
+}
diff --git a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/http/EnableMongoHttpSession.java b/src/main/java/org/mongodb/spring/session/config/annotation/web/http/EnableMongoHttpSession.java
similarity index 64%
rename from src/main/java/org/springframework/session/data/mongo/config/annotation/web/http/EnableMongoHttpSession.java
rename to src/main/java/org/mongodb/spring/session/config/annotation/web/http/EnableMongoHttpSession.java
index a314592..35f1ed7 100644
--- a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/http/EnableMongoHttpSession.java
+++ b/src/main/java/org/mongodb/spring/session/config/annotation/web/http/EnableMongoHttpSession.java
@@ -1,11 +1,12 @@
/*
+ * Copyright 2025-present MongoDB, Inc.
* Copyright 2014-present the original author or authors.
*
* Licensed 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
*
- * https://www.apache.org/licenses/LICENSE-2.0
+ * 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,
@@ -14,23 +15,21 @@
* limitations under the License.
*/
-package org.springframework.session.data.mongo.config.annotation.web.http;
+package org.mongodb.spring.session.config.annotation.web.http;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-
+import org.mongodb.spring.session.MongoIndexedSessionRepository;
import org.springframework.context.annotation.Import;
import org.springframework.session.MapSession;
-import org.springframework.session.data.mongo.MongoIndexedSessionRepository;
/**
- * Add this annotation to a {@code @Configuration} class to expose the
- * SessionRepositoryFilter as a bean named "springSessionRepositoryFilter" and backed by
- * Mongo. Use {@code collectionName} to change default name of the collection used to
- * store sessions.
+ * Add this annotation to a {@code @Configuration} class to expose the SessionRepositoryFilter as a bean named
+ * "springSessionRepositoryFilter" and backed by Mongo. Use {@code collectionName} to change default name of the
+ * collection used to store sessions.
*
*
*
@@ -55,16 +54,17 @@
@Import(MongoHttpSessionConfiguration.class)
public @interface EnableMongoHttpSession {
- /**
- * The maximum time a session will be kept if it is inactive.
- * @return default max inactive interval in seconds
- */
- int maxInactiveIntervalInSeconds() default MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
-
- /**
- * The collection name to use.
- * @return name of the collection to store session
- */
- String collectionName() default MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME;
+ /**
+ * The maximum time a session will be kept if it is inactive.
+ *
+ * @return default max inactive interval in seconds
+ */
+ int maxInactiveIntervalInSeconds() default MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
+ /**
+ * The collection name to use.
+ *
+ * @return name of the collection to store session
+ */
+ String collectionName() default MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME;
}
diff --git a/src/main/java/org/mongodb/spring/session/config/annotation/web/http/MongoHttpSessionConfiguration.java b/src/main/java/org/mongodb/spring/session/config/annotation/web/http/MongoHttpSessionConfiguration.java
new file mode 100644
index 0000000..041f472
--- /dev/null
+++ b/src/main/java/org/mongodb/spring/session/config/annotation/web/http/MongoHttpSessionConfiguration.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session.config.annotation.web.http;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.mongodb.spring.session.AbstractMongoSessionConverter;
+import org.mongodb.spring.session.JdkMongoSessionConverter;
+import org.mongodb.spring.session.MongoIndexedSessionRepository;
+import org.springframework.beans.factory.BeanClassLoaderAware;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.EmbeddedValueResolverAware;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.ImportAware;
+import org.springframework.core.annotation.AnnotationAttributes;
+import org.springframework.core.serializer.support.DeserializingConverter;
+import org.springframework.core.serializer.support.SerializingConverter;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.lang.Nullable;
+import org.springframework.session.IndexResolver;
+import org.springframework.session.MapSession;
+import org.springframework.session.Session;
+import org.springframework.session.SessionIdGenerator;
+import org.springframework.session.UuidSessionIdGenerator;
+import org.springframework.session.config.SessionRepositoryCustomizer;
+import org.springframework.session.config.annotation.web.http.SpringHttpSessionConfiguration;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+import org.springframework.util.StringValueResolver;
+
+/**
+ * Configuration class registering {@code MongoSessionRepository} bean. To import this configuration use
+ * {@link EnableMongoHttpSession} annotation.
+ *
+ * @author Jakub Kubrynski
+ * @author Eddú Meléndez
+ * @since 1.2
+ */
+@Configuration(proxyBeanMethods = false)
+@Import(SpringHttpSessionConfiguration.class)
+public class MongoHttpSessionConfiguration implements BeanClassLoaderAware, EmbeddedValueResolverAware, ImportAware {
+
+ private AbstractMongoSessionConverter mongoSessionConverter;
+
+ private Duration maxInactiveInterval = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL;
+
+ @Nullable private String collectionName;
+
+ @Nullable private StringValueResolver embeddedValueResolver;
+
+ @Nullable private List> sessionRepositoryCustomizers;
+
+ @Nullable private ClassLoader classLoader;
+
+ @Nullable private IndexResolver indexResolver;
+
+ private SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
+
+ @Bean
+ @SuppressWarnings("NullAway")
+ public MongoIndexedSessionRepository mongoSessionRepository(MongoOperations mongoOperations) {
+
+ MongoIndexedSessionRepository repository = new MongoIndexedSessionRepository(mongoOperations);
+ repository.setDefaultMaxInactiveInterval(this.maxInactiveInterval);
+
+ if (this.mongoSessionConverter != null) {
+ repository.setMongoSessionConverter(this.mongoSessionConverter);
+
+ if (this.indexResolver != null) {
+ this.mongoSessionConverter.setIndexResolver(this.indexResolver);
+ }
+ } else {
+ JdkMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(
+ new SerializingConverter(),
+ new DeserializingConverter(this.classLoader),
+ Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS));
+
+ if (this.indexResolver != null) {
+ mongoSessionConverter.setIndexResolver(this.indexResolver);
+ }
+
+ repository.setMongoSessionConverter(mongoSessionConverter);
+ }
+
+ if (StringUtils.hasText(this.collectionName)) {
+ repository.setCollectionName(this.collectionName);
+ }
+ repository.setSessionIdGenerator(this.sessionIdGenerator);
+
+ Assert.notNull(this.sessionRepositoryCustomizers, "SessionRepositoryCustomizers not initialized.");
+ this.sessionRepositoryCustomizers.forEach(
+ (sessionRepositoryCustomizer) -> sessionRepositoryCustomizer.customize(repository));
+
+ return repository;
+ }
+
+ public void setCollectionName(String collectionName) {
+ this.collectionName = collectionName;
+ }
+
+ public void setMaxInactiveInterval(Duration maxInactiveInterval) {
+ this.maxInactiveInterval = maxInactiveInterval;
+ }
+
+ @Deprecated
+ @SuppressWarnings("InlineMeSuggester")
+ public void setMaxInactiveIntervalInSeconds(Integer maxInactiveIntervalInSeconds) {
+ setMaxInactiveInterval(Duration.ofSeconds(maxInactiveIntervalInSeconds));
+ }
+
+ @Override
+ @SuppressWarnings("NullAway")
+ public void setImportMetadata(AnnotationMetadata importMetadata) {
+
+ AnnotationAttributes attributes = AnnotationAttributes.fromMap(
+ importMetadata.getAnnotationAttributes(EnableMongoHttpSession.class.getName()));
+
+ if (attributes != null) {
+ this.maxInactiveInterval =
+ Duration.ofSeconds(attributes.getNumber("maxInactiveIntervalInSeconds"));
+ }
+
+ String collectionNameValue = (attributes != null) ? attributes.getString("collectionName") : "";
+ if (StringUtils.hasText(collectionNameValue)) {
+ Assert.notNull(this.embeddedValueResolver, "EmbeddedValueResolver not initialized.");
+ this.collectionName = this.embeddedValueResolver.resolveStringValue(collectionNameValue);
+ }
+ }
+
+ @Autowired(required = false)
+ public void setMongoSessionConverter(AbstractMongoSessionConverter mongoSessionConverter) {
+ this.mongoSessionConverter = mongoSessionConverter;
+ }
+
+ @Autowired(required = false)
+ public void setSessionRepositoryCustomizers(
+ ObjectProvider> sessionRepositoryCustomizers) {
+ this.sessionRepositoryCustomizers =
+ sessionRepositoryCustomizers.orderedStream().collect(Collectors.toList());
+ }
+
+ @Override
+ public void setBeanClassLoader(ClassLoader classLoader) {
+ this.classLoader = classLoader;
+ }
+
+ @Override
+ public void setEmbeddedValueResolver(StringValueResolver resolver) {
+ this.embeddedValueResolver = resolver;
+ }
+
+ @Autowired(required = false)
+ public void setIndexResolver(IndexResolver indexResolver) {
+ this.indexResolver = indexResolver;
+ }
+
+ @Autowired(required = false)
+ public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
+ this.sessionIdGenerator = sessionIdGenerator;
+ }
+}
diff --git a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/reactive/EnableMongoWebSession.java b/src/main/java/org/mongodb/spring/session/config/annotation/web/reactive/EnableMongoWebSession.java
similarity index 59%
rename from src/main/java/org/springframework/session/data/mongo/config/annotation/web/reactive/EnableMongoWebSession.java
rename to src/main/java/org/mongodb/spring/session/config/annotation/web/reactive/EnableMongoWebSession.java
index 9581e45..07b543f 100644
--- a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/reactive/EnableMongoWebSession.java
+++ b/src/main/java/org/mongodb/spring/session/config/annotation/web/reactive/EnableMongoWebSession.java
@@ -1,11 +1,12 @@
/*
+ * Copyright 2025-present MongoDB, Inc.
* Copyright 2014-present the original author or authors.
*
* Licensed 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
*
- * https://www.apache.org/licenses/LICENSE-2.0
+ * 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,
@@ -14,21 +15,19 @@
* limitations under the License.
*/
-package org.springframework.session.data.mongo.config.annotation.web.reactive;
+package org.mongodb.spring.session.config.annotation.web.reactive;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
-
+import org.mongodb.spring.session.ReactiveMongoSessionRepository;
import org.springframework.context.annotation.Import;
import org.springframework.session.MapSession;
-import org.springframework.session.data.mongo.ReactiveMongoSessionRepository;
/**
- * Add this annotation to a {@code @Configuration} class to configure a MongoDB-based
- * {@code WebSessionManager} for a WebFlux application. This annotation assumes a
- * {@code ReactorMongoOperations} is defined somewhere in the application context. If not,
- * it will fail with a clear error messages. For example:
+ * Add this annotation to a {@code @Configuration} class to configure a MongoDB-based {@code WebSessionManager} for a
+ * WebFlux application. This annotation assumes a {@code ReactorMongoOperations} is defined somewhere in the application
+ * context. If not, it will fail with a clear error messages. For example:
*
*
*
@@ -49,21 +48,22 @@
* @since 2.0
*/
@Retention(java.lang.annotation.RetentionPolicy.RUNTIME)
-@Target({ java.lang.annotation.ElementType.TYPE })
+@Target({java.lang.annotation.ElementType.TYPE})
@Documented
@Import(ReactiveMongoWebSessionConfiguration.class)
public @interface EnableMongoWebSession {
- /**
- * The maximum time a session will be kept if it is inactive.
- * @return default max inactive interval in seconds
- */
- int maxInactiveIntervalInSeconds() default MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
-
- /**
- * The collection name to use.
- * @return name of the collection to store session
- */
- String collectionName() default ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME;
+ /**
+ * The maximum time a session will be kept if it is inactive.
+ *
+ * @return default max inactive interval in seconds
+ */
+ int maxInactiveIntervalInSeconds() default MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
+ /**
+ * The collection name to use.
+ *
+ * @return name of the collection to store session
+ */
+ String collectionName() default ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME;
}
diff --git a/src/main/java/org/mongodb/spring/session/config/annotation/web/reactive/ReactiveMongoWebSessionConfiguration.java b/src/main/java/org/mongodb/spring/session/config/annotation/web/reactive/ReactiveMongoWebSessionConfiguration.java
new file mode 100644
index 0000000..43f4972
--- /dev/null
+++ b/src/main/java/org/mongodb/spring/session/config/annotation/web/reactive/ReactiveMongoWebSessionConfiguration.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session.config.annotation.web.reactive;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.mongodb.spring.session.AbstractMongoSessionConverter;
+import org.mongodb.spring.session.JdkMongoSessionConverter;
+import org.mongodb.spring.session.ReactiveMongoSessionRepository;
+import org.springframework.beans.factory.BeanClassLoaderAware;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.EmbeddedValueResolverAware;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.ImportAware;
+import org.springframework.core.annotation.AnnotationAttributes;
+import org.springframework.core.serializer.support.DeserializingConverter;
+import org.springframework.core.serializer.support.SerializingConverter;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.ReactiveMongoOperations;
+import org.springframework.lang.Nullable;
+import org.springframework.session.IndexResolver;
+import org.springframework.session.MapSession;
+import org.springframework.session.Session;
+import org.springframework.session.SessionIdGenerator;
+import org.springframework.session.UuidSessionIdGenerator;
+import org.springframework.session.config.ReactiveSessionRepositoryCustomizer;
+import org.springframework.session.config.annotation.web.server.SpringWebSessionConfiguration;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+import org.springframework.util.StringValueResolver;
+
+/**
+ * Configure a {@link ReactiveMongoSessionRepository} using a provided {@link ReactiveMongoOperations}.
+ *
+ * @author Greg Turnquist
+ * @author Vedran Pavic
+ */
+@Configuration(proxyBeanMethods = false)
+@Import(SpringWebSessionConfiguration.class)
+public class ReactiveMongoWebSessionConfiguration
+ implements BeanClassLoaderAware, EmbeddedValueResolverAware, ImportAware {
+
+ @Nullable private AbstractMongoSessionConverter mongoSessionConverter;
+
+ private Duration maxInactiveInterval = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL;
+
+ @Nullable private String collectionName;
+
+ @Nullable private StringValueResolver embeddedValueResolver;
+
+ private List> sessionRepositoryCustomizers;
+
+ @Autowired(required = false)
+ @Nullable private MongoOperations mongoOperations;
+
+ @Nullable private ClassLoader classLoader;
+
+ @Nullable private IndexResolver indexResolver;
+
+ private SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
+
+ @Bean
+ public ReactiveMongoSessionRepository reactiveMongoSessionRepository(ReactiveMongoOperations operations) {
+
+ ReactiveMongoSessionRepository repository = new ReactiveMongoSessionRepository(operations);
+
+ if (this.mongoSessionConverter != null) {
+ repository.setMongoSessionConverter(this.mongoSessionConverter);
+
+ if (this.indexResolver != null) {
+ this.mongoSessionConverter.setIndexResolver(this.indexResolver);
+ }
+
+ } else {
+ JdkMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(
+ new SerializingConverter(),
+ new DeserializingConverter(this.classLoader),
+ Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS));
+
+ if (this.indexResolver != null) {
+ mongoSessionConverter.setIndexResolver(this.indexResolver);
+ }
+
+ repository.setMongoSessionConverter(mongoSessionConverter);
+ }
+
+ repository.setDefaultMaxInactiveInterval(this.maxInactiveInterval);
+
+ if (this.collectionName != null) {
+ repository.setCollectionName(this.collectionName);
+ }
+
+ if (this.mongoOperations != null) {
+ repository.setBlockingMongoOperations(this.mongoOperations);
+ }
+
+ this.sessionRepositoryCustomizers.forEach(
+ (sessionRepositoryCustomizer) -> sessionRepositoryCustomizer.customize(repository));
+
+ repository.setSessionIdGenerator(this.sessionIdGenerator);
+
+ return repository;
+ }
+
+ @Autowired(required = false)
+ public void setMongoSessionConverter(AbstractMongoSessionConverter mongoSessionConverter) {
+ this.mongoSessionConverter = mongoSessionConverter;
+ }
+
+ @Override
+ @SuppressWarnings("NullAway")
+ public void setImportMetadata(AnnotationMetadata importMetadata) {
+
+ AnnotationAttributes attributes = AnnotationAttributes.fromMap(
+ importMetadata.getAnnotationAttributes(EnableMongoWebSession.class.getName()));
+
+ if (attributes != null) {
+ this.maxInactiveInterval =
+ Duration.ofSeconds(attributes.getNumber("maxInactiveIntervalInSeconds"));
+ }
+
+ String collectionNameValue = (attributes != null) ? attributes.getString("collectionName") : "";
+ if (StringUtils.hasText(collectionNameValue)) {
+ Assert.notNull(this.embeddedValueResolver, "EmbeddedValueResolver not initialized.");
+ this.collectionName = this.embeddedValueResolver.resolveStringValue(collectionNameValue);
+ }
+ }
+
+ @Override
+ public void setBeanClassLoader(ClassLoader classLoader) {
+ this.classLoader = classLoader;
+ }
+
+ @Override
+ public void setEmbeddedValueResolver(StringValueResolver embeddedValueResolver) {
+ this.embeddedValueResolver = embeddedValueResolver;
+ }
+
+ public Duration getMaxInactiveInterval() {
+ return this.maxInactiveInterval;
+ }
+
+ public void setMaxInactiveInterval(Duration maxInactiveInterval) {
+ this.maxInactiveInterval = maxInactiveInterval;
+ }
+
+ @Deprecated
+ @SuppressWarnings("InlineMeSuggester")
+ public void setMaxInactiveIntervalInSeconds(Integer maxInactiveIntervalInSeconds) {
+ setMaxInactiveInterval(Duration.ofSeconds(maxInactiveIntervalInSeconds));
+ }
+
+ @Nullable public String getCollectionName() {
+ return this.collectionName;
+ }
+
+ public void setCollectionName(String collectionName) {
+ this.collectionName = collectionName;
+ }
+
+ @Autowired(required = false)
+ public void setSessionRepositoryCustomizers(
+ ObjectProvider>
+ sessionRepositoryCustomizers) {
+ this.sessionRepositoryCustomizers =
+ sessionRepositoryCustomizers.orderedStream().collect(Collectors.toList());
+ }
+
+ @Autowired(required = false)
+ public void setIndexResolver(IndexResolver indexResolver) {
+ this.indexResolver = indexResolver;
+ }
+
+ @Autowired(required = false)
+ public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
+ this.sessionIdGenerator = sessionIdGenerator;
+ }
+}
diff --git a/src/main/java/org/springframework/session/data/mongo/package-info.java b/src/main/java/org/mongodb/spring/session/package-info.java
similarity index 94%
rename from src/main/java/org/springframework/session/data/mongo/package-info.java
rename to src/main/java/org/mongodb/spring/session/package-info.java
index f7881e7..c4c4138 100644
--- a/src/main/java/org/springframework/session/data/mongo/package-info.java
+++ b/src/main/java/org/mongodb/spring/session/package-info.java
@@ -20,6 +20,6 @@
* @author Greg Turnquist
*/
@NonNullApi
-package org.springframework.session.data.mongo;
+package org.mongodb.spring.session;
import org.springframework.lang.NonNullApi;
diff --git a/src/main/java/org/springframework/session/data/mongo/AbstractMongoSessionConverter.java b/src/main/java/org/springframework/session/data/mongo/AbstractMongoSessionConverter.java
deleted file mode 100644
index ef7c328..0000000
--- a/src/main/java/org/springframework/session/data/mongo/AbstractMongoSessionConverter.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.util.Collections;
-import java.util.Set;
-
-import com.mongodb.DBObject;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.bson.Document;
-
-import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.core.convert.converter.GenericConverter;
-import org.springframework.data.domain.Sort;
-import org.springframework.data.mongodb.core.index.Index;
-import org.springframework.data.mongodb.core.index.IndexInfo;
-import org.springframework.data.mongodb.core.index.IndexOperations;
-import org.springframework.data.mongodb.core.query.Query;
-import org.springframework.lang.Nullable;
-import org.springframework.session.DelegatingIndexResolver;
-import org.springframework.session.FindByIndexNameSessionRepository;
-import org.springframework.session.IndexResolver;
-import org.springframework.session.PrincipalNameIndexResolver;
-import org.springframework.session.Session;
-import org.springframework.util.Assert;
-
-/**
- * Base class for serializing and deserializing session objects. To create custom
- * serializer you have to implement this interface and simply register your class as a
- * bean.
- *
- * @author Jakub Kubrynski
- * @author Greg Turnquist
- * @since 1.2
- */
-public abstract class AbstractMongoSessionConverter implements GenericConverter {
-
- static final String EXPIRE_AT_FIELD_NAME = "expireAt";
-
- private static final Log LOG = LogFactory.getLog(AbstractMongoSessionConverter.class);
-
- private static final String SPRING_SECURITY_CONTEXT = "SPRING_SECURITY_CONTEXT";
-
- private IndexResolver indexResolver = new DelegatingIndexResolver<>(new PrincipalNameIndexResolver<>());
-
- /**
- * Returns query to be executed to return sessions based on a particular index.
- * @param indexName name of the index
- * @param indexValue value to query against
- * @return built query or null if indexName is not supported
- */
- @Nullable
- protected abstract Query getQueryForIndex(String indexName, Object indexValue);
-
- /**
- * Method ensures that there is a TTL index on {@literal expireAt} field. It's has
- * {@literal expireAfterSeconds} set to zero seconds, so the expiration time is
- * controlled by the application. It can be extended in custom converters when there
- * is a need for creating additional custom indexes.
- * @param sessionCollectionIndexes {@link IndexOperations} to use
- */
- protected void ensureIndexes(IndexOperations sessionCollectionIndexes) {
-
- for (IndexInfo info : sessionCollectionIndexes.getIndexInfo()) {
- if (EXPIRE_AT_FIELD_NAME.equals(info.getName())) {
- LOG.debug("TTL index on field " + EXPIRE_AT_FIELD_NAME + " already exists");
- return;
- }
- }
-
- LOG.info("Creating TTL index on field " + EXPIRE_AT_FIELD_NAME);
-
- sessionCollectionIndexes
- .ensureIndex(new Index(EXPIRE_AT_FIELD_NAME, Sort.Direction.ASC).named(EXPIRE_AT_FIELD_NAME).expire(0));
- }
-
- protected String extractPrincipal(MongoSession expiringSession) {
-
- return this.indexResolver.resolveIndexesFor(expiringSession)
- .get(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME);
- }
-
- public Set getConvertibleTypes() {
-
- return Collections.singleton(new ConvertiblePair(DBObject.class, MongoSession.class));
- }
-
- @SuppressWarnings("unchecked")
- @Nullable
- public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
-
- if (source == null) {
- return null;
- }
-
- if (DBObject.class.isAssignableFrom(sourceType.getType())) {
- return convert(new Document(((DBObject) source).toMap()));
- }
- else if (Document.class.isAssignableFrom(sourceType.getType())) {
- return convert((Document) source);
- }
- else {
- return convert((MongoSession) source);
- }
- }
-
- protected abstract DBObject convert(MongoSession session);
-
- protected abstract MongoSession convert(Document sessionWrapper);
-
- public void setIndexResolver(IndexResolver indexResolver) {
- Assert.notNull(indexResolver, "indexResolver must not be null");
- this.indexResolver = indexResolver;
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/JacksonMongoSessionConverter.java b/src/main/java/org/springframework/session/data/mongo/JacksonMongoSessionConverter.java
deleted file mode 100644
index f66333c..0000000
--- a/src/main/java/org/springframework/session/data/mongo/JacksonMongoSessionConverter.java
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-
-import com.fasterxml.jackson.annotation.JsonAutoDetect;
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.PropertyAccessor;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.Module;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.PropertyNamingStrategies;
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBObject;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.bson.Document;
-import org.bson.json.JsonMode;
-import org.bson.json.JsonWriterSettings;
-
-import org.springframework.data.mongodb.core.query.Criteria;
-import org.springframework.data.mongodb.core.query.Query;
-import org.springframework.lang.Nullable;
-import org.springframework.security.jackson2.SecurityJackson2Modules;
-import org.springframework.session.FindByIndexNameSessionRepository;
-import org.springframework.util.Assert;
-
-/**
- * {@code AbstractMongoSessionConverter} implementation using Jackson.
- *
- * @author Jakub Kubrynski
- * @author Greg Turnquist
- * @author Michael Ruf
- * @since 1.2
- */
-public class JacksonMongoSessionConverter extends AbstractMongoSessionConverter {
-
- private static final Log LOG = LogFactory.getLog(JacksonMongoSessionConverter.class);
-
- private static final String ATTRS_FIELD_NAME = "attrs.";
-
- private static final String PRINCIPAL_FIELD_NAME = "principal";
-
- private static final String EXPIRE_AT_FIELD_NAME = "expireAt";
-
- private final ObjectMapper objectMapper;
-
- public JacksonMongoSessionConverter() {
- this(Collections.emptyList());
- }
-
- public JacksonMongoSessionConverter(Iterable modules) {
-
- this.objectMapper = buildObjectMapper();
- this.objectMapper.registerModules(modules);
- }
-
- public JacksonMongoSessionConverter(ObjectMapper objectMapper) {
-
- Assert.notNull(objectMapper, "ObjectMapper can NOT be null!");
- this.objectMapper = objectMapper;
- }
-
- @Nullable
- protected Query getQueryForIndex(String indexName, Object indexValue) {
-
- if (FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) {
- return Query.query(Criteria.where(PRINCIPAL_FIELD_NAME).is(indexValue));
- }
- else {
- return Query.query(Criteria.where(ATTRS_FIELD_NAME + MongoSession.coverDot(indexName)).is(indexValue));
- }
- }
-
- private ObjectMapper buildObjectMapper() {
-
- ObjectMapper objectMapper = new ObjectMapper();
-
- // serialize fields instead of properties
- objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
- objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
-
- // ignore unresolved fields (mostly 'principal')
- objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-
- objectMapper.setPropertyNamingStrategy(new MongoIdNamingStrategy());
-
- objectMapper.registerModules(SecurityJackson2Modules.getModules(getClass().getClassLoader()));
- objectMapper.addMixIn(MongoSession.class, MongoSessionMixin.class);
- objectMapper.addMixIn(HashMap.class, HashMapMixin.class);
-
- return objectMapper;
- }
-
- @Override
- protected DBObject convert(MongoSession source) {
-
- try {
- DBObject dbSession = BasicDBObject.parse(this.objectMapper.writeValueAsString(source));
-
- // Override default serialization with proper values.
- dbSession.put(PRINCIPAL_FIELD_NAME, extractPrincipal(source));
- dbSession.put(EXPIRE_AT_FIELD_NAME, source.getExpireAt());
- return dbSession;
- }
- catch (JsonProcessingException ex) {
- throw new IllegalStateException("Cannot convert MongoExpiringSession", ex);
- }
- }
-
- @Override
- @Nullable
- protected MongoSession convert(Document source) {
-
- Date expireAt = (Date) source.remove(EXPIRE_AT_FIELD_NAME);
- source.remove("originalSessionId");
- String json = source.toJson(JsonWriterSettings.builder().outputMode(JsonMode.RELAXED).build());
-
- try {
- MongoSession mongoSession = this.objectMapper.readValue(json, MongoSession.class);
- mongoSession.setExpireAt(expireAt);
- return mongoSession;
- }
- catch (IOException ex) {
- LOG.error("Error during Mongo Session deserialization", ex);
- return null;
- }
- }
-
- /**
- * Used to whitelist {@link MongoSession} for {@link SecurityJackson2Modules}.
- */
- private static class MongoSessionMixin {
-
- @JsonCreator
- MongoSessionMixin(@JsonProperty("_id") String id,
- @JsonProperty("intervalSeconds") long maxInactiveIntervalInSeconds) {
- }
-
- }
-
- /**
- * Used to whitelist {@link HashMap} for {@link SecurityJackson2Modules}.
- */
- private static class HashMapMixin {
-
- // Nothing special
-
- }
-
- private static class MongoIdNamingStrategy extends PropertyNamingStrategies.NamingBase {
-
- @Override
- public String translate(String propertyName) {
-
- switch (propertyName) {
- case "id":
- return "_id";
- case "_id":
- return "id";
- default:
- return propertyName;
- }
- }
-
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/JdkMongoSessionConverter.java b/src/main/java/org/springframework/session/data/mongo/JdkMongoSessionConverter.java
deleted file mode 100644
index 19a8b56..0000000
--- a/src/main/java/org/springframework/session/data/mongo/JdkMongoSessionConverter.java
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBObject;
-import org.bson.Document;
-import org.bson.types.Binary;
-
-import org.springframework.core.convert.converter.Converter;
-import org.springframework.core.serializer.support.DeserializingConverter;
-import org.springframework.core.serializer.support.SerializingConverter;
-import org.springframework.data.mongodb.core.query.Criteria;
-import org.springframework.data.mongodb.core.query.Query;
-import org.springframework.lang.Nullable;
-import org.springframework.session.FindByIndexNameSessionRepository;
-import org.springframework.session.Session;
-import org.springframework.util.Assert;
-
-/**
- * {@code AbstractMongoSessionConverter} implementation using standard Java serialization.
- *
- * @author Jakub Kubrynski
- * @author Rob Winch
- * @author Greg Turnquist
- * @since 1.2
- */
-public class JdkMongoSessionConverter extends AbstractMongoSessionConverter {
-
- private static final String ID = "_id";
-
- private static final String CREATION_TIME = "created";
-
- private static final String LAST_ACCESSED_TIME = "accessed";
-
- private static final String MAX_INTERVAL = "interval";
-
- private static final String ATTRIBUTES = "attr";
-
- private static final String PRINCIPAL_FIELD_NAME = "principal";
-
- private final Converter serializer;
-
- private final Converter deserializer;
-
- private Duration maxInactiveInterval;
-
- public JdkMongoSessionConverter(Duration maxInactiveInterval) {
- this(new SerializingConverter(), new DeserializingConverter(), maxInactiveInterval);
- }
-
- public JdkMongoSessionConverter(Converter serializer, Converter deserializer,
- Duration maxInactiveInterval) {
-
- Assert.notNull(serializer, "serializer cannot be null");
- Assert.notNull(deserializer, "deserializer cannot be null");
- Assert.notNull(maxInactiveInterval, "maxInactiveInterval cannot be null");
-
- this.serializer = serializer;
- this.deserializer = deserializer;
- this.maxInactiveInterval = maxInactiveInterval;
- }
-
- @Override
- @Nullable
- public Query getQueryForIndex(String indexName, Object indexValue) {
-
- if (FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME.equals(indexName)) {
- return Query.query(Criteria.where(PRINCIPAL_FIELD_NAME).is(indexValue));
- }
- else {
- return null;
- }
- }
-
- @Override
- protected DBObject convert(MongoSession session) {
-
- BasicDBObject basicDBObject = new BasicDBObject();
-
- basicDBObject.put(ID, session.getId());
- basicDBObject.put(CREATION_TIME, session.getCreationTime());
- basicDBObject.put(LAST_ACCESSED_TIME, session.getLastAccessedTime());
- basicDBObject.put(MAX_INTERVAL, session.getMaxInactiveInterval());
- basicDBObject.put(PRINCIPAL_FIELD_NAME, extractPrincipal(session));
- basicDBObject.put(EXPIRE_AT_FIELD_NAME, session.getExpireAt());
- basicDBObject.put(ATTRIBUTES, serializeAttributes(session));
-
- return basicDBObject;
- }
-
- @Override
- protected MongoSession convert(Document sessionWrapper) {
-
- Object maxInterval = sessionWrapper.getOrDefault(MAX_INTERVAL, this.maxInactiveInterval);
-
- Duration maxIntervalDuration = (maxInterval instanceof Duration) ? (Duration) maxInterval
- : Duration.parse(maxInterval.toString());
-
- MongoSession session = new MongoSession(sessionWrapper.getString(ID), maxIntervalDuration.getSeconds());
-
- Object creationTime = sessionWrapper.get(CREATION_TIME);
- if (creationTime instanceof Instant) {
- session.setCreationTime(((Instant) creationTime).toEpochMilli());
- }
- else if (creationTime instanceof Date) {
- session.setCreationTime(((Date) creationTime).getTime());
- }
-
- Object lastAccessedTime = sessionWrapper.get(LAST_ACCESSED_TIME);
- if (lastAccessedTime instanceof Instant) {
- session.setLastAccessedTime((Instant) lastAccessedTime);
- }
- else if (lastAccessedTime instanceof Date) {
- session.setLastAccessedTime(Instant.ofEpochMilli(((Date) lastAccessedTime).getTime()));
- }
-
- session.setExpireAt((Date) sessionWrapper.get(EXPIRE_AT_FIELD_NAME));
-
- deserializeAttributes(sessionWrapper, session);
-
- return session;
- }
-
- @Nullable
- private byte[] serializeAttributes(Session session) {
-
- Map attributes = new HashMap<>();
-
- for (String attrName : session.getAttributeNames()) {
- attributes.put(attrName, session.getAttribute(attrName));
- }
-
- return this.serializer.convert(attributes);
- }
-
- @SuppressWarnings("unchecked")
- private void deserializeAttributes(Document sessionWrapper, Session session) {
-
- Object sessionAttributes = sessionWrapper.get(ATTRIBUTES);
-
- byte[] attributesBytes = ((sessionAttributes instanceof Binary) ? ((Binary) sessionAttributes).getData()
- : (byte[]) sessionAttributes);
-
- Map attributes = (Map) this.deserializer.convert(attributesBytes);
-
- if (attributes != null) {
- for (Map.Entry entry : attributes.entrySet()) {
- session.setAttribute(entry.getKey(), entry.getValue());
- }
- }
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/MongoIndexedSessionRepository.java b/src/main/java/org/springframework/session/data/mongo/MongoIndexedSessionRepository.java
deleted file mode 100644
index 2cfea19..0000000
--- a/src/main/java/org/springframework/session/data/mongo/MongoIndexedSessionRepository.java
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.time.Duration;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-import com.mongodb.DBObject;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.bson.Document;
-
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.context.ApplicationEvent;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.ApplicationEventPublisherAware;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.index.IndexOperations;
-import org.springframework.lang.Nullable;
-import org.springframework.session.FindByIndexNameSessionRepository;
-import org.springframework.session.MapSession;
-import org.springframework.session.SessionIdGenerator;
-import org.springframework.session.UuidSessionIdGenerator;
-import org.springframework.session.events.SessionCreatedEvent;
-import org.springframework.session.events.SessionDeletedEvent;
-import org.springframework.session.events.SessionExpiredEvent;
-import org.springframework.util.Assert;
-
-/**
- * Session repository implementation which stores sessions in Mongo. Uses
- * {@link AbstractMongoSessionConverter} to transform session objects from/to native Mongo
- * representation ({@code DBObject}). Repository is also responsible for removing expired
- * sessions from database. Cleanup is done every minute.
- *
- * @author Jakub Kubrynski
- * @author Greg Turnquist
- * @author Vedran Pavic
- * @since 2.2.0
- */
-public class MongoIndexedSessionRepository
- implements FindByIndexNameSessionRepository, ApplicationEventPublisherAware, InitializingBean {
-
- /**
- * The default time period in seconds in which a session will expire.
- * @deprecated since 3.0.0 in favor of
- * {@link MapSession#DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS}
- */
- @Deprecated
- public static final int DEFAULT_INACTIVE_INTERVAL = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
-
- /**
- * the default collection name for storing session.
- */
- public static final String DEFAULT_COLLECTION_NAME = "sessions";
-
- private static final Log logger = LogFactory.getLog(MongoIndexedSessionRepository.class);
-
- private final MongoOperations mongoOperations;
-
- private Duration defaultMaxInactiveInterval = Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
-
- private String collectionName = DEFAULT_COLLECTION_NAME;
-
- private AbstractMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(
- this.defaultMaxInactiveInterval);
-
- private ApplicationEventPublisher eventPublisher;
-
- private SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
-
- public MongoIndexedSessionRepository(MongoOperations mongoOperations) {
- this.mongoOperations = mongoOperations;
- }
-
- @Override
- public MongoSession createSession() {
-
- MongoSession session = new MongoSession(this.sessionIdGenerator, this.defaultMaxInactiveInterval.toSeconds());
-
- publishEvent(new SessionCreatedEvent(this, session));
-
- return session;
- }
-
- @Override
- public void save(MongoSession session) {
- DBObject dbObject = MongoSessionUtils.convertToDBObject(this.mongoSessionConverter, session);
- Assert.notNull(dbObject, "dbObject must not be null");
- this.mongoOperations.save(dbObject, this.collectionName);
- }
-
- @Override
- @Nullable
- public MongoSession findById(String id) {
-
- Document sessionWrapper = findSession(id);
-
- if (sessionWrapper == null) {
- return null;
- }
-
- MongoSession session = MongoSessionUtils.convertToSession(this.mongoSessionConverter, sessionWrapper);
-
- if (session != null) {
- if (session.isExpired()) {
- publishEvent(new SessionExpiredEvent(this, session));
- deleteById(id);
- return null;
- }
- session.setSessionIdGenerator(this.sessionIdGenerator);
- }
-
- return session;
- }
-
- /**
- * Currently this repository allows only querying against
- * {@code PRINCIPAL_NAME_INDEX_NAME}.
- * @param indexName the name if the index (i.e.
- * {@link FindByIndexNameSessionRepository#PRINCIPAL_NAME_INDEX_NAME})
- * @param indexValue the value of the index to search for.
- * @return sessions map
- */
- @Override
- public Map findByIndexNameAndIndexValue(String indexName, String indexValue) {
-
- return Optional.ofNullable(this.mongoSessionConverter.getQueryForIndex(indexName, indexValue))
- .map((query) -> this.mongoOperations.find(query, Document.class, this.collectionName))
- .orElse(Collections.emptyList())
- .stream()
- .map((dbSession) -> MongoSessionUtils.convertToSession(this.mongoSessionConverter, dbSession))
- .peek((session) -> session.setSessionIdGenerator(this.sessionIdGenerator))
- .collect(Collectors.toMap(MongoSession::getId, (mapSession) -> mapSession));
- }
-
- @Override
- public void deleteById(String id) {
-
- Optional.ofNullable(findSession(id)).ifPresent((document) -> {
-
- MongoSession session = MongoSessionUtils.convertToSession(this.mongoSessionConverter, document);
- if (session != null) {
- publishEvent(new SessionDeletedEvent(this, session));
- }
- this.mongoOperations.remove(document, this.collectionName);
- });
- }
-
- @Override
- public void afterPropertiesSet() {
-
- IndexOperations indexOperations = this.mongoOperations.indexOps(this.collectionName);
- this.mongoSessionConverter.ensureIndexes(indexOperations);
- }
-
- @Nullable
- private Document findSession(String id) {
- return this.mongoOperations.findById(id, Document.class, this.collectionName);
- }
-
- @Override
- public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
- this.eventPublisher = eventPublisher;
- }
-
- private void publishEvent(ApplicationEvent event) {
-
- try {
- this.eventPublisher.publishEvent(event);
- }
- catch (Throwable ex) {
- logger.error("Error publishing " + event + ".", ex);
- }
- }
-
- /**
- * Set the maximum inactive interval in seconds between requests before newly created
- * sessions will be invalidated. A negative time indicates that the session will never
- * time out. The default is 30 minutes.
- * @param defaultMaxInactiveInterval the default maxInactiveInterval
- */
- public void setDefaultMaxInactiveInterval(Duration defaultMaxInactiveInterval) {
- org.springframework.util.Assert.notNull(defaultMaxInactiveInterval,
- "defaultMaxInactiveInterval must not be null");
- this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;
- }
-
- /**
- * Set the maximum inactive interval in seconds between requests before newly created
- * sessions will be invalidated. A negative time indicates that the session will never
- * time out. The default is 1800 (30 minutes).
- * @param defaultMaxInactiveInterval the default maxInactiveInterval in seconds
- * @deprecated since 3.0.0, in favor of
- * {@link #setDefaultMaxInactiveInterval(Duration)}
- */
- @Deprecated(since = "3.0.0")
- public void setMaxInactiveIntervalInSeconds(Integer defaultMaxInactiveInterval) {
- setDefaultMaxInactiveInterval(Duration.ofSeconds(defaultMaxInactiveInterval));
- }
-
- public void setCollectionName(final String collectionName) {
- this.collectionName = collectionName;
- }
-
- public void setMongoSessionConverter(final AbstractMongoSessionConverter mongoSessionConverter) {
- this.mongoSessionConverter = mongoSessionConverter;
- }
-
- /**
- * Set the {@link SessionIdGenerator} to use to generate session ids.
- * @param sessionIdGenerator the {@link SessionIdGenerator} to use
- * @since 3.2
- */
- public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
- Assert.notNull(sessionIdGenerator, "sessionIdGenerator cannot be null");
- this.sessionIdGenerator = sessionIdGenerator;
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/MongoSession.java b/src/main/java/org/springframework/session/data/mongo/MongoSession.java
deleted file mode 100644
index 698f463..0000000
--- a/src/main/java/org/springframework/session/data/mongo/MongoSession.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import org.springframework.lang.Nullable;
-import org.springframework.session.MapSession;
-import org.springframework.session.Session;
-import org.springframework.session.SessionIdGenerator;
-import org.springframework.session.UuidSessionIdGenerator;
-import org.springframework.util.Assert;
-
-/**
- * Session object providing additional information about the datetime of expiration.
- *
- * @author Jakub Kubrynski
- * @author Greg Turnquist
- * @since 1.2
- */
-public final class MongoSession implements Session {
-
- /**
- * Mongo doesn't support {@literal dot} in field names. We replace it with a unicode
- * character from the Private Use Area.
- *
- * NOTE: This was originally stored in unicode format. Delomboking the code caused it
- * to get converted to another encoding, which isn't supported on all systems, so we
- * migrated back to unicode. The same character is being represented ensuring binary
- * compatibility. See https://www.compart.com/en/unicode/U+F607
- */
- private static final char DOT_COVER_CHAR = '\uF607';
-
- private String id;
-
- private final String originalSessionId;
-
- private long createdMillis = System.currentTimeMillis();
-
- private long accessedMillis;
-
- private long intervalSeconds;
-
- private Date expireAt;
-
- private final Map attrs = new HashMap<>();
-
- private transient SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
-
- /**
- * Constructs a new instance using the provided session id.
- * @param sessionId the session id to use
- * @since 3.2
- */
- public MongoSession(String sessionId) {
- this(sessionId, MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
- }
-
- public MongoSession() {
- this(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
- }
-
- public MongoSession(long maxInactiveIntervalInSeconds) {
- this(UuidSessionIdGenerator.getInstance().generate(), maxInactiveIntervalInSeconds);
- }
-
- public MongoSession(String id, long maxInactiveIntervalInSeconds) {
- this.id = id;
- this.originalSessionId = id;
- this.intervalSeconds = maxInactiveIntervalInSeconds;
- setLastAccessedTime(Instant.ofEpochMilli(this.createdMillis));
- }
-
- /**
- * Constructs a new instance using the provided {@link SessionIdGenerator}.
- * @param sessionIdGenerator the {@link SessionIdGenerator} to use
- * @since 3.2
- */
- public MongoSession(SessionIdGenerator sessionIdGenerator) {
- this(sessionIdGenerator.generate(), MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
- this.sessionIdGenerator = sessionIdGenerator;
- }
-
- /**
- * Constructs a new instance using the provided {@link SessionIdGenerator} and max
- * inactive interval.
- * @param sessionIdGenerator the {@link SessionIdGenerator} to use
- * @param maxInactiveIntervalInSeconds the max inactive interval in seconds
- * @since 3.2
- */
- MongoSession(SessionIdGenerator sessionIdGenerator, long maxInactiveIntervalInSeconds) {
- this(sessionIdGenerator.generate(), maxInactiveIntervalInSeconds);
- this.sessionIdGenerator = sessionIdGenerator;
- }
-
- static String coverDot(String attributeName) {
- return attributeName.replace('.', DOT_COVER_CHAR);
- }
-
- static String uncoverDot(String attributeName) {
- return attributeName.replace(DOT_COVER_CHAR, '.');
- }
-
- @Override
- public String changeSessionId() {
-
- String changedId = this.sessionIdGenerator.generate();
- this.id = changedId;
- return changedId;
- }
-
- @Override
- @Nullable
- @SuppressWarnings("unchecked")
- public T getAttribute(String attributeName) {
- return (T) this.attrs.get(coverDot(attributeName));
- }
-
- @Override
- public Set getAttributeNames() {
- return this.attrs.keySet().stream().map(MongoSession::uncoverDot).collect(Collectors.toSet());
- }
-
- @Override
- public void setAttribute(String attributeName, Object attributeValue) {
-
- if (attributeValue == null) {
- removeAttribute(coverDot(attributeName));
- }
- else {
- this.attrs.put(coverDot(attributeName), attributeValue);
- }
- }
-
- @Override
- public void removeAttribute(String attributeName) {
- this.attrs.remove(coverDot(attributeName));
- }
-
- @Override
- public Instant getCreationTime() {
- return Instant.ofEpochMilli(this.createdMillis);
- }
-
- void setCreationTime(long created) {
- this.createdMillis = created;
- }
-
- @Override
- public Instant getLastAccessedTime() {
- return Instant.ofEpochMilli(this.accessedMillis);
- }
-
- @Override
- public void setLastAccessedTime(Instant lastAccessedTime) {
- this.accessedMillis = lastAccessedTime.toEpochMilli();
- this.expireAt = Date.from(lastAccessedTime.plus(Duration.ofSeconds(this.intervalSeconds)));
- }
-
- @Override
- public Duration getMaxInactiveInterval() {
- return Duration.ofSeconds(this.intervalSeconds);
- }
-
- @Override
- public void setMaxInactiveInterval(Duration interval) {
- this.intervalSeconds = interval.getSeconds();
- }
-
- @Override
- public boolean isExpired() {
- return this.intervalSeconds >= 0 && new Date().after(this.expireAt);
- }
-
- @Override
- public boolean equals(Object o) {
-
- if (this == o) {
- return true;
- }
- if (o == null || getClass() != o.getClass()) {
- return false;
- }
- MongoSession that = (MongoSession) o;
- return Objects.equals(this.id, that.id);
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(this.id);
- }
-
- @Override
- public String getId() {
- return this.id;
- }
-
- Date getExpireAt() {
- return this.expireAt;
- }
-
- void setExpireAt(final Date expireAt) {
- this.expireAt = expireAt;
- }
-
- boolean hasChangedSessionId() {
- return !getId().equals(this.originalSessionId);
- }
-
- String getOriginalSessionId() {
- return this.originalSessionId;
- }
-
- /**
- * Sets the session id.
- * @param id the id to set
- * @since 3.2
- */
- void setId(String id) {
- this.id = id;
- }
-
- /**
- * Sets the {@link SessionIdGenerator} to use.
- * @param sessionIdGenerator the {@link SessionIdGenerator} to use
- * @since 3.2
- */
- void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
- Assert.notNull(sessionIdGenerator, "sessionIdGenerator cannot be null");
- this.sessionIdGenerator = sessionIdGenerator;
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/MongoSessionUtils.java b/src/main/java/org/springframework/session/data/mongo/MongoSessionUtils.java
deleted file mode 100644
index 4021b27..0000000
--- a/src/main/java/org/springframework/session/data/mongo/MongoSessionUtils.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import com.mongodb.DBObject;
-import org.bson.Document;
-
-import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.lang.Nullable;
-
-/**
- * Utility for MongoSession.
- *
- * @author Greg Turnquist
- */
-final class MongoSessionUtils {
-
- private MongoSessionUtils() {
- }
-
- @Nullable
- static DBObject convertToDBObject(AbstractMongoSessionConverter mongoSessionConverter, MongoSession session) {
-
- return (DBObject) mongoSessionConverter.convert(session, TypeDescriptor.valueOf(MongoSession.class),
- TypeDescriptor.valueOf(DBObject.class));
- }
-
- @Nullable
- static MongoSession convertToSession(AbstractMongoSessionConverter mongoSessionConverter, Document session) {
-
- return (MongoSession) mongoSessionConverter.convert(session, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class));
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/ReactiveMongoSessionRepository.java b/src/main/java/org/springframework/session/data/mongo/ReactiveMongoSessionRepository.java
deleted file mode 100644
index a988f3c..0000000
--- a/src/main/java/org/springframework/session/data/mongo/ReactiveMongoSessionRepository.java
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.time.Duration;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.bson.Document;
-import reactor.core.publisher.Mono;
-import reactor.core.scheduler.Schedulers;
-
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.context.ApplicationEvent;
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.context.ApplicationEventPublisherAware;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.ReactiveMongoOperations;
-import org.springframework.data.mongodb.core.index.IndexOperations;
-import org.springframework.data.mongodb.core.query.Criteria;
-import org.springframework.data.mongodb.core.query.Query;
-import org.springframework.session.MapSession;
-import org.springframework.session.ReactiveSessionRepository;
-import org.springframework.session.SessionIdGenerator;
-import org.springframework.session.UuidSessionIdGenerator;
-import org.springframework.session.events.SessionCreatedEvent;
-import org.springframework.session.events.SessionDeletedEvent;
-import org.springframework.util.Assert;
-
-/**
- * A {@link ReactiveSessionRepository} implementation that uses Spring Data MongoDB.
- *
- * @author Greg Turnquist
- * @author Vedran Pavic
- * @since 2.2.0
- */
-public class ReactiveMongoSessionRepository
- implements ReactiveSessionRepository, ApplicationEventPublisherAware, InitializingBean {
-
- /**
- * The default time period in seconds in which a session will expire.
- * @deprecated since 3.0.0 in favor of
- * {@link MapSession#DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS}
- */
- @Deprecated
- public static final int DEFAULT_INACTIVE_INTERVAL = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS;
-
- /**
- * The default collection name for storing session.
- */
- public static final String DEFAULT_COLLECTION_NAME = "sessions";
-
- private static final Log logger = LogFactory.getLog(ReactiveMongoSessionRepository.class);
-
- private final ReactiveMongoOperations mongoOperations;
-
- private Duration defaultMaxInactiveInterval = Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
-
- private String collectionName = DEFAULT_COLLECTION_NAME;
-
- private AbstractMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(
- this.defaultMaxInactiveInterval);
-
- private MongoOperations blockingMongoOperations;
-
- private ApplicationEventPublisher eventPublisher;
-
- private SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
-
- public ReactiveMongoSessionRepository(ReactiveMongoOperations mongoOperations) {
- this.mongoOperations = mongoOperations;
- }
-
- /**
- * Creates a new {@link MongoSession} that is capable of being persisted by this
- * {@link ReactiveSessionRepository}.
- *
- * This allows optimizations and customizations in how the {@link MongoSession} is
- * persisted. For example, the implementation returned might keep track of the changes
- * ensuring that only the delta needs to be persisted on a save.
- *
- * @return a new {@link MongoSession} that is capable of being persisted by this
- * {@link ReactiveSessionRepository}
- */
- @Override
- public Mono createSession() {
- // @formatter:off
- return Mono.fromSupplier(() -> this.sessionIdGenerator.generate())
- .zipWith(Mono.just(this.defaultMaxInactiveInterval.toSeconds()))
- .map((tuple) -> new MongoSession(tuple.getT1(), tuple.getT2()))
- .doOnNext((mongoSession) -> mongoSession.setMaxInactiveInterval(this.defaultMaxInactiveInterval))
- .doOnNext(
- (mongoSession) -> mongoSession.setSessionIdGenerator(this.sessionIdGenerator))
- .doOnNext((mongoSession) -> publishEvent(new SessionCreatedEvent(this, mongoSession)))
- .switchIfEmpty(Mono.just(new MongoSession(this.sessionIdGenerator)))
- .subscribeOn(Schedulers.boundedElastic())
- .publishOn(Schedulers.parallel());
- // @formatter:on
- }
-
- @Override
- public Mono save(MongoSession session) {
-
- return Mono //
- .justOrEmpty(MongoSessionUtils.convertToDBObject(this.mongoSessionConverter, session)) //
- .flatMap((dbObject) -> {
- if (session.hasChangedSessionId()) {
-
- return this.mongoOperations
- .remove(Query.query(Criteria.where("_id").is(session.getOriginalSessionId())),
- this.collectionName) //
- .then(this.mongoOperations.save(dbObject, this.collectionName));
- }
- else {
-
- return this.mongoOperations.save(dbObject, this.collectionName);
- }
- }) //
- .then();
- }
-
- @Override
- public Mono findById(String id) {
-
- return findSession(id) //
- .map((document) -> MongoSessionUtils.convertToSession(this.mongoSessionConverter, document)) //
- .filter((mongoSession) -> !mongoSession.isExpired()) //
- .doOnNext((mongoSession) -> mongoSession.setSessionIdGenerator(this.sessionIdGenerator))
- .switchIfEmpty(Mono.defer(() -> this.deleteById(id).then(Mono.empty())));
- }
-
- @Override
- public Mono deleteById(String id) {
-
- return findSession(id) //
- .flatMap((document) -> this.mongoOperations.remove(document, this.collectionName) //
- .then(Mono.just(document))) //
- .map((document) -> MongoSessionUtils.convertToSession(this.mongoSessionConverter, document)) //
- .doOnNext((mongoSession) -> publishEvent(new SessionDeletedEvent(this, mongoSession))) //
- .then();
- }
-
- /**
- * Do not use
- * {@link org.springframework.data.mongodb.core.index.ReactiveIndexOperations} to
- * ensure indexes exist. Instead, get a blocking {@link IndexOperations} and use that
- * instead, if possible.
- */
- @Override
- public void afterPropertiesSet() {
-
- if (this.blockingMongoOperations != null) {
-
- IndexOperations indexOperations = this.blockingMongoOperations.indexOps(this.collectionName);
- this.mongoSessionConverter.ensureIndexes(indexOperations);
- }
- }
-
- private Mono findSession(String id) {
- return this.mongoOperations.findById(id, Document.class, this.collectionName);
- }
-
- @Override
- public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
- this.eventPublisher = eventPublisher;
- }
-
- private void publishEvent(ApplicationEvent event) {
-
- try {
- this.eventPublisher.publishEvent(event);
- }
- catch (Throwable ex) {
- logger.error("Error publishing " + event + ".", ex);
- }
- }
-
- /**
- * Set the maximum inactive interval in seconds between requests before newly created
- * sessions will be invalidated. A negative time indicates that the session will never
- * time out. The default is 30 minutes.
- * @param defaultMaxInactiveInterval the default maxInactiveInterval
- */
- public void setDefaultMaxInactiveInterval(Duration defaultMaxInactiveInterval) {
- Assert.notNull(defaultMaxInactiveInterval, "defaultMaxInactiveInterval must not be null");
- this.defaultMaxInactiveInterval = defaultMaxInactiveInterval;
- }
-
- /**
- * Set the maximum inactive interval in seconds between requests before newly created
- * sessions will be invalidated. A negative time indicates that the session will never
- * time out. The default is 1800 (30 minutes).
- * @param defaultMaxInactiveInterval the default maxInactiveInterval in seconds
- * @deprecated since 3.0.0, in favor of
- * {@link #setDefaultMaxInactiveInterval(Duration)}
- */
- @Deprecated(since = "3.0.0")
- public void setMaxInactiveIntervalInSeconds(Integer defaultMaxInactiveInterval) {
- setDefaultMaxInactiveInterval(Duration.ofSeconds(defaultMaxInactiveInterval));
- }
-
- public String getCollectionName() {
- return this.collectionName;
- }
-
- public void setCollectionName(final String collectionName) {
- this.collectionName = collectionName;
- }
-
- public void setMongoSessionConverter(final AbstractMongoSessionConverter mongoSessionConverter) {
- this.mongoSessionConverter = mongoSessionConverter;
- }
-
- public void setBlockingMongoOperations(final MongoOperations blockingMongoOperations) {
- this.blockingMongoOperations = blockingMongoOperations;
- }
-
- public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
- Assert.notNull(sessionIdGenerator, "sessionIdGenerator cannot be null");
- this.sessionIdGenerator = sessionIdGenerator;
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/http/MongoHttpSessionConfiguration.java b/src/main/java/org/springframework/session/data/mongo/config/annotation/web/http/MongoHttpSessionConfiguration.java
deleted file mode 100644
index a2c7e35..0000000
--- a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/http/MongoHttpSessionConfiguration.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo.config.annotation.web.http;
-
-import java.time.Duration;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.springframework.beans.factory.BeanClassLoaderAware;
-import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.EmbeddedValueResolverAware;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.context.annotation.ImportAware;
-import org.springframework.core.annotation.AnnotationAttributes;
-import org.springframework.core.serializer.support.DeserializingConverter;
-import org.springframework.core.serializer.support.SerializingConverter;
-import org.springframework.core.type.AnnotationMetadata;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.session.IndexResolver;
-import org.springframework.session.MapSession;
-import org.springframework.session.Session;
-import org.springframework.session.SessionIdGenerator;
-import org.springframework.session.UuidSessionIdGenerator;
-import org.springframework.session.config.SessionRepositoryCustomizer;
-import org.springframework.session.config.annotation.web.http.SpringHttpSessionConfiguration;
-import org.springframework.session.data.mongo.AbstractMongoSessionConverter;
-import org.springframework.session.data.mongo.JdkMongoSessionConverter;
-import org.springframework.session.data.mongo.MongoIndexedSessionRepository;
-import org.springframework.util.StringUtils;
-import org.springframework.util.StringValueResolver;
-
-/**
- * Configuration class registering {@code MongoSessionRepository} bean. To import this
- * configuration use {@link EnableMongoHttpSession} annotation.
- *
- * @author Jakub Kubrynski
- * @author Eddú Meléndez
- * @since 1.2
- */
-@Configuration(proxyBeanMethods = false)
-@Import(SpringHttpSessionConfiguration.class)
-public class MongoHttpSessionConfiguration implements BeanClassLoaderAware, EmbeddedValueResolverAware, ImportAware {
-
- private AbstractMongoSessionConverter mongoSessionConverter;
-
- private Duration maxInactiveInterval = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL;
-
- private String collectionName;
-
- private StringValueResolver embeddedValueResolver;
-
- private List> sessionRepositoryCustomizers;
-
- private ClassLoader classLoader;
-
- private IndexResolver indexResolver;
-
- private SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
-
- @Bean
- public MongoIndexedSessionRepository mongoSessionRepository(MongoOperations mongoOperations) {
-
- MongoIndexedSessionRepository repository = new MongoIndexedSessionRepository(mongoOperations);
- repository.setDefaultMaxInactiveInterval(this.maxInactiveInterval);
-
- if (this.mongoSessionConverter != null) {
- repository.setMongoSessionConverter(this.mongoSessionConverter);
-
- if (this.indexResolver != null) {
- this.mongoSessionConverter.setIndexResolver(this.indexResolver);
- }
- }
- else {
- JdkMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(new SerializingConverter(),
- new DeserializingConverter(this.classLoader),
- Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS));
-
- if (this.indexResolver != null) {
- mongoSessionConverter.setIndexResolver(this.indexResolver);
- }
-
- repository.setMongoSessionConverter(mongoSessionConverter);
- }
-
- if (StringUtils.hasText(this.collectionName)) {
- repository.setCollectionName(this.collectionName);
- }
- repository.setSessionIdGenerator(this.sessionIdGenerator);
-
- this.sessionRepositoryCustomizers
- .forEach((sessionRepositoryCustomizer) -> sessionRepositoryCustomizer.customize(repository));
-
- return repository;
- }
-
- public void setCollectionName(String collectionName) {
- this.collectionName = collectionName;
- }
-
- public void setMaxInactiveInterval(Duration maxInactiveInterval) {
- this.maxInactiveInterval = maxInactiveInterval;
- }
-
- @Deprecated
- public void setMaxInactiveIntervalInSeconds(Integer maxInactiveIntervalInSeconds) {
- setMaxInactiveInterval(Duration.ofSeconds(maxInactiveIntervalInSeconds));
- }
-
- public void setImportMetadata(AnnotationMetadata importMetadata) {
-
- AnnotationAttributes attributes = AnnotationAttributes
- .fromMap(importMetadata.getAnnotationAttributes(EnableMongoHttpSession.class.getName()));
-
- if (attributes != null) {
- this.maxInactiveInterval = Duration
- .ofSeconds(attributes.getNumber("maxInactiveIntervalInSeconds"));
- }
-
- String collectionNameValue = (attributes != null) ? attributes.getString("collectionName") : "";
- if (StringUtils.hasText(collectionNameValue)) {
- this.collectionName = this.embeddedValueResolver.resolveStringValue(collectionNameValue);
- }
- }
-
- @Autowired(required = false)
- public void setMongoSessionConverter(AbstractMongoSessionConverter mongoSessionConverter) {
- this.mongoSessionConverter = mongoSessionConverter;
- }
-
- @Autowired(required = false)
- public void setSessionRepositoryCustomizers(
- ObjectProvider> sessionRepositoryCustomizers) {
- this.sessionRepositoryCustomizers = sessionRepositoryCustomizers.orderedStream().collect(Collectors.toList());
- }
-
- @Override
- public void setBeanClassLoader(ClassLoader classLoader) {
- this.classLoader = classLoader;
- }
-
- @Override
- public void setEmbeddedValueResolver(StringValueResolver resolver) {
- this.embeddedValueResolver = resolver;
- }
-
- @Autowired(required = false)
- public void setIndexResolver(IndexResolver indexResolver) {
- this.indexResolver = indexResolver;
- }
-
- @Autowired(required = false)
- public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
- this.sessionIdGenerator = sessionIdGenerator;
- }
-
-}
diff --git a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/reactive/ReactiveMongoWebSessionConfiguration.java b/src/main/java/org/springframework/session/data/mongo/config/annotation/web/reactive/ReactiveMongoWebSessionConfiguration.java
deleted file mode 100644
index 08d70bf..0000000
--- a/src/main/java/org/springframework/session/data/mongo/config/annotation/web/reactive/ReactiveMongoWebSessionConfiguration.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo.config.annotation.web.reactive;
-
-import java.time.Duration;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.springframework.beans.factory.BeanClassLoaderAware;
-import org.springframework.beans.factory.ObjectProvider;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.EmbeddedValueResolverAware;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.context.annotation.ImportAware;
-import org.springframework.core.annotation.AnnotationAttributes;
-import org.springframework.core.serializer.support.DeserializingConverter;
-import org.springframework.core.serializer.support.SerializingConverter;
-import org.springframework.core.type.AnnotationMetadata;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.ReactiveMongoOperations;
-import org.springframework.session.IndexResolver;
-import org.springframework.session.MapSession;
-import org.springframework.session.Session;
-import org.springframework.session.SessionIdGenerator;
-import org.springframework.session.UuidSessionIdGenerator;
-import org.springframework.session.config.ReactiveSessionRepositoryCustomizer;
-import org.springframework.session.config.annotation.web.server.SpringWebSessionConfiguration;
-import org.springframework.session.data.mongo.AbstractMongoSessionConverter;
-import org.springframework.session.data.mongo.JdkMongoSessionConverter;
-import org.springframework.session.data.mongo.ReactiveMongoSessionRepository;
-import org.springframework.util.StringUtils;
-import org.springframework.util.StringValueResolver;
-
-/**
- * Configure a {@link ReactiveMongoSessionRepository} using a provided
- * {@link ReactiveMongoOperations}.
- *
- * @author Greg Turnquist
- * @author Vedran Pavic
- */
-@Configuration(proxyBeanMethods = false)
-@Import(SpringWebSessionConfiguration.class)
-public class ReactiveMongoWebSessionConfiguration
- implements BeanClassLoaderAware, EmbeddedValueResolverAware, ImportAware {
-
- private AbstractMongoSessionConverter mongoSessionConverter;
-
- private Duration maxInactiveInterval = MapSession.DEFAULT_MAX_INACTIVE_INTERVAL;
-
- private String collectionName;
-
- private StringValueResolver embeddedValueResolver;
-
- private List> sessionRepositoryCustomizers;
-
- @Autowired(required = false)
- private MongoOperations mongoOperations;
-
- private ClassLoader classLoader;
-
- private IndexResolver indexResolver;
-
- private SessionIdGenerator sessionIdGenerator = UuidSessionIdGenerator.getInstance();
-
- @Bean
- public ReactiveMongoSessionRepository reactiveMongoSessionRepository(ReactiveMongoOperations operations) {
-
- ReactiveMongoSessionRepository repository = new ReactiveMongoSessionRepository(operations);
-
- if (this.mongoSessionConverter != null) {
- repository.setMongoSessionConverter(this.mongoSessionConverter);
-
- if (this.indexResolver != null) {
- this.mongoSessionConverter.setIndexResolver(this.indexResolver);
- }
-
- }
- else {
- JdkMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(new SerializingConverter(),
- new DeserializingConverter(this.classLoader),
- Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS));
-
- if (this.indexResolver != null) {
- mongoSessionConverter.setIndexResolver(this.indexResolver);
- }
-
- repository.setMongoSessionConverter(mongoSessionConverter);
- }
-
- repository.setDefaultMaxInactiveInterval(this.maxInactiveInterval);
-
- if (this.collectionName != null) {
- repository.setCollectionName(this.collectionName);
- }
-
- if (this.mongoOperations != null) {
- repository.setBlockingMongoOperations(this.mongoOperations);
- }
-
- this.sessionRepositoryCustomizers
- .forEach((sessionRepositoryCustomizer) -> sessionRepositoryCustomizer.customize(repository));
-
- repository.setSessionIdGenerator(this.sessionIdGenerator);
-
- return repository;
- }
-
- @Autowired(required = false)
- public void setMongoSessionConverter(AbstractMongoSessionConverter mongoSessionConverter) {
- this.mongoSessionConverter = mongoSessionConverter;
- }
-
- @Override
- public void setImportMetadata(AnnotationMetadata importMetadata) {
-
- AnnotationAttributes attributes = AnnotationAttributes
- .fromMap(importMetadata.getAnnotationAttributes(EnableMongoWebSession.class.getName()));
-
- if (attributes != null) {
- this.maxInactiveInterval = Duration
- .ofSeconds(attributes.getNumber("maxInactiveIntervalInSeconds"));
- }
-
- String collectionNameValue = (attributes != null) ? attributes.getString("collectionName") : "";
- if (StringUtils.hasText(collectionNameValue)) {
- this.collectionName = this.embeddedValueResolver.resolveStringValue(collectionNameValue);
- }
-
- }
-
- @Override
- public void setBeanClassLoader(ClassLoader classLoader) {
- this.classLoader = classLoader;
- }
-
- @Override
- public void setEmbeddedValueResolver(StringValueResolver embeddedValueResolver) {
- this.embeddedValueResolver = embeddedValueResolver;
- }
-
- public Duration getMaxInactiveInterval() {
- return this.maxInactiveInterval;
- }
-
- public void setMaxInactiveInterval(Duration maxInactiveInterval) {
- this.maxInactiveInterval = maxInactiveInterval;
- }
-
- @Deprecated
- public void setMaxInactiveIntervalInSeconds(Integer maxInactiveIntervalInSeconds) {
- setMaxInactiveInterval(Duration.ofSeconds(maxInactiveIntervalInSeconds));
- }
-
- public String getCollectionName() {
- return this.collectionName;
- }
-
- public void setCollectionName(String collectionName) {
- this.collectionName = collectionName;
- }
-
- @Autowired(required = false)
- public void setSessionRepositoryCustomizers(
- ObjectProvider> sessionRepositoryCustomizers) {
- this.sessionRepositoryCustomizers = sessionRepositoryCustomizers.orderedStream().collect(Collectors.toList());
- }
-
- @Autowired(required = false)
- public void setIndexResolver(IndexResolver indexResolver) {
- this.indexResolver = indexResolver;
- }
-
- @Autowired(required = false)
- public void setSessionIdGenerator(SessionIdGenerator sessionIdGenerator) {
- this.sessionIdGenerator = sessionIdGenerator;
- }
-
-}
diff --git a/src/test/java/org/mongodb/spring/session/AbstractMongoSessionConverterTests.java b/src/test/java/org/mongodb/spring/session/AbstractMongoSessionConverterTests.java
new file mode 100644
index 0000000..767682f
--- /dev/null
+++ b/src/test/java/org/mongodb/spring/session/AbstractMongoSessionConverterTests.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.mongodb.DBObject;
+import java.time.Duration;
+import org.bson.Document;
+import org.junit.jupiter.api.Test;
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.lang.Nullable;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextImpl;
+import org.springframework.session.FindByIndexNameSessionRepository;
+
+/** @author Greg Turnquist */
+public abstract class AbstractMongoSessionConverterTests {
+
+ abstract AbstractMongoSessionConverter getMongoSessionConverter();
+
+ @Test
+ void verifyRoundTripSerialization() throws Exception {
+
+ // given
+ MongoSession toSerialize = new MongoSession();
+ toSerialize.setAttribute("username", "john_the_springer");
+
+ // when
+ DBObject dbObject = convertToDBObject(toSerialize);
+ MongoSession deserialized = convertToSession(dbObject);
+
+ // then
+ assertThat(deserialized).usingRecursiveComparison().isEqualTo(toSerialize);
+ }
+
+ @Test
+ void verifyRoundTripSecuritySerialization() {
+
+ // given
+ MongoSession toSerialize = new MongoSession();
+ String principalName = "john_the_springer";
+ SecurityContextImpl context = new SecurityContextImpl();
+ context.setAuthentication(new UsernamePasswordAuthenticationToken(principalName, null));
+ toSerialize.setAttribute("SPRING_SECURITY_CONTEXT", context);
+
+ // when
+ DBObject serialized = convertToDBObject(toSerialize);
+ MongoSession deserialized = convertToSession(serialized);
+
+ // then
+ assertThat(deserialized).usingRecursiveComparison().isEqualTo(toSerialize);
+
+ SecurityContextImpl springSecurityContextBefore = toSerialize.getAttribute("SPRING_SECURITY_CONTEXT");
+ SecurityContextImpl springSecurityContextAfter = deserialized.getAttribute("SPRING_SECURITY_CONTEXT");
+
+ assertThat(springSecurityContextBefore).usingRecursiveComparison().isEqualTo(springSecurityContextAfter);
+ assertThat(springSecurityContextAfter.getAuthentication().getPrincipal())
+ .isEqualTo("john_the_springer");
+ assertThat(springSecurityContextAfter.getAuthentication().getCredentials())
+ .isNull();
+ }
+
+ @Test
+ void shouldExtractPrincipalNameFromAttributes() throws Exception {
+
+ // given
+ MongoSession toSerialize = new MongoSession();
+ String principalName = "john_the_springer";
+ toSerialize.setAttribute(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, principalName);
+
+ // when
+ DBObject dbObject = convertToDBObject(toSerialize);
+
+ // then
+ assertThat(dbObject.get("principal")).isEqualTo(principalName);
+ }
+
+ @Test
+ void shouldExtractPrincipalNameFromAuthentication() throws Exception {
+
+ // given
+ MongoSession toSerialize = new MongoSession();
+ String principalName = "john_the_springer";
+ SecurityContextImpl context = new SecurityContextImpl();
+ context.setAuthentication(new UsernamePasswordAuthenticationToken(principalName, null));
+ toSerialize.setAttribute("SPRING_SECURITY_CONTEXT", context);
+
+ // when
+ DBObject dbObject = convertToDBObject(toSerialize);
+
+ // then
+ assertThat(dbObject.get("principal")).isEqualTo(principalName);
+ }
+
+ @Test
+ void sessionWrapperWithNoMaxIntervalShouldFallbackToDefaultValues() {
+
+ // given
+ MongoSession toSerialize = new MongoSession();
+ DBObject dbObject = convertToDBObject(toSerialize);
+ Document document = new Document(dbObject.toMap());
+ document.remove("interval");
+
+ // when
+ MongoSession convertedSession = getMongoSessionConverter().convert(document);
+
+ // then
+ assertThat(convertedSession.getMaxInactiveInterval()).isEqualTo(Duration.ofMinutes(30));
+ }
+
+ @Nullable MongoSession convertToSession(DBObject session) {
+ return (MongoSession) getMongoSessionConverter()
+ .convert(session, TypeDescriptor.valueOf(DBObject.class), TypeDescriptor.valueOf(MongoSession.class));
+ }
+
+ @Nullable DBObject convertToDBObject(MongoSession session) {
+ return (DBObject) getMongoSessionConverter()
+ .convert(session, TypeDescriptor.valueOf(MongoSession.class), TypeDescriptor.valueOf(DBObject.class));
+ }
+}
diff --git a/src/test/java/org/mongodb/spring/session/JacksonMongoSessionConverterTests.java b/src/test/java/org/mongodb/spring/session/JacksonMongoSessionConverterTests.java
new file mode 100644
index 0000000..107ba4a
--- /dev/null
+++ b/src/test/java/org/mongodb/spring/session/JacksonMongoSessionConverterTests.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.mongodb.DBObject;
+import java.lang.reflect.Field;
+import java.util.Date;
+import java.util.HashMap;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.api.AssertionsForClassTypes;
+import org.bson.Document;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.Test;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * @author Jakub Kubrynski
+ * @author Greg Turnquist
+ */
+class JacksonMongoSessionConverterTests extends AbstractMongoSessionConverterTests {
+
+ JacksonMongoSessionConverter mongoSessionConverter = new JacksonMongoSessionConverter();
+
+ @Override
+ AbstractMongoSessionConverter getMongoSessionConverter() {
+ return this.mongoSessionConverter;
+ }
+
+ @Test
+ void shouldSaveIdField() {
+
+ // given
+ MongoSession session = new MongoSession();
+
+ // when
+ DBObject convert = this.mongoSessionConverter.convert(session);
+
+ // then
+ AssertionsForClassTypes.assertThat(convert.get("_id")).isEqualTo(session.getId());
+ AssertionsForClassTypes.assertThat(convert.get("id")).isNull();
+ }
+
+ @Test
+ void shouldQueryAgainstAttribute() throws Exception {
+
+ // when
+ Query cart = this.mongoSessionConverter.getQueryForIndex("cart", "my-cart");
+
+ // then
+ AssertionsForClassTypes.assertThat(cart.getQueryObject().get("attrs.cart"))
+ .isEqualTo("my-cart");
+ }
+
+ @Test
+ void shouldAllowCustomObjectMapper() {
+
+ // given
+ ObjectMapper myMapper = new ObjectMapper();
+
+ // when
+ JacksonMongoSessionConverter converter = new JacksonMongoSessionConverter(myMapper);
+
+ // then
+ Field objectMapperField = ReflectionUtils.findField(JacksonMongoSessionConverter.class, "objectMapper");
+ ReflectionUtils.makeAccessible(objectMapperField);
+ ObjectMapper converterMapper = (ObjectMapper) ReflectionUtils.getField(objectMapperField, converter);
+
+ AssertionsForClassTypes.assertThat(converterMapper).isEqualTo(myMapper);
+ }
+
+ @Test
+ void shouldNotAllowNullObjectMapperToBeInjected() {
+
+ Assertions.assertThatIllegalArgumentException()
+ .isThrownBy(() -> new JacksonMongoSessionConverter((ObjectMapper) null));
+ }
+
+ @Test
+ void shouldSaveExpireAtAsDate() {
+
+ // given
+ MongoSession session = new MongoSession();
+
+ // when
+ DBObject convert = this.mongoSessionConverter.convert(session);
+
+ // then
+ AssertionsForClassTypes.assertThat(convert.get("expireAt")).isInstanceOf(Date.class);
+ AssertionsForClassTypes.assertThat(convert.get("expireAt")).isEqualTo(session.getExpireAt());
+ }
+
+ @Test
+ void shouldLoadExpireAtFromDocument() {
+
+ // given
+ Date now = new Date();
+ HashMap data = new HashMap<>();
+
+ data.put("expireAt", now);
+ data.put("@class", MongoSession.class.getName());
+ data.put("_id", new ObjectId().toString());
+
+ Document document = new Document(data);
+
+ // when
+ MongoSession convertedSession = this.mongoSessionConverter.convert(document);
+
+ // then
+ AssertionsForClassTypes.assertThat(convertedSession).isNotNull();
+ AssertionsForClassTypes.assertThat(convertedSession.getExpireAt()).isEqualTo(now);
+ }
+}
diff --git a/src/test/java/org/springframework/session/data/mongo/JdkMongoSessionConverterTests.java b/src/test/java/org/mongodb/spring/session/JdkMongoSessionConverterTests.java
similarity index 53%
rename from src/test/java/org/springframework/session/data/mongo/JdkMongoSessionConverterTests.java
rename to src/test/java/org/mongodb/spring/session/JdkMongoSessionConverterTests.java
index af4b5de..6415cf0 100644
--- a/src/test/java/org/springframework/session/data/mongo/JdkMongoSessionConverterTests.java
+++ b/src/test/java/org/mongodb/spring/session/JdkMongoSessionConverterTests.java
@@ -1,11 +1,12 @@
/*
+ * Copyright 2025-present MongoDB, Inc.
* Copyright 2014-present the original author or authors.
*
* Licensed 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
*
- * https://www.apache.org/licenses/LICENSE-2.0
+ * 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,
@@ -14,17 +15,15 @@
* limitations under the License.
*/
-package org.springframework.session.data.mongo;
+package org.mongodb.spring.session;
-import java.time.Duration;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import java.time.Duration;
import org.junit.jupiter.api.Test;
-
import org.springframework.core.serializer.support.DeserializingConverter;
import org.springframework.core.serializer.support.SerializingConverter;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-
/**
* @author Jakub Kubrynski
* @author Rob Winch
@@ -32,25 +31,26 @@
*/
class JdkMongoSessionConverterTests extends AbstractMongoSessionConverterTests {
- Duration inactiveInterval = Duration.ofMinutes(30);
-
- JdkMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(this.inactiveInterval);
+ Duration inactiveInterval = Duration.ofMinutes(30);
- @Override
- AbstractMongoSessionConverter getMongoSessionConverter() {
- return this.mongoSessionConverter;
- }
+ JdkMongoSessionConverter mongoSessionConverter = new JdkMongoSessionConverter(this.inactiveInterval);
- @Test
- void constructorNullSerializer() {
- assertThatIllegalArgumentException()
- .isThrownBy(() -> new JdkMongoSessionConverter(null, new DeserializingConverter(), this.inactiveInterval));
- }
+ @Override
+ AbstractMongoSessionConverter getMongoSessionConverter() {
+ return this.mongoSessionConverter;
+ }
- @Test
- void constructorNullDeserializer() {
- assertThatIllegalArgumentException()
- .isThrownBy(() -> new JdkMongoSessionConverter(new SerializingConverter(), null, this.inactiveInterval));
- }
+ @Test
+ void constructorNullSerializer() {
+ assertThatIllegalArgumentException()
+ .isThrownBy(
+ () -> new JdkMongoSessionConverter(null, new DeserializingConverter(), this.inactiveInterval));
+ }
+ @Test
+ void constructorNullDeserializer() {
+ assertThatIllegalArgumentException()
+ .isThrownBy(
+ () -> new JdkMongoSessionConverter(new SerializingConverter(), null, this.inactiveInterval));
+ }
}
diff --git a/src/test/java/org/mongodb/spring/session/MongoIndexedSessionRepositoryTests.java b/src/test/java/org/mongodb/spring/session/MongoIndexedSessionRepositoryTests.java
new file mode 100644
index 0000000..084da6e
--- /dev/null
+++ b/src/test/java/org/mongodb/spring/session/MongoIndexedSessionRepositoryTests.java
@@ -0,0 +1,290 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.mock;
+import static org.mockito.BDDMockito.verify;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Collections;
+import java.util.Map;
+import java.util.UUID;
+import org.bson.Document;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.session.FindByIndexNameSessionRepository;
+import org.springframework.session.MapSession;
+import org.springframework.session.SessionIdGenerator;
+
+/**
+ * Tests for {@link MongoIndexedSessionRepository}.
+ *
+ * @author Jakub Kubrynski
+ * @author Vedran Pavic
+ * @author Greg Turnquist
+ */
+@ExtendWith(MockitoExtension.class)
+class MongoIndexedSessionRepositoryTests {
+
+ @Mock
+ private AbstractMongoSessionConverter converter;
+
+ @Mock
+ private MongoOperations mongoOperations;
+
+ private MongoIndexedSessionRepository repository;
+
+ @BeforeEach
+ void setUp() {
+
+ this.repository = new MongoIndexedSessionRepository(this.mongoOperations);
+ this.repository.setMongoSessionConverter(this.converter);
+ }
+
+ @Test
+ void shouldCreateSession() {
+
+ // when
+ MongoSession session = this.repository.createSession();
+
+ // then
+ assertThat(session.getId()).isNotEmpty();
+ assertThat(session.getMaxInactiveInterval().getSeconds())
+ .isEqualTo(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
+ }
+
+ @Test
+ void shouldSaveSession() {
+
+ // given
+ MongoSession session = new MongoSession();
+ BasicDBObject dbSession = new BasicDBObject();
+
+ given(this.converter.convert(
+ session, TypeDescriptor.valueOf(MongoSession.class), TypeDescriptor.valueOf(DBObject.class)))
+ .willReturn(dbSession);
+ // when
+ this.repository.save(session);
+
+ // then
+ verify(this.mongoOperations).save(dbSession, MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME);
+ }
+
+ @Test
+ void shouldGetSession() {
+
+ // given
+ String sessionId = UUID.randomUUID().toString();
+ Document sessionDocument = new Document();
+
+ given(this.mongoOperations.findById(
+ sessionId, Document.class, MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(sessionDocument);
+
+ MongoSession session = new MongoSession();
+
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+
+ // when
+ MongoSession retrievedSession = this.repository.findById(sessionId);
+
+ // then
+ assertThat(retrievedSession).isEqualTo(session);
+ }
+
+ @Test
+ void shouldHandleExpiredSession() {
+
+ // given
+ String sessionId = UUID.randomUUID().toString();
+ Document sessionDocument = new Document();
+
+ given(this.mongoOperations.findById(
+ sessionId, Document.class, MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(sessionDocument);
+
+ MongoSession session = mock(MongoSession.class);
+
+ given(session.isExpired()).willReturn(true);
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+ given(session.getId()).willReturn("sessionId");
+
+ // when
+ this.repository.findById(sessionId);
+
+ // then
+ verify(this.mongoOperations)
+ .remove(any(Document.class), eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME));
+ }
+
+ @Test
+ void shouldDeleteSession() {
+
+ // given
+ String sessionId = UUID.randomUUID().toString();
+
+ Document sessionDocument = new Document();
+ sessionDocument.put("id", sessionId);
+
+ MongoSession mongoSession = new MongoSession(sessionId, MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
+
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(mongoSession);
+ given(this.mongoOperations.findById(
+ eq(sessionId), eq(Document.class), eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME)))
+ .willReturn(sessionDocument);
+
+ // when
+ this.repository.deleteById(sessionId);
+
+ // then
+ verify(this.mongoOperations)
+ .remove(any(Document.class), eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME));
+ }
+
+ @Test
+ void shouldGetSessionsMapByPrincipal() {
+
+ // given
+ String principalNameIndexName = FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME;
+
+ Document document = new Document();
+
+ given(this.converter.getQueryForIndex(anyString(), any(Object.class))).willReturn(mock(Query.class));
+ given(this.mongoOperations.find(
+ any(Query.class),
+ eq(Document.class),
+ eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME)))
+ .willReturn(Collections.singletonList(document));
+
+ String sessionId = UUID.randomUUID().toString();
+
+ MongoSession session = new MongoSession(sessionId, 1800);
+
+ given(this.converter.convert(
+ document, TypeDescriptor.valueOf(Document.class), TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+
+ // when
+ Map sessionsMap =
+ this.repository.findByIndexNameAndIndexValue(principalNameIndexName, "john");
+
+ // then
+ assertThat(sessionsMap).containsOnlyKeys(sessionId);
+ assertThat(sessionsMap).containsValues(session);
+ }
+
+ @Test
+ void shouldReturnEmptyMapForNotSupportedIndex() {
+
+ // given
+ String index = "some_not_supported_index_name";
+
+ // when
+ Map sessionsMap = this.repository.findByIndexNameAndIndexValue(index, "some_value");
+
+ // then
+ assertThat(sessionsMap).isEmpty();
+ }
+
+ @Test
+ void createSessionWhenSessionIdGeneratorThenUses() {
+ this.repository.setSessionIdGenerator(new FixedSessionIdGenerator("123"));
+ MongoSession session = this.repository.createSession();
+ assertThat(session.getId()).isEqualTo("123");
+ assertThat(session.changeSessionId()).isEqualTo("123");
+ }
+
+ @Test
+ void setSessionIdGeneratorWhenNullThenThrowsException() {
+ assertThatIllegalArgumentException().isThrownBy(() -> this.repository.setSessionIdGenerator(null));
+ }
+
+ @Test
+ void findByIdWhenChangeSessionIdThenUsesSessionIdGenerator() {
+ this.repository.setSessionIdGenerator(new FixedSessionIdGenerator("456"));
+
+ Document sessionDocument = new Document();
+
+ given(this.mongoOperations.findById(
+ "123", Document.class, MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(sessionDocument);
+
+ MongoSession session = new MongoSession("123");
+
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+
+ MongoSession retrievedSession = this.repository.findById("123");
+ assertThat(retrievedSession.getId()).isEqualTo("123");
+ String newSessionId = retrievedSession.changeSessionId();
+ assertThat(newSessionId).isEqualTo("456");
+ }
+
+ @Test
+ void createSessionWhenMaxInactiveIntervalSetThenUse() {
+ this.repository.setDefaultMaxInactiveInterval(Duration.ofSeconds(60));
+ MongoSession session = this.repository.createSession();
+ Instant now = Instant.now();
+ assertThat(session.getExpireAt())
+ .isBetween(now.plusSeconds(59), Instant.now().plusSeconds(61));
+ }
+
+ static class FixedSessionIdGenerator implements SessionIdGenerator {
+
+ private final String id;
+
+ FixedSessionIdGenerator(String id) {
+ this.id = id;
+ }
+
+ @Override
+ public String generate() {
+ return this.id;
+ }
+ }
+}
diff --git a/src/test/java/org/springframework/session/data/mongo/MongoSessionTests.java b/src/test/java/org/mongodb/spring/session/MongoSessionTests.java
similarity index 65%
rename from src/test/java/org/springframework/session/data/mongo/MongoSessionTests.java
rename to src/test/java/org/mongodb/spring/session/MongoSessionTests.java
index 6992fce..6ca08bd 100644
--- a/src/test/java/org/springframework/session/data/mongo/MongoSessionTests.java
+++ b/src/test/java/org/mongodb/spring/session/MongoSessionTests.java
@@ -1,11 +1,12 @@
/*
+ * Copyright 2025-present MongoDB, Inc.
* Copyright 2014-present the original author or authors.
*
* Licensed 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
*
- * https://www.apache.org/licenses/LICENSE-2.0
+ * 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,
@@ -14,29 +15,27 @@
* limitations under the License.
*/
-package org.springframework.session.data.mongo;
+package org.mongodb.spring.session;
+
+import static org.assertj.core.api.Assertions.assertThat;
import java.time.Duration;
import java.time.Instant;
-
import org.junit.jupiter.api.Test;
-import static org.assertj.core.api.Assertions.assertThat;
-
/**
* @author Rob Winch
* @author Greg Turnquist
*/
class MongoSessionTests {
- @Test
- void isExpiredWhenIntervalNegativeThenFalse() {
-
- MongoSession session = new MongoSession();
- session.setMaxInactiveInterval(Duration.ofSeconds(-1));
- session.setLastAccessedTime(Instant.ofEpochMilli(0L));
+ @Test
+ void isExpiredWhenIntervalNegativeThenFalse() {
- assertThat(session.isExpired()).isFalse();
- }
+ MongoSession session = new MongoSession();
+ session.setMaxInactiveInterval(Duration.ofSeconds(-1));
+ session.setLastAccessedTime(Instant.ofEpochMilli(0L));
+ assertThat(session.isExpired()).isFalse();
+ }
}
diff --git a/src/test/java/org/mongodb/spring/session/ReactiveMongoSessionRepositoryTests.java b/src/test/java/org/mongodb/spring/session/ReactiveMongoSessionRepositoryTests.java
new file mode 100644
index 0000000..b006674
--- /dev/null
+++ b/src/test/java/org/mongodb/spring/session/ReactiveMongoSessionRepositoryTests.java
@@ -0,0 +1,292 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.mockito.BDDMockito.any;
+import static org.mockito.BDDMockito.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.mock;
+import static org.mockito.BDDMockito.times;
+import static org.mockito.BDDMockito.verify;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+import com.mongodb.client.result.DeleteResult;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.UUID;
+import org.bson.Document;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.ReactiveMongoOperations;
+import org.springframework.data.mongodb.core.index.IndexOperations;
+import org.springframework.session.MapSession;
+import org.springframework.session.events.SessionDeletedEvent;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+/**
+ * Tests for {@link ReactiveMongoSessionRepository}.
+ *
+ * @author Jakub Kubrynski
+ * @author Vedran Pavic
+ * @author Greg Turnquist
+ */
+@ExtendWith(MockitoExtension.class)
+class ReactiveMongoSessionRepositoryTests {
+
+ @Mock
+ private AbstractMongoSessionConverter converter;
+
+ @Mock
+ private ReactiveMongoOperations mongoOperations;
+
+ @Mock
+ private MongoOperations blockingMongoOperations;
+
+ @Mock
+ private ApplicationEventPublisher eventPublisher;
+
+ private ReactiveMongoSessionRepository repository;
+
+ @BeforeEach
+ void setUp() {
+
+ this.repository = new ReactiveMongoSessionRepository(this.mongoOperations);
+ this.repository.setMongoSessionConverter(this.converter);
+ this.repository.setApplicationEventPublisher(this.eventPublisher);
+ }
+
+ @Test
+ void shouldCreateSession() {
+
+ this.repository
+ .createSession() //
+ .as(StepVerifier::create) //
+ .expectNextMatches((mongoSession) -> {
+ assertThat(mongoSession.getId()).isNotEmpty();
+ assertThat(mongoSession.getMaxInactiveInterval())
+ .isEqualTo(Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS));
+ return true;
+ }) //
+ .verifyComplete();
+ }
+
+ @Test
+ void shouldSaveSession() {
+
+ // given
+ MongoSession session = new MongoSession();
+ BasicDBObject dbSession = new BasicDBObject();
+
+ given(this.converter.convert(
+ session, TypeDescriptor.valueOf(MongoSession.class), TypeDescriptor.valueOf(DBObject.class)))
+ .willReturn(dbSession);
+
+ given(this.mongoOperations.save(dbSession, "sessions")).willReturn(Mono.just(dbSession));
+
+ // when
+ this.repository
+ .save(session) //
+ .as(StepVerifier::create) //
+ .verifyComplete();
+
+ verify(this.mongoOperations).save(dbSession, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME);
+ }
+
+ @Test
+ void shouldGetSession() {
+
+ // given
+ String sessionId = UUID.randomUUID().toString();
+ Document sessionDocument = new Document();
+
+ given(this.mongoOperations.findById(
+ sessionId, Document.class, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(Mono.just(sessionDocument));
+
+ MongoSession session = new MongoSession();
+
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+
+ // when
+ this.repository
+ .findById(sessionId) //
+ .as(StepVerifier::create) //
+ .expectNext(session) //
+ .verifyComplete();
+ }
+
+ @Test
+ void shouldHandleExpiredSession() {
+
+ // given
+ String sessionId = UUID.randomUUID().toString();
+ Document sessionDocument = new Document();
+
+ given(this.mongoOperations.findById(
+ sessionId, Document.class, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(Mono.just(sessionDocument));
+
+ given(this.mongoOperations.remove(sessionDocument, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(Mono.just(DeleteResult.acknowledged(1)));
+
+ MongoSession session = mock(MongoSession.class);
+
+ given(session.isExpired()).willReturn(true);
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+
+ // when
+ this.repository
+ .findById(sessionId) //
+ .as(StepVerifier::create) //
+ .verifyComplete();
+
+ // then
+ verify(this.mongoOperations)
+ .remove(any(Document.class), eq(ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME));
+ }
+
+ @Test
+ void shouldDeleteSession() {
+
+ // given
+ String sessionId = UUID.randomUUID().toString();
+ Document sessionDocument = new Document();
+
+ given(this.mongoOperations.findById(
+ sessionId, Document.class, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(Mono.just(sessionDocument));
+
+ given(this.mongoOperations.remove(sessionDocument, "sessions"))
+ .willReturn(Mono.just(DeleteResult.acknowledged(1)));
+
+ MongoSession session = mock(MongoSession.class);
+
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+
+ // when
+ this.repository
+ .deleteById(sessionId) //
+ .as(StepVerifier::create) //
+ .verifyComplete();
+
+ verify(this.mongoOperations)
+ .remove(any(Document.class), eq(ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME));
+
+ verify(this.eventPublisher).publishEvent(any(SessionDeletedEvent.class));
+ }
+
+ @Test
+ void shouldInvokeMethodToCreateIndexesImperatively() {
+
+ // given
+ IndexOperations indexOperations = mock(IndexOperations.class);
+ given(this.blockingMongoOperations.indexOps((String) any())).willReturn(indexOperations);
+
+ this.repository.setBlockingMongoOperations(this.blockingMongoOperations);
+
+ // when
+ this.repository.afterPropertiesSet();
+
+ // then
+ verify(this.blockingMongoOperations, times(1)).indexOps((String) any());
+ verify(this.converter, times(1)).ensureIndexes(indexOperations);
+ }
+
+ @Test
+ void createSessionWhenSessionIdGeneratorThenUses() {
+ this.repository.setSessionIdGenerator(() -> "test");
+
+ this.repository
+ .createSession()
+ .as(StepVerifier::create)
+ .assertNext((mongoSession) -> {
+ assertThat(mongoSession.getId()).isEqualTo("test");
+ assertThat(mongoSession.changeSessionId()).isEqualTo("test");
+ })
+ .verifyComplete();
+ }
+
+ @Test
+ void setSessionIdGeneratorWhenNullThenThrowsException() {
+ assertThatIllegalArgumentException()
+ .isThrownBy(() -> this.repository.setSessionIdGenerator(null))
+ .withMessage("sessionIdGenerator cannot be null");
+ }
+
+ @Test
+ void findByIdWhenChangeSessionIdThenUsesSessionIdGenerator() {
+ this.repository.setSessionIdGenerator(() -> "test");
+
+ String sessionId = UUID.randomUUID().toString();
+ Document sessionDocument = new Document();
+
+ given(this.mongoOperations.findById(
+ sessionId, Document.class, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
+ .willReturn(Mono.just(sessionDocument));
+
+ MongoSession session = new MongoSession(sessionId);
+
+ given(this.converter.convert(
+ sessionDocument,
+ TypeDescriptor.valueOf(Document.class),
+ TypeDescriptor.valueOf(MongoSession.class)))
+ .willReturn(session);
+
+ this.repository
+ .findById(sessionId)
+ .as(StepVerifier::create)
+ .assertNext((mongoSession) -> {
+ String oldId = mongoSession.getId();
+ String newId = mongoSession.changeSessionId();
+ assertThat(oldId).isEqualTo(sessionId);
+ assertThat(newId).isEqualTo("test");
+ })
+ .verifyComplete();
+ }
+
+ @Test
+ void createSessionWhenMaxInactiveIntervalSetThenUse() {
+ this.repository.setDefaultMaxInactiveInterval(Duration.ofSeconds(60));
+ MongoSession session = this.repository.createSession().block();
+ Instant now = Instant.now();
+ assertThat(session.getExpireAt())
+ .isBetween(now.plusSeconds(59), Instant.now().plusSeconds(61));
+ }
+}
diff --git a/src/test/java/org/mongodb/spring/session/config/annotation/web/http/MongoHttpSessionConfigurationTests.java b/src/test/java/org/mongodb/spring/session/config/annotation/web/http/MongoHttpSessionConfigurationTests.java
new file mode 100644
index 0000000..6a09df6
--- /dev/null
+++ b/src/test/java/org/mongodb/spring/session/config/annotation/web/http/MongoHttpSessionConfigurationTests.java
@@ -0,0 +1,373 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session.config.annotation.web.http;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.mock;
+
+import java.net.UnknownHostException;
+import java.time.Duration;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.mongodb.spring.session.AbstractMongoSessionConverter;
+import org.mongodb.spring.session.JacksonMongoSessionConverter;
+import org.mongodb.spring.session.MongoIndexedSessionRepository;
+import org.springframework.beans.factory.UnsatisfiedDependencyException;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.index.IndexOperations;
+import org.springframework.mock.env.MockEnvironment;
+import org.springframework.session.IndexResolver;
+import org.springframework.session.Session;
+import org.springframework.session.SessionIdGenerator;
+import org.springframework.session.UuidSessionIdGenerator;
+import org.springframework.session.config.SessionRepositoryCustomizer;
+import org.springframework.test.util.ReflectionTestUtils;
+
+/**
+ * Tests for {@link MongoHttpSessionConfiguration}.
+ *
+ * @author Eddú Meléndez
+ * @author Vedran Pavic
+ */
+class MongoHttpSessionConfigurationTests {
+
+ private static final String COLLECTION_NAME = "testSessions";
+
+ private static final int MAX_INACTIVE_INTERVAL_IN_SECONDS = 600;
+
+ private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
+
+ @AfterEach
+ void after() {
+
+ if (this.context != null) {
+ this.context.close();
+ }
+ }
+
+ @Test
+ void noMongoOperationsConfiguration() {
+
+ assertThatExceptionOfType(UnsatisfiedDependencyException.class)
+ .isThrownBy(() -> registerAndRefresh(EmptyConfiguration.class))
+ .withMessageContaining("mongoSessionRepository");
+ }
+
+ @Test
+ void defaultConfiguration() {
+
+ registerAndRefresh(DefaultConfiguration.class);
+
+ assertThat(this.context.getBean(MongoIndexedSessionRepository.class)).isNotNull();
+ }
+
+ @Test
+ void customCollectionName() {
+
+ registerAndRefresh(CustomCollectionNameConfiguration.class);
+
+ MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
+
+ assertThat(repository).isNotNull();
+ assertThat(ReflectionTestUtils.getField(repository, "collectionName")).isEqualTo(COLLECTION_NAME);
+ }
+
+ @Test
+ void setCustomCollectionName() {
+
+ registerAndRefresh(CustomCollectionNameSetConfiguration.class);
+
+ MongoHttpSessionConfiguration session = this.context.getBean(MongoHttpSessionConfiguration.class);
+
+ assertThat(session).isNotNull();
+ assertThat(ReflectionTestUtils.getField(session, "collectionName")).isEqualTo(COLLECTION_NAME);
+ }
+
+ @Test
+ void customMaxInactiveIntervalInSeconds() {
+
+ registerAndRefresh(CustomMaxInactiveIntervalInSecondsConfiguration.class);
+
+ MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
+
+ assertThat(repository)
+ .extracting("defaultMaxInactiveInterval")
+ .isEqualTo(Duration.ofSeconds(MAX_INACTIVE_INTERVAL_IN_SECONDS));
+ }
+
+ @Test
+ void setCustomMaxInactiveIntervalInSeconds() {
+
+ registerAndRefresh(CustomMaxInactiveIntervalInSecondsSetConfiguration.class);
+
+ MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
+
+ assertThat(repository)
+ .extracting("defaultMaxInactiveInterval")
+ .isEqualTo(Duration.ofSeconds(MAX_INACTIVE_INTERVAL_IN_SECONDS));
+ }
+
+ @Test
+ void setCustomSessionConverterConfiguration() {
+
+ registerAndRefresh(CustomSessionConverterConfiguration.class);
+
+ MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
+ AbstractMongoSessionConverter mongoSessionConverter = this.context.getBean(AbstractMongoSessionConverter.class);
+
+ assertThat(repository).isNotNull();
+ assertThat(mongoSessionConverter).isNotNull();
+ assertThat(ReflectionTestUtils.getField(repository, "mongoSessionConverter"))
+ .isEqualTo(mongoSessionConverter);
+ }
+
+ @Test
+ void resolveCollectionNameByPropertyPlaceholder() {
+
+ this.context.setEnvironment(
+ new MockEnvironment().withProperty("session.mongo.collectionName", COLLECTION_NAME));
+ registerAndRefresh(CustomMongoJdbcSessionConfiguration.class);
+
+ MongoHttpSessionConfiguration configuration = this.context.getBean(MongoHttpSessionConfiguration.class);
+
+ assertThat(ReflectionTestUtils.getField(configuration, "collectionName"))
+ .isEqualTo(COLLECTION_NAME);
+ }
+
+ @Test
+ void sessionRepositoryCustomizer() {
+
+ registerAndRefresh(MongoConfiguration.class, SessionRepositoryCustomizerConfiguration.class);
+
+ MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
+
+ assertThat(sessionRepository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(10000));
+ }
+
+ @Test
+ void customIndexResolverConfigurationWithDefaultMongoSessionConverter() {
+
+ registerAndRefresh(
+ MongoConfiguration.class, CustomIndexResolverConfigurationWithDefaultMongoSessionConverter.class);
+
+ MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
+ IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
+
+ assertThat(repository).isNotNull();
+ assertThat(indexResolver).isNotNull();
+ assertThat(repository)
+ .extracting("mongoSessionConverter")
+ .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
+ }
+
+ @Test
+ void customIndexResolverConfigurationWithProvidedMongoSessionConverter() {
+
+ registerAndRefresh(
+ MongoConfiguration.class, CustomIndexResolverConfigurationWithProvidedMongoSessionConverter.class);
+
+ MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
+ IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
+
+ assertThat(repository).isNotNull();
+ assertThat(indexResolver).isNotNull();
+ assertThat(repository)
+ .extracting("mongoSessionConverter")
+ .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
+ }
+
+ @Test
+ void importConfigAndCustomize() {
+ registerAndRefresh(ImportConfigAndCustomizeConfiguration.class);
+ MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
+ assertThat(sessionRepository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ZERO);
+ }
+
+ @Test
+ void registerWhenSessionIdGeneratorBeanThenUses() {
+ registerAndRefresh(SessionIdGeneratorConfiguration.class);
+ MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
+ assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(TestSessionIdGenerator.class);
+ }
+
+ @Test
+ void registerWhenNoSessionIdGeneratorBeanThenDefault() {
+ registerAndRefresh(DefaultConfiguration.class);
+ MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
+ assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(UuidSessionIdGenerator.class);
+ }
+
+ private void registerAndRefresh(Class... annotatedClasses) {
+
+ this.context.register(annotatedClasses);
+ this.context.refresh();
+ }
+
+ @Configuration
+ @EnableMongoHttpSession
+ static class EmptyConfiguration {}
+
+ static class BaseConfiguration {
+
+ @Bean
+ MongoOperations mongoOperations() throws UnknownHostException {
+
+ MongoOperations mongoOperations = mock(MongoOperations.class);
+ IndexOperations indexOperations = mock(IndexOperations.class);
+
+ given(mongoOperations.indexOps(anyString())).willReturn(indexOperations);
+
+ return mongoOperations;
+ }
+ }
+
+ @Configuration
+ @EnableMongoHttpSession
+ static class DefaultConfiguration extends BaseConfiguration {}
+
+ @Configuration
+ static class MongoConfiguration extends BaseConfiguration {}
+
+ @Configuration
+ @EnableMongoHttpSession(collectionName = COLLECTION_NAME)
+ static class CustomCollectionNameConfiguration extends BaseConfiguration {}
+
+ @Configuration
+ @Import(MongoConfiguration.class)
+ static class CustomCollectionNameSetConfiguration extends MongoHttpSessionConfiguration {
+
+ CustomCollectionNameSetConfiguration() {
+ setCollectionName(COLLECTION_NAME);
+ }
+ }
+
+ @Configuration
+ @EnableMongoHttpSession(maxInactiveIntervalInSeconds = MAX_INACTIVE_INTERVAL_IN_SECONDS)
+ static class CustomMaxInactiveIntervalInSecondsConfiguration extends BaseConfiguration {}
+
+ @Configuration
+ @Import(MongoConfiguration.class)
+ static class CustomMaxInactiveIntervalInSecondsSetConfiguration extends MongoHttpSessionConfiguration {
+
+ CustomMaxInactiveIntervalInSecondsSetConfiguration() {
+ setMaxInactiveInterval(Duration.ofSeconds(MAX_INACTIVE_INTERVAL_IN_SECONDS));
+ }
+ }
+
+ @Configuration
+ @Import(MongoConfiguration.class)
+ static class CustomSessionConverterConfiguration extends MongoHttpSessionConfiguration {
+
+ @Bean
+ AbstractMongoSessionConverter mongoSessionConverter() {
+ return mock(AbstractMongoSessionConverter.class);
+ }
+ }
+
+ @Configuration
+ @EnableMongoHttpSession(collectionName = "${session.mongo.collectionName}")
+ static class CustomMongoJdbcSessionConfiguration extends BaseConfiguration {
+
+ @Bean
+ PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
+ return new PropertySourcesPlaceholderConfigurer();
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoHttpSession
+ static class SessionRepositoryCustomizerConfiguration {
+
+ @Bean
+ @Order(0)
+ SessionRepositoryCustomizer sessionRepositoryCustomizerOne() {
+ return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
+ }
+
+ @Bean
+ @Order(1)
+ SessionRepositoryCustomizer sessionRepositoryCustomizerTwo() {
+ return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ofSeconds(10000));
+ }
+ }
+
+ @Configuration
+ @EnableMongoHttpSession
+ static class CustomIndexResolverConfigurationWithDefaultMongoSessionConverter {
+
+ @Bean
+ @SuppressWarnings("unchecked")
+ IndexResolver indexResolver() {
+ return mock(IndexResolver.class);
+ }
+ }
+
+ @Configuration
+ @EnableMongoHttpSession
+ static class CustomIndexResolverConfigurationWithProvidedMongoSessionConverter {
+
+ @Bean
+ AbstractMongoSessionConverter mongoSessionConverter() {
+ return new JacksonMongoSessionConverter();
+ }
+
+ @Bean
+ @SuppressWarnings("unchecked")
+ IndexResolver indexResolver() {
+ return mock(IndexResolver.class);
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @Import(MongoHttpSessionConfiguration.class)
+ static class ImportConfigAndCustomizeConfiguration extends BaseConfiguration {
+
+ @Bean
+ SessionRepositoryCustomizer sessionRepositoryCustomizer() {
+ return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoHttpSession
+ @Import(MongoConfiguration.class)
+ static class SessionIdGeneratorConfiguration {
+
+ @Bean
+ SessionIdGenerator sessionIdGenerator() {
+ return new TestSessionIdGenerator();
+ }
+ }
+
+ static class TestSessionIdGenerator implements SessionIdGenerator {
+
+ @Override
+ public String generate() {
+ return "test";
+ }
+ }
+}
diff --git a/src/test/java/org/mongodb/spring/session/config/annotation/web/reactive/ReactiveMongoWebSessionConfigurationTests.java b/src/test/java/org/mongodb/spring/session/config/annotation/web/reactive/ReactiveMongoWebSessionConfigurationTests.java
new file mode 100644
index 0000000..96da551
--- /dev/null
+++ b/src/test/java/org/mongodb/spring/session/config/annotation/web/reactive/ReactiveMongoWebSessionConfigurationTests.java
@@ -0,0 +1,450 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ * Copyright 2014-present the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.mongodb.spring.session.config.annotation.web.reactive;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.BDDMockito.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.mock;
+import static org.mockito.BDDMockito.times;
+import static org.mockito.BDDMockito.verify;
+
+import java.lang.reflect.Field;
+import java.time.Duration;
+import java.util.Collections;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.mongodb.spring.session.AbstractMongoSessionConverter;
+import org.mongodb.spring.session.JacksonMongoSessionConverter;
+import org.mongodb.spring.session.JdkMongoSessionConverter;
+import org.mongodb.spring.session.ReactiveMongoSessionRepository;
+import org.springframework.beans.factory.UnsatisfiedDependencyException;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.ReactiveMongoOperations;
+import org.springframework.data.mongodb.core.index.IndexOperations;
+import org.springframework.session.IndexResolver;
+import org.springframework.session.ReactiveSessionRepository;
+import org.springframework.session.Session;
+import org.springframework.session.SessionIdGenerator;
+import org.springframework.session.UuidSessionIdGenerator;
+import org.springframework.session.config.ReactiveSessionRepositoryCustomizer;
+import org.springframework.session.config.annotation.web.server.EnableSpringWebSession;
+import org.springframework.util.ReflectionUtils;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+import org.springframework.web.server.session.WebSessionManager;
+
+/**
+ * Verify various configurations through {@link EnableSpringWebSession}.
+ *
+ * @author Greg Turnquist
+ * @author Vedran Pavic
+ */
+class ReactiveMongoWebSessionConfigurationTests {
+
+ private AnnotationConfigApplicationContext context;
+
+ @AfterEach
+ void tearDown() {
+
+ if (this.context != null) {
+ this.context.close();
+ }
+ }
+
+ @Test
+ void enableSpringWebSessionConfiguresThings() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(GoodConfig.class);
+ this.context.refresh();
+
+ WebSessionManager webSessionManagerFoundByType = this.context.getBean(WebSessionManager.class);
+ Object webSessionManagerFoundByName = this.context.getBean(WebHttpHandlerBuilder.WEB_SESSION_MANAGER_BEAN_NAME);
+
+ assertThat(webSessionManagerFoundByType).isNotNull();
+ assertThat(webSessionManagerFoundByName).isNotNull();
+ assertThat(webSessionManagerFoundByType).isEqualTo(webSessionManagerFoundByName);
+
+ assertThat(this.context.getBean(ReactiveSessionRepository.class)).isNotNull();
+ }
+
+ @Test
+ void missingReactorSessionRepositoryBreaksAppContext() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(BadConfig.class);
+
+ assertThatExceptionOfType(UnsatisfiedDependencyException.class)
+ .isThrownBy(this.context::refresh)
+ .withMessageContaining("Error creating bean with name 'reactiveMongoSessionRepository'")
+ .withMessageContaining(
+ "No qualifying bean of type '" + ReactiveMongoOperations.class.getCanonicalName());
+ }
+
+ @Test
+ void defaultSessionConverterShouldBeJdkWhenOnClasspath() throws IllegalAccessException {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(GoodConfig.class);
+ this.context.refresh();
+
+ ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
+
+ AbstractMongoSessionConverter converter = findMongoSessionConverter(repository);
+
+ assertThat(converter).isOfAnyClassIn(JdkMongoSessionConverter.class);
+ }
+
+ @Test
+ void overridingMongoSessionConverterWithBeanShouldWork() throws IllegalAccessException {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(OverrideSessionConverterConfig.class);
+ this.context.refresh();
+
+ ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
+
+ AbstractMongoSessionConverter converter = findMongoSessionConverter(repository);
+
+ assertThat(converter).isOfAnyClassIn(JacksonMongoSessionConverter.class);
+ }
+
+ @Test
+ void overridingIntervalAndCollectionNameThroughAnnotationShouldWork() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(OverrideMongoParametersConfig.class);
+ this.context.refresh();
+
+ ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
+
+ assertThat(repository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(123));
+ assertThat(repository).extracting("collectionName").isEqualTo("test-case");
+ }
+
+ @Test
+ void reactiveAndBlockingMongoOperationsShouldEnsureIndexing() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(ConfigWithReactiveAndImperativeMongoOperations.class);
+ this.context.refresh();
+
+ MongoOperations operations = this.context.getBean(MongoOperations.class);
+ IndexOperations indexOperations = this.context.getBean(IndexOperations.class);
+
+ // First initialization: should call createIndex once
+ verify(operations, times(1)).indexOps((String) any());
+ verify(indexOperations, times(1)).getIndexInfo();
+ verify(indexOperations, times(1)).createIndex(any());
+
+ // Simulate repeated initialization/configuration
+ this.context.close();
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(ConfigWithReactiveAndImperativeMongoOperations.class);
+ this.context.refresh();
+
+ MongoOperations operations2 = this.context.getBean(MongoOperations.class);
+ IndexOperations indexOperations2 = this.context.getBean(IndexOperations.class);
+
+ // Should not call createIndex again (total calls should still be 1)
+ verify(indexOperations2, times(1)).createIndex(any());
+ }
+
+ @Test
+ void overrideCollectionAndInactiveIntervalThroughConfigurationOptions() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(CustomizedReactiveConfiguration.class);
+ this.context.refresh();
+
+ ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
+
+ assertThat(repository.getCollectionName()).isEqualTo("custom-collection");
+ assertThat(repository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(123));
+ }
+
+ @Test
+ void sessionRepositoryCustomizer() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(SessionRepositoryCustomizerConfiguration.class);
+ this.context.refresh();
+
+ ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
+
+ assertThat(repository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(10000));
+ }
+
+ @Test
+ void customIndexResolverConfigurationWithDefaultMongoSessionConverter() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(CustomIndexResolverConfigurationWithDefaultMongoSessionConverter.class);
+ this.context.refresh();
+
+ ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
+ IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
+
+ assertThat(repository).isNotNull();
+ assertThat(indexResolver).isNotNull();
+ assertThat(repository)
+ .extracting("mongoSessionConverter")
+ .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
+ }
+
+ @Test
+ void customIndexResolverConfigurationWithProvidedMongoSessionConverter() {
+
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(CustomIndexResolverConfigurationWithProvidedtMongoSessionConverter.class);
+ this.context.refresh();
+
+ ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
+ IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
+
+ assertThat(repository).isNotNull();
+ assertThat(indexResolver).isNotNull();
+ assertThat(repository)
+ .extracting("mongoSessionConverter")
+ .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
+ }
+
+ @Test
+ void importConfigAndCustomize() {
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(ImportConfigAndCustomizeConfiguration.class);
+ this.context.refresh();
+ ReactiveMongoSessionRepository sessionRepository = this.context.getBean(ReactiveMongoSessionRepository.class);
+ assertThat(sessionRepository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ZERO);
+ }
+
+ @Test
+ void registerWhenSessionIdGeneratorBeanThenUses() {
+ registerAndRefresh(GoodConfig.class, SessionIdGeneratorConfiguration.class);
+ ReactiveMongoSessionRepository sessionRepository = this.context.getBean(ReactiveMongoSessionRepository.class);
+ assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(TestSessionIdGenerator.class);
+ }
+
+ @Test
+ void registerWhenNoSessionIdGeneratorBeanThenDefault() {
+ registerAndRefresh(GoodConfig.class);
+ ReactiveMongoSessionRepository sessionRepository = this.context.getBean(ReactiveMongoSessionRepository.class);
+ assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(UuidSessionIdGenerator.class);
+ }
+
+ private void registerAndRefresh(Class... annotatedClasses) {
+ this.context = new AnnotationConfigApplicationContext();
+ this.context.register(annotatedClasses);
+ this.context.refresh();
+ }
+
+ /**
+ * Reflectively extract the {@link AbstractMongoSessionConverter} from the {@link ReactiveMongoSessionRepository}.
+ * This is to avoid expanding the surface area of the API.
+ */
+ private AbstractMongoSessionConverter findMongoSessionConverter(ReactiveMongoSessionRepository repository) {
+
+ Field field = ReflectionUtils.findField(ReactiveMongoSessionRepository.class, "mongoSessionConverter");
+ ReflectionUtils.makeAccessible(field);
+ try {
+ return (AbstractMongoSessionConverter) field.get(repository);
+ } catch (IllegalAccessException ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+
+ /** A configuration with all the right parts. */
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession
+ static class GoodConfig {
+
+ @Bean
+ ReactiveMongoOperations operations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+ }
+
+ /** A configuration where no {@link ReactiveMongoOperations} is defined. It's BAD! */
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession
+ static class BadConfig {}
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession
+ static class OverrideSessionConverterConfig {
+
+ @Bean
+ ReactiveMongoOperations operations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+
+ @Bean
+ AbstractMongoSessionConverter mongoSessionConverter() {
+ return new JacksonMongoSessionConverter();
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession(maxInactiveIntervalInSeconds = 123, collectionName = "test-case")
+ static class OverrideMongoParametersConfig {
+
+ @Bean
+ ReactiveMongoOperations operations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession
+ static class ConfigWithReactiveAndImperativeMongoOperations {
+
+ @Bean
+ ReactiveMongoOperations reactiveMongoOperations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+
+ @Bean
+ IndexOperations indexOperations() {
+
+ IndexOperations indexOperations = mock(IndexOperations.class);
+ given(indexOperations.getIndexInfo()).willReturn(Collections.emptyList());
+ return indexOperations;
+ }
+
+ @Bean
+ MongoOperations mongoOperations(IndexOperations indexOperations) {
+
+ MongoOperations mongoOperations = mock(MongoOperations.class);
+ given(mongoOperations.indexOps((String) any())).willReturn(indexOperations);
+ return mongoOperations;
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableSpringWebSession
+ static class CustomizedReactiveConfiguration extends ReactiveMongoWebSessionConfiguration {
+
+ CustomizedReactiveConfiguration() {
+
+ this.setCollectionName("custom-collection");
+ this.setMaxInactiveInterval(Duration.ofSeconds(123));
+ }
+
+ @Bean
+ ReactiveMongoOperations reactiveMongoOperations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession
+ static class SessionRepositoryCustomizerConfiguration {
+
+ @Bean
+ ReactiveMongoOperations operations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+
+ @Bean
+ @Order(0)
+ ReactiveSessionRepositoryCustomizer sessionRepositoryCustomizerOne() {
+ return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
+ }
+
+ @Bean
+ @Order(1)
+ ReactiveSessionRepositoryCustomizer sessionRepositoryCustomizerTwo() {
+ return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ofSeconds(10000));
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession
+ static class CustomIndexResolverConfigurationWithDefaultMongoSessionConverter {
+
+ @Bean
+ ReactiveMongoOperations operations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+
+ @Bean
+ @SuppressWarnings("unchecked")
+ IndexResolver indexResolver() {
+ return mock(IndexResolver.class);
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @EnableMongoWebSession
+ static class CustomIndexResolverConfigurationWithProvidedtMongoSessionConverter {
+
+ @Bean
+ ReactiveMongoOperations operations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+
+ @Bean
+ JacksonMongoSessionConverter jacksonMongoSessionConverter() {
+ return new JacksonMongoSessionConverter();
+ }
+
+ @Bean
+ @SuppressWarnings("unchecked")
+ IndexResolver indexResolver() {
+ return mock(IndexResolver.class);
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ @Import(ReactiveMongoWebSessionConfiguration.class)
+ static class ImportConfigAndCustomizeConfiguration {
+
+ @Bean
+ ReactiveMongoOperations operations() {
+ return mock(ReactiveMongoOperations.class);
+ }
+
+ @Bean
+ ReactiveSessionRepositoryCustomizer sessionRepositoryCustomizer() {
+ return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
+ }
+ }
+
+ @Configuration(proxyBeanMethods = false)
+ static class SessionIdGeneratorConfiguration {
+
+ @Bean
+ SessionIdGenerator sessionIdGenerator() {
+ return new TestSessionIdGenerator();
+ }
+ }
+
+ static class TestSessionIdGenerator implements SessionIdGenerator {
+
+ @Override
+ public String generate() {
+ return "test";
+ }
+ }
+}
diff --git a/src/test/java/org/springframework/session/data/mongo/AbstractMongoSessionConverterTests.java b/src/test/java/org/springframework/session/data/mongo/AbstractMongoSessionConverterTests.java
deleted file mode 100644
index 78054f9..0000000
--- a/src/test/java/org/springframework/session/data/mongo/AbstractMongoSessionConverterTests.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.time.Duration;
-
-import com.mongodb.DBObject;
-import org.bson.Document;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.lang.Nullable;
-import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
-import org.springframework.security.core.context.SecurityContextImpl;
-import org.springframework.session.FindByIndexNameSessionRepository;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * @author Greg Turnquist
- */
-public abstract class AbstractMongoSessionConverterTests {
-
- abstract AbstractMongoSessionConverter getMongoSessionConverter();
-
- @Test
- void verifyRoundTripSerialization() throws Exception {
-
- // given
- MongoSession toSerialize = new MongoSession();
- toSerialize.setAttribute("username", "john_the_springer");
-
- // when
- DBObject dbObject = convertToDBObject(toSerialize);
- MongoSession deserialized = convertToSession(dbObject);
-
- // then
- assertThat(deserialized).usingRecursiveComparison().isEqualTo(toSerialize);
- }
-
- @Test
- void verifyRoundTripSecuritySerialization() {
-
- // given
- MongoSession toSerialize = new MongoSession();
- String principalName = "john_the_springer";
- SecurityContextImpl context = new SecurityContextImpl();
- context.setAuthentication(new UsernamePasswordAuthenticationToken(principalName, null));
- toSerialize.setAttribute("SPRING_SECURITY_CONTEXT", context);
-
- // when
- DBObject serialized = convertToDBObject(toSerialize);
- MongoSession deserialized = convertToSession(serialized);
-
- // then
- assertThat(deserialized).usingRecursiveComparison().isEqualTo(toSerialize);
-
- SecurityContextImpl springSecurityContextBefore = toSerialize.getAttribute("SPRING_SECURITY_CONTEXT");
- SecurityContextImpl springSecurityContextAfter = deserialized.getAttribute("SPRING_SECURITY_CONTEXT");
-
- assertThat(springSecurityContextBefore).usingRecursiveComparison().isEqualTo(springSecurityContextAfter);
- assertThat(springSecurityContextAfter.getAuthentication().getPrincipal()).isEqualTo("john_the_springer");
- assertThat(springSecurityContextAfter.getAuthentication().getCredentials()).isNull();
- }
-
- @Test
- void shouldExtractPrincipalNameFromAttributes() throws Exception {
-
- // given
- MongoSession toSerialize = new MongoSession();
- String principalName = "john_the_springer";
- toSerialize.setAttribute(FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME, principalName);
-
- // when
- DBObject dbObject = convertToDBObject(toSerialize);
-
- // then
- assertThat(dbObject.get("principal")).isEqualTo(principalName);
- }
-
- @Test
- void shouldExtractPrincipalNameFromAuthentication() throws Exception {
-
- // given
- MongoSession toSerialize = new MongoSession();
- String principalName = "john_the_springer";
- SecurityContextImpl context = new SecurityContextImpl();
- context.setAuthentication(new UsernamePasswordAuthenticationToken(principalName, null));
- toSerialize.setAttribute("SPRING_SECURITY_CONTEXT", context);
-
- // when
- DBObject dbObject = convertToDBObject(toSerialize);
-
- // then
- assertThat(dbObject.get("principal")).isEqualTo(principalName);
- }
-
- @Test
- void sessionWrapperWithNoMaxIntervalShouldFallbackToDefaultValues() {
-
- // given
- MongoSession toSerialize = new MongoSession();
- DBObject dbObject = convertToDBObject(toSerialize);
- Document document = new Document(dbObject.toMap());
- document.remove("interval");
-
- // when
- MongoSession convertedSession = getMongoSessionConverter().convert(document);
-
- // then
- assertThat(convertedSession.getMaxInactiveInterval()).isEqualTo(Duration.ofMinutes(30));
- }
-
- @Nullable
- MongoSession convertToSession(DBObject session) {
- return (MongoSession) getMongoSessionConverter().convert(session, TypeDescriptor.valueOf(DBObject.class),
- TypeDescriptor.valueOf(MongoSession.class));
- }
-
- @Nullable
- DBObject convertToDBObject(MongoSession session) {
- return (DBObject) getMongoSessionConverter().convert(session, TypeDescriptor.valueOf(MongoSession.class),
- TypeDescriptor.valueOf(DBObject.class));
- }
-
-}
diff --git a/src/test/java/org/springframework/session/data/mongo/JacksonMongoSessionConverterTests.java b/src/test/java/org/springframework/session/data/mongo/JacksonMongoSessionConverterTests.java
deleted file mode 100644
index 26efdbe..0000000
--- a/src/test/java/org/springframework/session/data/mongo/JacksonMongoSessionConverterTests.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.lang.reflect.Field;
-import java.util.Date;
-import java.util.HashMap;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.mongodb.DBObject;
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.AssertionsForClassTypes;
-import org.bson.Document;
-import org.bson.types.ObjectId;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.data.mongodb.core.query.Query;
-import org.springframework.util.ReflectionUtils;
-
-/**
- * @author Jakub Kubrynski
- * @author Greg Turnquist
- */
-class JacksonMongoSessionConverterTests extends AbstractMongoSessionConverterTests {
-
- JacksonMongoSessionConverter mongoSessionConverter = new JacksonMongoSessionConverter();
-
- @Override
- AbstractMongoSessionConverter getMongoSessionConverter() {
- return this.mongoSessionConverter;
- }
-
- @Test
- void shouldSaveIdField() {
-
- // given
- MongoSession session = new MongoSession();
-
- // when
- DBObject convert = this.mongoSessionConverter.convert(session);
-
- // then
- AssertionsForClassTypes.assertThat(convert.get("_id")).isEqualTo(session.getId());
- AssertionsForClassTypes.assertThat(convert.get("id")).isNull();
- }
-
- @Test
- void shouldQueryAgainstAttribute() throws Exception {
-
- // when
- Query cart = this.mongoSessionConverter.getQueryForIndex("cart", "my-cart");
-
- // then
- AssertionsForClassTypes.assertThat(cart.getQueryObject().get("attrs.cart")).isEqualTo("my-cart");
- }
-
- @Test
- void shouldAllowCustomObjectMapper() {
-
- // given
- ObjectMapper myMapper = new ObjectMapper();
-
- // when
- JacksonMongoSessionConverter converter = new JacksonMongoSessionConverter(myMapper);
-
- // then
- Field objectMapperField = ReflectionUtils.findField(JacksonMongoSessionConverter.class, "objectMapper");
- ReflectionUtils.makeAccessible(objectMapperField);
- ObjectMapper converterMapper = (ObjectMapper) ReflectionUtils.getField(objectMapperField, converter);
-
- AssertionsForClassTypes.assertThat(converterMapper).isEqualTo(myMapper);
- }
-
- @Test
- void shouldNotAllowNullObjectMapperToBeInjected() {
-
- Assertions.assertThatIllegalArgumentException()
- .isThrownBy(() -> new JacksonMongoSessionConverter((ObjectMapper) null));
- }
-
- @Test
- void shouldSaveExpireAtAsDate() {
-
- // given
- MongoSession session = new MongoSession();
-
- // when
- DBObject convert = this.mongoSessionConverter.convert(session);
-
- // then
- AssertionsForClassTypes.assertThat(convert.get("expireAt")).isInstanceOf(Date.class);
- AssertionsForClassTypes.assertThat(convert.get("expireAt")).isEqualTo(session.getExpireAt());
- }
-
- @Test
- void shouldLoadExpireAtFromDocument() {
-
- // given
- Date now = new Date();
- HashMap data = new HashMap<>();
-
- data.put("expireAt", now);
- data.put("@class", MongoSession.class.getName());
- data.put("_id", new ObjectId().toString());
-
- Document document = new Document(data);
-
- // when
- MongoSession convertedSession = this.mongoSessionConverter.convert(document);
-
- // then
- AssertionsForClassTypes.assertThat(convertedSession).isNotNull();
- AssertionsForClassTypes.assertThat(convertedSession.getExpireAt()).isEqualTo(now);
- }
-
-}
diff --git a/src/test/java/org/springframework/session/data/mongo/MongoIndexedSessionRepositoryTests.java b/src/test/java/org/springframework/session/data/mongo/MongoIndexedSessionRepositoryTests.java
deleted file mode 100644
index cb86171..0000000
--- a/src/test/java/org/springframework/session/data/mongo/MongoIndexedSessionRepositoryTests.java
+++ /dev/null
@@ -1,282 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.Collections;
-import java.util.Map;
-import java.util.UUID;
-
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBObject;
-import org.bson.Document;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.query.Query;
-import org.springframework.session.FindByIndexNameSessionRepository;
-import org.springframework.session.MapSession;
-import org.springframework.session.SessionIdGenerator;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.mock;
-import static org.mockito.BDDMockito.verify;
-
-/**
- * Tests for {@link MongoIndexedSessionRepository}.
- *
- * @author Jakub Kubrynski
- * @author Vedran Pavic
- * @author Greg Turnquist
- */
-@ExtendWith(MockitoExtension.class)
-class MongoIndexedSessionRepositoryTests {
-
- @Mock
- private AbstractMongoSessionConverter converter;
-
- @Mock
- private MongoOperations mongoOperations;
-
- private MongoIndexedSessionRepository repository;
-
- @BeforeEach
- void setUp() {
-
- this.repository = new MongoIndexedSessionRepository(this.mongoOperations);
- this.repository.setMongoSessionConverter(this.converter);
- }
-
- @Test
- void shouldCreateSession() {
-
- // when
- MongoSession session = this.repository.createSession();
-
- // then
- assertThat(session.getId()).isNotEmpty();
- assertThat(session.getMaxInactiveInterval().getSeconds())
- .isEqualTo(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
- }
-
- @Test
- void shouldSaveSession() {
-
- // given
- MongoSession session = new MongoSession();
- BasicDBObject dbSession = new BasicDBObject();
-
- given(this.converter.convert(session, TypeDescriptor.valueOf(MongoSession.class),
- TypeDescriptor.valueOf(DBObject.class)))
- .willReturn(dbSession);
- // when
- this.repository.save(session);
-
- // then
- verify(this.mongoOperations).save(dbSession, MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME);
- }
-
- @Test
- void shouldGetSession() {
-
- // given
- String sessionId = UUID.randomUUID().toString();
- Document sessionDocument = new Document();
-
- given(this.mongoOperations.findById(sessionId, Document.class,
- MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(sessionDocument);
-
- MongoSession session = new MongoSession();
-
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
-
- // when
- MongoSession retrievedSession = this.repository.findById(sessionId);
-
- // then
- assertThat(retrievedSession).isEqualTo(session);
- }
-
- @Test
- void shouldHandleExpiredSession() {
-
- // given
- String sessionId = UUID.randomUUID().toString();
- Document sessionDocument = new Document();
-
- given(this.mongoOperations.findById(sessionId, Document.class,
- MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(sessionDocument);
-
- MongoSession session = mock(MongoSession.class);
-
- given(session.isExpired()).willReturn(true);
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
- given(session.getId()).willReturn("sessionId");
-
- // when
- this.repository.findById(sessionId);
-
- // then
- verify(this.mongoOperations).remove(any(Document.class),
- eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME));
- }
-
- @Test
- void shouldDeleteSession() {
-
- // given
- String sessionId = UUID.randomUUID().toString();
-
- Document sessionDocument = new Document();
- sessionDocument.put("id", sessionId);
-
- MongoSession mongoSession = new MongoSession(sessionId, MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS);
-
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(mongoSession);
- given(this.mongoOperations.findById(eq(sessionId), eq(Document.class),
- eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME)))
- .willReturn(sessionDocument);
-
- // when
- this.repository.deleteById(sessionId);
-
- // then
- verify(this.mongoOperations).remove(any(Document.class),
- eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME));
- }
-
- @Test
- void shouldGetSessionsMapByPrincipal() {
-
- // given
- String principalNameIndexName = FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME;
-
- Document document = new Document();
-
- given(this.converter.getQueryForIndex(anyString(), any(Object.class))).willReturn(mock(Query.class));
- given(this.mongoOperations.find(any(Query.class), eq(Document.class),
- eq(MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME)))
- .willReturn(Collections.singletonList(document));
-
- String sessionId = UUID.randomUUID().toString();
-
- MongoSession session = new MongoSession(sessionId, 1800);
-
- given(this.converter.convert(document, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
-
- // when
- Map sessionsMap = this.repository.findByIndexNameAndIndexValue(principalNameIndexName,
- "john");
-
- // then
- assertThat(sessionsMap).containsOnlyKeys(sessionId);
- assertThat(sessionsMap).containsValues(session);
- }
-
- @Test
- void shouldReturnEmptyMapForNotSupportedIndex() {
-
- // given
- String index = "some_not_supported_index_name";
-
- // when
- Map sessionsMap = this.repository.findByIndexNameAndIndexValue(index, "some_value");
-
- // then
- assertThat(sessionsMap).isEmpty();
- }
-
- @Test
- void createSessionWhenSessionIdGeneratorThenUses() {
- this.repository.setSessionIdGenerator(new FixedSessionIdGenerator("123"));
- MongoSession session = this.repository.createSession();
- assertThat(session.getId()).isEqualTo("123");
- assertThat(session.changeSessionId()).isEqualTo("123");
- }
-
- @Test
- void setSessionIdGeneratorWhenNullThenThrowsException() {
- assertThatIllegalArgumentException().isThrownBy(() -> this.repository.setSessionIdGenerator(null));
- }
-
- @Test
- void findByIdWhenChangeSessionIdThenUsesSessionIdGenerator() {
- this.repository.setSessionIdGenerator(new FixedSessionIdGenerator("456"));
-
- Document sessionDocument = new Document();
-
- given(this.mongoOperations.findById("123", Document.class,
- MongoIndexedSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(sessionDocument);
-
- MongoSession session = new MongoSession("123");
-
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
-
- MongoSession retrievedSession = this.repository.findById("123");
- assertThat(retrievedSession.getId()).isEqualTo("123");
- String newSessionId = retrievedSession.changeSessionId();
- assertThat(newSessionId).isEqualTo("456");
- }
-
- @Test
- void createSessionWhenMaxInactiveIntervalSetThenUse() {
- this.repository.setDefaultMaxInactiveInterval(Duration.ofSeconds(60));
- MongoSession session = this.repository.createSession();
- Instant now = Instant.now();
- assertThat(session.getExpireAt()).isBetween(now.plusSeconds(59), Instant.now().plusSeconds(61));
- }
-
- static class FixedSessionIdGenerator implements SessionIdGenerator {
-
- private final String id;
-
- FixedSessionIdGenerator(String id) {
- this.id = id;
- }
-
- @Override
- public String generate() {
- return this.id;
- }
-
- }
-
-}
diff --git a/src/test/java/org/springframework/session/data/mongo/ReactiveMongoSessionRepositoryTests.java b/src/test/java/org/springframework/session/data/mongo/ReactiveMongoSessionRepositoryTests.java
deleted file mode 100644
index 313f64c..0000000
--- a/src/test/java/org/springframework/session/data/mongo/ReactiveMongoSessionRepositoryTests.java
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.UUID;
-
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBObject;
-import com.mongodb.client.result.DeleteResult;
-import org.bson.Document;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import reactor.core.publisher.Mono;
-import reactor.test.StepVerifier;
-
-import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.ReactiveMongoOperations;
-import org.springframework.data.mongodb.core.index.IndexOperations;
-import org.springframework.session.MapSession;
-import org.springframework.session.events.SessionDeletedEvent;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
-import static org.mockito.BDDMockito.any;
-import static org.mockito.BDDMockito.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.mock;
-import static org.mockito.BDDMockito.times;
-import static org.mockito.BDDMockito.verify;
-
-/**
- * Tests for {@link ReactiveMongoSessionRepository}.
- *
- * @author Jakub Kubrynski
- * @author Vedran Pavic
- * @author Greg Turnquist
- */
-@ExtendWith(MockitoExtension.class)
-class ReactiveMongoSessionRepositoryTests {
-
- @Mock
- private AbstractMongoSessionConverter converter;
-
- @Mock
- private ReactiveMongoOperations mongoOperations;
-
- @Mock
- private MongoOperations blockingMongoOperations;
-
- @Mock
- private ApplicationEventPublisher eventPublisher;
-
- private ReactiveMongoSessionRepository repository;
-
- @BeforeEach
- void setUp() {
-
- this.repository = new ReactiveMongoSessionRepository(this.mongoOperations);
- this.repository.setMongoSessionConverter(this.converter);
- this.repository.setApplicationEventPublisher(this.eventPublisher);
- }
-
- @Test
- void shouldCreateSession() {
-
- this.repository.createSession() //
- .as(StepVerifier::create) //
- .expectNextMatches((mongoSession) -> {
- assertThat(mongoSession.getId()).isNotEmpty();
- assertThat(mongoSession.getMaxInactiveInterval())
- .isEqualTo(Duration.ofSeconds(MapSession.DEFAULT_MAX_INACTIVE_INTERVAL_SECONDS));
- return true;
- }) //
- .verifyComplete();
- }
-
- @Test
- void shouldSaveSession() {
-
- // given
- MongoSession session = new MongoSession();
- BasicDBObject dbSession = new BasicDBObject();
-
- given(this.converter.convert(session, TypeDescriptor.valueOf(MongoSession.class),
- TypeDescriptor.valueOf(DBObject.class)))
- .willReturn(dbSession);
-
- given(this.mongoOperations.save(dbSession, "sessions")).willReturn(Mono.just(dbSession));
-
- // when
- this.repository.save(session) //
- .as(StepVerifier::create) //
- .verifyComplete();
-
- verify(this.mongoOperations).save(dbSession, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME);
- }
-
- @Test
- void shouldGetSession() {
-
- // given
- String sessionId = UUID.randomUUID().toString();
- Document sessionDocument = new Document();
-
- given(this.mongoOperations.findById(sessionId, Document.class,
- ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(Mono.just(sessionDocument));
-
- MongoSession session = new MongoSession();
-
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
-
- // when
- this.repository.findById(sessionId) //
- .as(StepVerifier::create) //
- .expectNext(session) //
- .verifyComplete();
- }
-
- @Test
- void shouldHandleExpiredSession() {
-
- // given
- String sessionId = UUID.randomUUID().toString();
- Document sessionDocument = new Document();
-
- given(this.mongoOperations.findById(sessionId, Document.class,
- ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(Mono.just(sessionDocument));
-
- given(this.mongoOperations.remove(sessionDocument, ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(Mono.just(DeleteResult.acknowledged(1)));
-
- MongoSession session = mock(MongoSession.class);
-
- given(session.isExpired()).willReturn(true);
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
-
- // when
- this.repository.findById(sessionId) //
- .as(StepVerifier::create) //
- .verifyComplete();
-
- // then
- verify(this.mongoOperations).remove(any(Document.class),
- eq(ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME));
- }
-
- @Test
- void shouldDeleteSession() {
-
- // given
- String sessionId = UUID.randomUUID().toString();
- Document sessionDocument = new Document();
-
- given(this.mongoOperations.findById(sessionId, Document.class,
- ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(Mono.just(sessionDocument));
-
- given(this.mongoOperations.remove(sessionDocument, "sessions"))
- .willReturn(Mono.just(DeleteResult.acknowledged(1)));
-
- MongoSession session = mock(MongoSession.class);
-
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
-
- // when
- this.repository.deleteById(sessionId) //
- .as(StepVerifier::create) //
- .verifyComplete();
-
- verify(this.mongoOperations).remove(any(Document.class),
- eq(ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME));
-
- verify(this.eventPublisher).publishEvent(any(SessionDeletedEvent.class));
- }
-
- @Test
- void shouldInvokeMethodToCreateIndexesImperatively() {
-
- // given
- IndexOperations indexOperations = mock(IndexOperations.class);
- given(this.blockingMongoOperations.indexOps((String) any())).willReturn(indexOperations);
-
- this.repository.setBlockingMongoOperations(this.blockingMongoOperations);
-
- // when
- this.repository.afterPropertiesSet();
-
- // then
- verify(this.blockingMongoOperations, times(1)).indexOps((String) any());
- verify(this.converter, times(1)).ensureIndexes(indexOperations);
- }
-
- @Test
- void createSessionWhenSessionIdGeneratorThenUses() {
- this.repository.setSessionIdGenerator(() -> "test");
-
- this.repository.createSession().as(StepVerifier::create).assertNext((mongoSession) -> {
- assertThat(mongoSession.getId()).isEqualTo("test");
- assertThat(mongoSession.changeSessionId()).isEqualTo("test");
- }).verifyComplete();
- }
-
- @Test
- void setSessionIdGeneratorWhenNullThenThrowsException() {
- assertThatIllegalArgumentException().isThrownBy(() -> this.repository.setSessionIdGenerator(null))
- .withMessage("sessionIdGenerator cannot be null");
- }
-
- @Test
- void findByIdWhenChangeSessionIdThenUsesSessionIdGenerator() {
- this.repository.setSessionIdGenerator(() -> "test");
-
- String sessionId = UUID.randomUUID().toString();
- Document sessionDocument = new Document();
-
- given(this.mongoOperations.findById(sessionId, Document.class,
- ReactiveMongoSessionRepository.DEFAULT_COLLECTION_NAME))
- .willReturn(Mono.just(sessionDocument));
-
- MongoSession session = new MongoSession(sessionId);
-
- given(this.converter.convert(sessionDocument, TypeDescriptor.valueOf(Document.class),
- TypeDescriptor.valueOf(MongoSession.class)))
- .willReturn(session);
-
- this.repository.findById(sessionId).as(StepVerifier::create).assertNext((mongoSession) -> {
- String oldId = mongoSession.getId();
- String newId = mongoSession.changeSessionId();
- assertThat(oldId).isEqualTo(sessionId);
- assertThat(newId).isEqualTo("test");
- }).verifyComplete();
- }
-
- @Test
- void createSessionWhenMaxInactiveIntervalSetThenUse() {
- this.repository.setDefaultMaxInactiveInterval(Duration.ofSeconds(60));
- MongoSession session = this.repository.createSession().block();
- Instant now = Instant.now();
- assertThat(session.getExpireAt()).isBetween(now.plusSeconds(59), Instant.now().plusSeconds(61));
- }
-
-}
diff --git a/src/test/java/org/springframework/session/data/mongo/config/annotation/web/http/MongoHttpSessionConfigurationTests.java b/src/test/java/org/springframework/session/data/mongo/config/annotation/web/http/MongoHttpSessionConfigurationTests.java
deleted file mode 100644
index eb46469..0000000
--- a/src/test/java/org/springframework/session/data/mongo/config/annotation/web/http/MongoHttpSessionConfigurationTests.java
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo.config.annotation.web.http;
-
-import java.net.UnknownHostException;
-import java.time.Duration;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Order;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.beans.factory.UnsatisfiedDependencyException;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.index.IndexOperations;
-import org.springframework.mock.env.MockEnvironment;
-import org.springframework.session.IndexResolver;
-import org.springframework.session.Session;
-import org.springframework.session.SessionIdGenerator;
-import org.springframework.session.UuidSessionIdGenerator;
-import org.springframework.session.config.SessionRepositoryCustomizer;
-import org.springframework.session.data.mongo.AbstractMongoSessionConverter;
-import org.springframework.session.data.mongo.JacksonMongoSessionConverter;
-import org.springframework.session.data.mongo.MongoIndexedSessionRepository;
-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.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.mock;
-
-/**
- * Tests for {@link MongoHttpSessionConfiguration}.
- *
- * @author Eddú Meléndez
- * @author Vedran Pavic
- */
-class MongoHttpSessionConfigurationTests {
-
- private static final String COLLECTION_NAME = "testSessions";
-
- private static final int MAX_INACTIVE_INTERVAL_IN_SECONDS = 600;
-
- private AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
-
- @AfterEach
- void after() {
-
- if (this.context != null) {
- this.context.close();
- }
- }
-
- @Test
- void noMongoOperationsConfiguration() {
-
- assertThatExceptionOfType(UnsatisfiedDependencyException.class)
- .isThrownBy(() -> registerAndRefresh(EmptyConfiguration.class))
- .withMessageContaining("mongoSessionRepository");
- }
-
- @Test
- void defaultConfiguration() {
-
- registerAndRefresh(DefaultConfiguration.class);
-
- assertThat(this.context.getBean(MongoIndexedSessionRepository.class)).isNotNull();
- }
-
- @Test
- void customCollectionName() {
-
- registerAndRefresh(CustomCollectionNameConfiguration.class);
-
- MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
-
- assertThat(repository).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository, "collectionName")).isEqualTo(COLLECTION_NAME);
- }
-
- @Test
- void setCustomCollectionName() {
-
- registerAndRefresh(CustomCollectionNameSetConfiguration.class);
-
- MongoHttpSessionConfiguration session = this.context.getBean(MongoHttpSessionConfiguration.class);
-
- assertThat(session).isNotNull();
- assertThat(ReflectionTestUtils.getField(session, "collectionName")).isEqualTo(COLLECTION_NAME);
- }
-
- @Test
- void customMaxInactiveIntervalInSeconds() {
-
- registerAndRefresh(CustomMaxInactiveIntervalInSecondsConfiguration.class);
-
- MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
-
- assertThat(repository).extracting("defaultMaxInactiveInterval")
- .isEqualTo(Duration.ofSeconds(MAX_INACTIVE_INTERVAL_IN_SECONDS));
- }
-
- @Test
- void setCustomMaxInactiveIntervalInSeconds() {
-
- registerAndRefresh(CustomMaxInactiveIntervalInSecondsSetConfiguration.class);
-
- MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
-
- assertThat(repository).extracting("defaultMaxInactiveInterval")
- .isEqualTo(Duration.ofSeconds(MAX_INACTIVE_INTERVAL_IN_SECONDS));
- }
-
- @Test
- void setCustomSessionConverterConfiguration() {
-
- registerAndRefresh(CustomSessionConverterConfiguration.class);
-
- MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
- AbstractMongoSessionConverter mongoSessionConverter = this.context.getBean(AbstractMongoSessionConverter.class);
-
- assertThat(repository).isNotNull();
- assertThat(mongoSessionConverter).isNotNull();
- assertThat(ReflectionTestUtils.getField(repository, "mongoSessionConverter")).isEqualTo(mongoSessionConverter);
- }
-
- @Test
- void resolveCollectionNameByPropertyPlaceholder() {
-
- this.context
- .setEnvironment(new MockEnvironment().withProperty("session.mongo.collectionName", COLLECTION_NAME));
- registerAndRefresh(CustomMongoJdbcSessionConfiguration.class);
-
- MongoHttpSessionConfiguration configuration = this.context.getBean(MongoHttpSessionConfiguration.class);
-
- assertThat(ReflectionTestUtils.getField(configuration, "collectionName")).isEqualTo(COLLECTION_NAME);
- }
-
- @Test
- void sessionRepositoryCustomizer() {
-
- registerAndRefresh(MongoConfiguration.class, SessionRepositoryCustomizerConfiguration.class);
-
- MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
-
- assertThat(sessionRepository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(10000));
- }
-
- @Test
- void customIndexResolverConfigurationWithDefaultMongoSessionConverter() {
-
- registerAndRefresh(MongoConfiguration.class,
- CustomIndexResolverConfigurationWithDefaultMongoSessionConverter.class);
-
- MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
- IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
-
- assertThat(repository).isNotNull();
- assertThat(indexResolver).isNotNull();
- assertThat(repository).extracting("mongoSessionConverter")
- .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
- }
-
- @Test
- void customIndexResolverConfigurationWithProvidedMongoSessionConverter() {
-
- registerAndRefresh(MongoConfiguration.class,
- CustomIndexResolverConfigurationWithProvidedMongoSessionConverter.class);
-
- MongoIndexedSessionRepository repository = this.context.getBean(MongoIndexedSessionRepository.class);
- IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
-
- assertThat(repository).isNotNull();
- assertThat(indexResolver).isNotNull();
- assertThat(repository).extracting("mongoSessionConverter")
- .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
- }
-
- @Test
- void importConfigAndCustomize() {
- registerAndRefresh(ImportConfigAndCustomizeConfiguration.class);
- MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
- assertThat(sessionRepository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ZERO);
- }
-
- @Test
- void registerWhenSessionIdGeneratorBeanThenUses() {
- registerAndRefresh(SessionIdGeneratorConfiguration.class);
- MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
- assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(TestSessionIdGenerator.class);
- }
-
- @Test
- void registerWhenNoSessionIdGeneratorBeanThenDefault() {
- registerAndRefresh(DefaultConfiguration.class);
- MongoIndexedSessionRepository sessionRepository = this.context.getBean(MongoIndexedSessionRepository.class);
- assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(UuidSessionIdGenerator.class);
- }
-
- private void registerAndRefresh(Class... annotatedClasses) {
-
- this.context.register(annotatedClasses);
- this.context.refresh();
- }
-
- @Configuration
- @EnableMongoHttpSession
- static class EmptyConfiguration {
-
- }
-
- static class BaseConfiguration {
-
- @Bean
- MongoOperations mongoOperations() throws UnknownHostException {
-
- MongoOperations mongoOperations = mock(MongoOperations.class);
- IndexOperations indexOperations = mock(IndexOperations.class);
-
- given(mongoOperations.indexOps(anyString())).willReturn(indexOperations);
-
- return mongoOperations;
- }
-
- }
-
- @Configuration
- @EnableMongoHttpSession
- static class DefaultConfiguration extends BaseConfiguration {
-
- }
-
- @Configuration
- static class MongoConfiguration extends BaseConfiguration {
-
- }
-
- @Configuration
- @EnableMongoHttpSession(collectionName = COLLECTION_NAME)
- static class CustomCollectionNameConfiguration extends BaseConfiguration {
-
- }
-
- @Configuration
- @Import(MongoConfiguration.class)
- static class CustomCollectionNameSetConfiguration extends MongoHttpSessionConfiguration {
-
- CustomCollectionNameSetConfiguration() {
- setCollectionName(COLLECTION_NAME);
- }
-
- }
-
- @Configuration
- @EnableMongoHttpSession(maxInactiveIntervalInSeconds = MAX_INACTIVE_INTERVAL_IN_SECONDS)
- static class CustomMaxInactiveIntervalInSecondsConfiguration extends BaseConfiguration {
-
- }
-
- @Configuration
- @Import(MongoConfiguration.class)
- static class CustomMaxInactiveIntervalInSecondsSetConfiguration extends MongoHttpSessionConfiguration {
-
- CustomMaxInactiveIntervalInSecondsSetConfiguration() {
- setMaxInactiveInterval(Duration.ofSeconds(MAX_INACTIVE_INTERVAL_IN_SECONDS));
- }
-
- }
-
- @Configuration
- @Import(MongoConfiguration.class)
- static class CustomSessionConverterConfiguration extends MongoHttpSessionConfiguration {
-
- @Bean
- AbstractMongoSessionConverter mongoSessionConverter() {
- return mock(AbstractMongoSessionConverter.class);
- }
-
- }
-
- @Configuration
- @EnableMongoHttpSession(collectionName = "${session.mongo.collectionName}")
- static class CustomMongoJdbcSessionConfiguration extends BaseConfiguration {
-
- @Bean
- PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
- return new PropertySourcesPlaceholderConfigurer();
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoHttpSession
- static class SessionRepositoryCustomizerConfiguration {
-
- @Bean
- @Order(0)
- SessionRepositoryCustomizer sessionRepositoryCustomizerOne() {
- return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
- }
-
- @Bean
- @Order(1)
- SessionRepositoryCustomizer sessionRepositoryCustomizerTwo() {
- return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ofSeconds(10000));
- }
-
- }
-
- @Configuration
- @EnableMongoHttpSession
- static class CustomIndexResolverConfigurationWithDefaultMongoSessionConverter {
-
- @Bean
- @SuppressWarnings("unchecked")
- IndexResolver indexResolver() {
- return mock(IndexResolver.class);
- }
-
- }
-
- @Configuration
- @EnableMongoHttpSession
- static class CustomIndexResolverConfigurationWithProvidedMongoSessionConverter {
-
- @Bean
- AbstractMongoSessionConverter mongoSessionConverter() {
- return new JacksonMongoSessionConverter();
- }
-
- @Bean
- @SuppressWarnings("unchecked")
- IndexResolver indexResolver() {
- return mock(IndexResolver.class);
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @Import(MongoHttpSessionConfiguration.class)
- static class ImportConfigAndCustomizeConfiguration extends BaseConfiguration {
-
- @Bean
- SessionRepositoryCustomizer sessionRepositoryCustomizer() {
- return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoHttpSession
- @Import(MongoConfiguration.class)
- static class SessionIdGeneratorConfiguration {
-
- @Bean
- SessionIdGenerator sessionIdGenerator() {
- return new TestSessionIdGenerator();
- }
-
- }
-
- static class TestSessionIdGenerator implements SessionIdGenerator {
-
- @Override
- public String generate() {
- return "test";
- }
-
- }
-
-}
diff --git a/src/test/java/org/springframework/session/data/mongo/config/annotation/web/reactive/ReactiveMongoWebSessionConfigurationTests.java b/src/test/java/org/springframework/session/data/mongo/config/annotation/web/reactive/ReactiveMongoWebSessionConfigurationTests.java
deleted file mode 100644
index 1a18bfe..0000000
--- a/src/test/java/org/springframework/session/data/mongo/config/annotation/web/reactive/ReactiveMongoWebSessionConfigurationTests.java
+++ /dev/null
@@ -1,454 +0,0 @@
-/*
- * Copyright 2014-present the original author or authors.
- *
- * Licensed 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
- *
- * https://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.
- */
-
-package org.springframework.session.data.mongo.config.annotation.web.reactive;
-
-import java.lang.reflect.Field;
-import java.time.Duration;
-import java.util.Collections;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Order;
-import org.junit.jupiter.api.Test;
-
-import org.springframework.beans.factory.UnsatisfiedDependencyException;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.ReactiveMongoOperations;
-import org.springframework.data.mongodb.core.index.IndexOperations;
-import org.springframework.session.IndexResolver;
-import org.springframework.session.ReactiveSessionRepository;
-import org.springframework.session.Session;
-import org.springframework.session.SessionIdGenerator;
-import org.springframework.session.UuidSessionIdGenerator;
-import org.springframework.session.config.ReactiveSessionRepositoryCustomizer;
-import org.springframework.session.config.annotation.web.server.EnableSpringWebSession;
-import org.springframework.session.data.mongo.AbstractMongoSessionConverter;
-import org.springframework.session.data.mongo.JacksonMongoSessionConverter;
-import org.springframework.session.data.mongo.JdkMongoSessionConverter;
-import org.springframework.session.data.mongo.ReactiveMongoSessionRepository;
-import org.springframework.util.ReflectionUtils;
-import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
-import org.springframework.web.server.session.WebSessionManager;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
-import static org.mockito.BDDMockito.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.mock;
-import static org.mockito.BDDMockito.times;
-import static org.mockito.BDDMockito.verify;
-
-/**
- * Verify various configurations through {@link EnableSpringWebSession}.
- *
- * @author Greg Turnquist
- * @author Vedran Pavic
- */
-class ReactiveMongoWebSessionConfigurationTests {
-
- private AnnotationConfigApplicationContext context;
-
- @AfterEach
- void tearDown() {
-
- if (this.context != null) {
- this.context.close();
- }
- }
-
- @Test
- void enableSpringWebSessionConfiguresThings() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(GoodConfig.class);
- this.context.refresh();
-
- WebSessionManager webSessionManagerFoundByType = this.context.getBean(WebSessionManager.class);
- Object webSessionManagerFoundByName = this.context.getBean(WebHttpHandlerBuilder.WEB_SESSION_MANAGER_BEAN_NAME);
-
- assertThat(webSessionManagerFoundByType).isNotNull();
- assertThat(webSessionManagerFoundByName).isNotNull();
- assertThat(webSessionManagerFoundByType).isEqualTo(webSessionManagerFoundByName);
-
- assertThat(this.context.getBean(ReactiveSessionRepository.class)).isNotNull();
- }
-
- @Test
- void missingReactorSessionRepositoryBreaksAppContext() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(BadConfig.class);
-
- assertThatExceptionOfType(UnsatisfiedDependencyException.class).isThrownBy(this.context::refresh)
- .withMessageContaining("Error creating bean with name 'reactiveMongoSessionRepository'")
- .withMessageContaining("No qualifying bean of type '" + ReactiveMongoOperations.class.getCanonicalName());
- }
-
- @Test
- void defaultSessionConverterShouldBeJdkWhenOnClasspath() throws IllegalAccessException {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(GoodConfig.class);
- this.context.refresh();
-
- ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
-
- AbstractMongoSessionConverter converter = findMongoSessionConverter(repository);
-
- assertThat(converter).isOfAnyClassIn(JdkMongoSessionConverter.class);
- }
-
- @Test
- void overridingMongoSessionConverterWithBeanShouldWork() throws IllegalAccessException {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(OverrideSessionConverterConfig.class);
- this.context.refresh();
-
- ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
-
- AbstractMongoSessionConverter converter = findMongoSessionConverter(repository);
-
- assertThat(converter).isOfAnyClassIn(JacksonMongoSessionConverter.class);
- }
-
- @Test
- void overridingIntervalAndCollectionNameThroughAnnotationShouldWork() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(OverrideMongoParametersConfig.class);
- this.context.refresh();
-
- ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
-
- assertThat(repository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(123));
- assertThat(repository).extracting("collectionName").isEqualTo("test-case");
- }
-
- @Test
- void reactiveAndBlockingMongoOperationsShouldEnsureIndexing() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(ConfigWithReactiveAndImperativeMongoOperations.class);
- this.context.refresh();
-
- MongoOperations operations = this.context.getBean(MongoOperations.class);
- IndexOperations indexOperations = this.context.getBean(IndexOperations.class);
-
- verify(operations, times(1)).indexOps((String) any());
- verify(indexOperations, times(1)).getIndexInfo();
- verify(indexOperations, times(1)).ensureIndex(any());
- }
-
- @Test
- void overrideCollectionAndInactiveIntervalThroughConfigurationOptions() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(CustomizedReactiveConfiguration.class);
- this.context.refresh();
-
- ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
-
- assertThat(repository.getCollectionName()).isEqualTo("custom-collection");
- assertThat(repository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(123));
- }
-
- @Test
- void sessionRepositoryCustomizer() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(SessionRepositoryCustomizerConfiguration.class);
- this.context.refresh();
-
- ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
-
- assertThat(repository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ofSeconds(10000));
- }
-
- @Test
- void customIndexResolverConfigurationWithDefaultMongoSessionConverter() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(CustomIndexResolverConfigurationWithDefaultMongoSessionConverter.class);
- this.context.refresh();
-
- ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
- IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
-
- assertThat(repository).isNotNull();
- assertThat(indexResolver).isNotNull();
- assertThat(repository).extracting("mongoSessionConverter")
- .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
- }
-
- @Test
- void customIndexResolverConfigurationWithProvidedMongoSessionConverter() {
-
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(CustomIndexResolverConfigurationWithProvidedtMongoSessionConverter.class);
- this.context.refresh();
-
- ReactiveMongoSessionRepository repository = this.context.getBean(ReactiveMongoSessionRepository.class);
- IndexResolver indexResolver = this.context.getBean(IndexResolver.class);
-
- assertThat(repository).isNotNull();
- assertThat(indexResolver).isNotNull();
- assertThat(repository).extracting("mongoSessionConverter")
- .hasFieldOrPropertyWithValue("indexResolver", indexResolver);
- }
-
- @Test
- void importConfigAndCustomize() {
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(ImportConfigAndCustomizeConfiguration.class);
- this.context.refresh();
- ReactiveMongoSessionRepository sessionRepository = this.context.getBean(ReactiveMongoSessionRepository.class);
- assertThat(sessionRepository).extracting("defaultMaxInactiveInterval").isEqualTo(Duration.ZERO);
- }
-
- @Test
- void registerWhenSessionIdGeneratorBeanThenUses() {
- registerAndRefresh(GoodConfig.class, SessionIdGeneratorConfiguration.class);
- ReactiveMongoSessionRepository sessionRepository = this.context.getBean(ReactiveMongoSessionRepository.class);
- assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(TestSessionIdGenerator.class);
- }
-
- @Test
- void registerWhenNoSessionIdGeneratorBeanThenDefault() {
- registerAndRefresh(GoodConfig.class);
- ReactiveMongoSessionRepository sessionRepository = this.context.getBean(ReactiveMongoSessionRepository.class);
- assertThat(sessionRepository).extracting("sessionIdGenerator").isInstanceOf(UuidSessionIdGenerator.class);
- }
-
- private void registerAndRefresh(Class... annotatedClasses) {
- this.context = new AnnotationConfigApplicationContext();
- this.context.register(annotatedClasses);
- this.context.refresh();
- }
-
- /**
- * Reflectively extract the {@link AbstractMongoSessionConverter} from the
- * {@link ReactiveMongoSessionRepository}. This is to avoid expanding the surface area
- * of the API.
- */
- private AbstractMongoSessionConverter findMongoSessionConverter(ReactiveMongoSessionRepository repository) {
-
- Field field = ReflectionUtils.findField(ReactiveMongoSessionRepository.class, "mongoSessionConverter");
- ReflectionUtils.makeAccessible(field);
- try {
- return (AbstractMongoSessionConverter) field.get(repository);
- }
- catch (IllegalAccessException ex) {
- throw new RuntimeException(ex);
- }
- }
-
- /**
- * A configuration with all the right parts.
- */
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession
- static class GoodConfig {
-
- @Bean
- ReactiveMongoOperations operations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- }
-
- /**
- * A configuration where no {@link ReactiveMongoOperations} is defined. It's BAD!
- */
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession
- static class BadConfig {
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession
- static class OverrideSessionConverterConfig {
-
- @Bean
- ReactiveMongoOperations operations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- @Bean
- AbstractMongoSessionConverter mongoSessionConverter() {
- return new JacksonMongoSessionConverter();
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession(maxInactiveIntervalInSeconds = 123, collectionName = "test-case")
- static class OverrideMongoParametersConfig {
-
- @Bean
- ReactiveMongoOperations operations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession
- static class ConfigWithReactiveAndImperativeMongoOperations {
-
- @Bean
- ReactiveMongoOperations reactiveMongoOperations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- @Bean
- IndexOperations indexOperations() {
-
- IndexOperations indexOperations = mock(IndexOperations.class);
- given(indexOperations.getIndexInfo()).willReturn(Collections.emptyList());
- return indexOperations;
- }
-
- @Bean
- MongoOperations mongoOperations(IndexOperations indexOperations) {
-
- MongoOperations mongoOperations = mock(MongoOperations.class);
- given(mongoOperations.indexOps((String) any())).willReturn(indexOperations);
- return mongoOperations;
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableSpringWebSession
- static class CustomizedReactiveConfiguration extends ReactiveMongoWebSessionConfiguration {
-
- CustomizedReactiveConfiguration() {
-
- this.setCollectionName("custom-collection");
- this.setMaxInactiveInterval(Duration.ofSeconds(123));
- }
-
- @Bean
- ReactiveMongoOperations reactiveMongoOperations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession
- static class SessionRepositoryCustomizerConfiguration {
-
- @Bean
- ReactiveMongoOperations operations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- @Bean
- @Order(0)
- ReactiveSessionRepositoryCustomizer sessionRepositoryCustomizerOne() {
- return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
- }
-
- @Bean
- @Order(1)
- ReactiveSessionRepositoryCustomizer sessionRepositoryCustomizerTwo() {
- return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ofSeconds(10000));
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession
- static class CustomIndexResolverConfigurationWithDefaultMongoSessionConverter {
-
- @Bean
- ReactiveMongoOperations operations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- @Bean
- @SuppressWarnings("unchecked")
- IndexResolver indexResolver() {
- return mock(IndexResolver.class);
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @EnableMongoWebSession
- static class CustomIndexResolverConfigurationWithProvidedtMongoSessionConverter {
-
- @Bean
- ReactiveMongoOperations operations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- @Bean
- JacksonMongoSessionConverter jacksonMongoSessionConverter() {
- return new JacksonMongoSessionConverter();
- }
-
- @Bean
- @SuppressWarnings("unchecked")
- IndexResolver indexResolver() {
- return mock(IndexResolver.class);
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- @Import(ReactiveMongoWebSessionConfiguration.class)
- static class ImportConfigAndCustomizeConfiguration {
-
- @Bean
- ReactiveMongoOperations operations() {
- return mock(ReactiveMongoOperations.class);
- }
-
- @Bean
- ReactiveSessionRepositoryCustomizer sessionRepositoryCustomizer() {
- return (sessionRepository) -> sessionRepository.setDefaultMaxInactiveInterval(Duration.ZERO);
- }
-
- }
-
- @Configuration(proxyBeanMethods = false)
- static class SessionIdGeneratorConfiguration {
-
- @Bean
- SessionIdGenerator sessionIdGenerator() {
- return new TestSessionIdGenerator();
- }
-
- }
-
- static class TestSessionIdGenerator implements SessionIdGenerator {
-
- @Override
- public String generate() {
- return "test";
- }
-
- }
-
-}