Reinstate support for Spring Data Couchbase

Closes gh-28976

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2020 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.
@@ -27,6 +27,7 @@ import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration.Cache
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration;
 import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
 import org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration;
 import org.springframework.boot.autoconfigure.orm.jpa.EntityManagerFactoryDependsOnPostProcessor;
@@ -60,8 +61,8 @@ import org.springframework.util.Assert;
 @ConditionalOnBean(CacheAspectSupport.class)
 @ConditionalOnMissingBean(value = CacheManager.class, name = "cacheResolver")
 @EnableConfigurationProperties(CacheProperties.class)
-@AutoConfigureAfter({ HazelcastAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
-		RedisAutoConfiguration.class })
+@AutoConfigureAfter({ CouchbaseDataAutoConfiguration.class, HazelcastAutoConfiguration.class,
+		HibernateJpaAutoConfiguration.class, RedisAutoConfiguration.class })
 @Import({ CacheConfigurationImportSelector.class, CacheManagerEntityManagerFactoryDependsOnPostProcessor.class })
 public class CacheAutoConfiguration {
 

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheConfigurations.java

@@ -38,6 +38,7 @@ final class CacheConfigurations {
 		mappings.put(CacheType.GENERIC, GenericCacheConfiguration.class.getName());
 		mappings.put(CacheType.HAZELCAST, HazelcastCacheConfiguration.class.getName());
 		mappings.put(CacheType.JCACHE, JCacheCacheConfiguration.class.getName());
+		mappings.put(CacheType.COUCHBASE, CouchbaseCacheConfiguration.class.getName());
 		mappings.put(CacheType.REDIS, RedisCacheConfiguration.class.getName());
 		mappings.put(CacheType.CAFFEINE, CaffeineCacheConfiguration.class.getName());
 		mappings.put(CacheType.SIMPLE, SimpleCacheConfiguration.class.getName());

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheType.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2019 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.
@@ -41,6 +41,11 @@ public enum CacheType {
 	 */
 	HAZELCAST,
 
+	/**
+	 * Couchbase backed caching.
+	 */
+	COUCHBASE,
+
 	/**
 	 * Redis backed caching.
 	 */

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CouchbaseCacheConfiguration.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2012-2021 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.boot.autoconfigure.cache;
+
+import java.util.LinkedHashSet;
+import java.util.List;
+
+import com.couchbase.client.java.Cluster;
+
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.boot.autoconfigure.cache.CacheProperties.Couchbase;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
+import org.springframework.cache.CacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Conditional;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.CouchbaseClientFactory;
+import org.springframework.data.couchbase.cache.CouchbaseCacheManager;
+import org.springframework.data.couchbase.cache.CouchbaseCacheManager.CouchbaseCacheManagerBuilder;
+import org.springframework.util.ObjectUtils;
+
+/**
+ * Couchbase cache configuration.
+ *
+ * @author Stephane Nicoll
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass({ Cluster.class, CouchbaseClientFactory.class, CouchbaseCacheManager.class })
+@ConditionalOnMissingBean(CacheManager.class)
+@ConditionalOnSingleCandidate(CouchbaseClientFactory.class)
+@Conditional(CacheCondition.class)
+class CouchbaseCacheConfiguration {
+
+	@Bean
+	CouchbaseCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers customizers,
+			ObjectProvider<CouchbaseCacheManagerBuilderCustomizer> couchbaseCacheManagerBuilderCustomizers,
+			CouchbaseClientFactory clientFactory) {
+		List<String> cacheNames = cacheProperties.getCacheNames();
+		CouchbaseCacheManagerBuilder builder = CouchbaseCacheManager.builder(clientFactory);
+		Couchbase couchbase = cacheProperties.getCouchbase();
+		org.springframework.data.couchbase.cache.CouchbaseCacheConfiguration config = org.springframework.data.couchbase.cache.CouchbaseCacheConfiguration
+				.defaultCacheConfig();
+		if (couchbase.getExpiration() != null) {
+			config = config.entryExpiry(couchbase.getExpiration());
+		}
+		builder.cacheDefaults(config);
+		if (!ObjectUtils.isEmpty(cacheNames)) {
+			builder.initialCacheNames(new LinkedHashSet<>(cacheNames));
+		}
+		couchbaseCacheManagerBuilderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
+		CouchbaseCacheManager cacheManager = builder.build();
+		return customizers.customize(cacheManager);
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CouchbaseCacheManagerBuilderCustomizer.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.cache;
+
+import org.springframework.data.couchbase.cache.CouchbaseCacheManager;
+import org.springframework.data.couchbase.cache.CouchbaseCacheManager.CouchbaseCacheManagerBuilder;
+
+/**
+ * Callback interface that can be implemented by beans wishing to customize the
+ * {@link CouchbaseCacheManagerBuilder} before it is used to build the auto-configured
+ * {@link CouchbaseCacheManager}.
+ *
+ * @author Stephane Nicoll
+ * @since 2.3.3
+ */
+@FunctionalInterface
+public interface CouchbaseCacheManagerBuilderCustomizer {
+
+	/**
+	 * Customize the {@link CouchbaseCacheManagerBuilder}.
+	 * @param builder the builder to customize
+	 */
+	void customize(CouchbaseCacheManagerBuilder builder);
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseClientFactoryConfiguration.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import com.couchbase.client.java.Cluster;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.CouchbaseClientFactory;
+import org.springframework.data.couchbase.SimpleCouchbaseClientFactory;
+
+/**
+ * Configuration for a {@link CouchbaseClientFactory}.
+ *
+ * @author Stephane Nicoll
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnSingleCandidate(Cluster.class)
+@ConditionalOnProperty("spring.data.couchbase.bucket-name")
+class CouchbaseClientFactoryConfiguration {
+
+	@Bean
+	@ConditionalOnMissingBean
+	CouchbaseClientFactory couchbaseClientFactory(Cluster cluster, CouchbaseDataProperties properties) {
+		return new SimpleCouchbaseClientFactory(cluster, properties.getBucketName(), properties.getScopeName());
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseClientFactoryDependentConfiguration.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012-2021 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.boot.autoconfigure.data.couchbase;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.CouchbaseClientFactory;
+import org.springframework.data.couchbase.config.BeanNames;
+import org.springframework.data.couchbase.core.CouchbaseTemplate;
+import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
+import org.springframework.data.couchbase.repository.config.RepositoryOperationsMapping;
+
+/**
+ * Configuration for Couchbase-related beans that depend on a
+ * {@link CouchbaseClientFactory}.
+ *
+ * @author Stephane Nicoll
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnSingleCandidate(CouchbaseClientFactory.class)
+class CouchbaseClientFactoryDependentConfiguration {
+
+	@Bean(name = BeanNames.COUCHBASE_TEMPLATE)
+	@ConditionalOnMissingBean(name = BeanNames.COUCHBASE_TEMPLATE)
+	CouchbaseTemplate couchbaseTemplate(CouchbaseClientFactory couchbaseClientFactory,
+			MappingCouchbaseConverter mappingCouchbaseConverter) {
+		return new CouchbaseTemplate(couchbaseClientFactory, mappingCouchbaseConverter);
+	}
+
+	@Bean(name = BeanNames.COUCHBASE_OPERATIONS_MAPPING)
+	@ConditionalOnMissingBean(name = BeanNames.COUCHBASE_OPERATIONS_MAPPING)
+	RepositoryOperationsMapping couchbaseRepositoryOperationsMapping(CouchbaseTemplate couchbaseTemplate) {
+		return new RepositoryOperationsMapping(couchbaseTemplate);
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseDataAutoConfiguration.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import jakarta.validation.Validator;
+
+import com.couchbase.client.java.Bucket;
+
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration;
+import org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.couchbase.core.mapping.event.ValidatingCouchbaseEventListener;
+import org.springframework.data.couchbase.repository.CouchbaseRepository;
+
+/**
+ * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's Couchbase support.
+ *
+ * @author Eddú Meléndez
+ * @author Stephane Nicoll
+ * @since 1.4.0
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass({ Bucket.class, CouchbaseRepository.class })
+@AutoConfigureAfter({ CouchbaseAutoConfiguration.class, ValidationAutoConfiguration.class })
+@EnableConfigurationProperties(CouchbaseDataProperties.class)
+@Import({ CouchbaseDataConfiguration.class, CouchbaseClientFactoryConfiguration.class,
+		CouchbaseClientFactoryDependentConfiguration.class })
+public class CouchbaseDataAutoConfiguration {
+
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass(Validator.class)
+	public static class ValidationConfiguration {
+
+		@Bean
+		@ConditionalOnSingleCandidate(Validator.class)
+		public ValidatingCouchbaseEventListener validationEventListener(Validator validator) {
+			return new ValidatingCouchbaseEventListener(validator);
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseDataConfiguration.java

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2012-2021 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.boot.autoconfigure.data.couchbase;
+
+import java.util.Collections;
+
+import org.springframework.beans.BeanUtils;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.domain.EntityScanner;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.config.BeanNames;
+import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions;
+import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
+import org.springframework.data.couchbase.core.convert.translation.JacksonTranslationService;
+import org.springframework.data.couchbase.core.convert.translation.TranslationService;
+import org.springframework.data.couchbase.core.mapping.CouchbaseMappingContext;
+import org.springframework.data.couchbase.core.mapping.Document;
+import org.springframework.data.mapping.model.FieldNamingStrategy;
+
+/**
+ * Configuration for Spring Data's couchbase support.
+ *
+ * @author Stephane Nicoll
+ */
+@Configuration(proxyBeanMethods = false)
+class CouchbaseDataConfiguration {
+
+	@Bean
+	@ConditionalOnMissingBean
+	MappingCouchbaseConverter couchbaseMappingConverter(CouchbaseDataProperties properties,
+			CouchbaseMappingContext couchbaseMappingContext, CouchbaseCustomConversions couchbaseCustomConversions) {
+		MappingCouchbaseConverter converter = new MappingCouchbaseConverter(couchbaseMappingContext,
+				properties.getTypeKey());
+		converter.setCustomConversions(couchbaseCustomConversions);
+		return converter;
+	}
+
+	@Bean
+	@ConditionalOnMissingBean
+	TranslationService couchbaseTranslationService() {
+		return new JacksonTranslationService();
+	}
+
+	@Bean(name = BeanNames.COUCHBASE_MAPPING_CONTEXT)
+	@ConditionalOnMissingBean(name = BeanNames.COUCHBASE_MAPPING_CONTEXT)
+	CouchbaseMappingContext couchbaseMappingContext(CouchbaseDataProperties properties,
+			ApplicationContext applicationContext, CouchbaseCustomConversions couchbaseCustomConversions)
+			throws Exception {
+		CouchbaseMappingContext mappingContext = new CouchbaseMappingContext();
+		mappingContext.setInitialEntitySet(new EntityScanner(applicationContext).scan(Document.class));
+		mappingContext.setSimpleTypeHolder(couchbaseCustomConversions.getSimpleTypeHolder());
+		Class<?> fieldNamingStrategy = properties.getFieldNamingStrategy();
+		if (fieldNamingStrategy != null) {
+			mappingContext
+					.setFieldNamingStrategy((FieldNamingStrategy) BeanUtils.instantiateClass(fieldNamingStrategy));
+		}
+		mappingContext.setAutoIndexCreation(properties.isAutoIndex());
+		return mappingContext;
+	}
+
+	@Bean(name = BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
+	@ConditionalOnMissingBean(name = BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
+	CouchbaseCustomConversions couchbaseCustomConversions() {
+		return new CouchbaseCustomConversions(Collections.emptyList());
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseDataProperties.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * Configuration properties for Spring Data Couchbase.
+ *
+ * @author Stephane Nicoll
+ * @since 1.4.0
+ */
+@ConfigurationProperties(prefix = "spring.data.couchbase")
+public class CouchbaseDataProperties {
+
+	/**
+	 * Automatically create views and indexes. Use the meta-data provided by
+	 * "@ViewIndexed", "@N1qlPrimaryIndexed" and "@N1qlSecondaryIndexed".
+	 */
+	private boolean autoIndex;
+
+	/**
+	 * Name of the bucket to connect to.
+	 */
+	private String bucketName;
+
+	/**
+	 * Name of the scope used for all collection access.
+	 */
+	private String scopeName;
+
+	/**
+	 * Fully qualified name of the FieldNamingStrategy to use.
+	 */
+	private Class<?> fieldNamingStrategy;
+
+	/**
+	 * Name of the field that stores the type information for complex types when using
+	 * "MappingCouchbaseConverter".
+	 */
+	private String typeKey = "_class";
+
+	public boolean isAutoIndex() {
+		return this.autoIndex;
+	}
+
+	public void setAutoIndex(boolean autoIndex) {
+		this.autoIndex = autoIndex;
+	}
+
+	public String getBucketName() {
+		return this.bucketName;
+	}
+
+	public void setBucketName(String bucketName) {
+		this.bucketName = bucketName;
+	}
+
+	public String getScopeName() {
+		return this.scopeName;
+	}
+
+	public void setScopeName(String scopeName) {
+		this.scopeName = scopeName;
+	}
+
+	public Class<?> getFieldNamingStrategy() {
+		return this.fieldNamingStrategy;
+	}
+
+	public void setFieldNamingStrategy(Class<?> fieldNamingStrategy) {
+		this.fieldNamingStrategy = fieldNamingStrategy;
+	}
+
+	public String getTypeKey() {
+		return this.typeKey;
+	}
+
+	public void setTypeKey(String typeKey) {
+		this.typeKey = typeKey;
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseReactiveDataAutoConfiguration.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import com.couchbase.client.java.Cluster;
+import reactor.core.publisher.Flux;
+
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.couchbase.repository.ReactiveCouchbaseRepository;
+
+/**
+ * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's Reactive Couchbase
+ * support.
+ *
+ * @author Alex Derkach
+ * @since 2.0.0
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass({ Cluster.class, ReactiveCouchbaseRepository.class, Flux.class })
+@AutoConfigureAfter(CouchbaseDataAutoConfiguration.class)
+@Import(CouchbaseReactiveDataConfiguration.class)
+public class CouchbaseReactiveDataAutoConfiguration {
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseReactiveDataConfiguration.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.CouchbaseClientFactory;
+import org.springframework.data.couchbase.config.BeanNames;
+import org.springframework.data.couchbase.core.ReactiveCouchbaseTemplate;
+import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
+import org.springframework.data.couchbase.repository.config.ReactiveRepositoryOperationsMapping;
+
+/**
+ * Configuration for Spring Data's couchbase reactive support.
+ *
+ * @author Stephane Nicoll
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnSingleCandidate(CouchbaseClientFactory.class)
+class CouchbaseReactiveDataConfiguration {
+
+	@Bean(name = BeanNames.REACTIVE_COUCHBASE_TEMPLATE)
+	@ConditionalOnMissingBean(name = BeanNames.REACTIVE_COUCHBASE_TEMPLATE)
+	ReactiveCouchbaseTemplate reactiveCouchbaseTemplate(CouchbaseClientFactory couchbaseClientFactory,
+			MappingCouchbaseConverter mappingCouchbaseConverter) {
+		return new ReactiveCouchbaseTemplate(couchbaseClientFactory, mappingCouchbaseConverter);
+	}
+
+	@Bean(name = BeanNames.REACTIVE_COUCHBASE_OPERATIONS_MAPPING)
+	@ConditionalOnMissingBean(name = BeanNames.REACTIVE_COUCHBASE_OPERATIONS_MAPPING)
+	ReactiveRepositoryOperationsMapping reactiveCouchbaseRepositoryOperationsMapping(
+			ReactiveCouchbaseTemplate reactiveCouchbaseTemplate) {
+		return new ReactiveRepositoryOperationsMapping(reactiveCouchbaseTemplate);
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseReactiveRepositoriesAutoConfiguration.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import com.couchbase.client.java.Cluster;
+import reactor.core.publisher.Flux;
+
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.data.ConditionalOnRepositoryType;
+import org.springframework.boot.autoconfigure.data.RepositoryType;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.couchbase.repository.ReactiveCouchbaseRepository;
+import org.springframework.data.couchbase.repository.config.ReactiveRepositoryOperationsMapping;
+import org.springframework.data.couchbase.repository.support.ReactiveCouchbaseRepositoryFactoryBean;
+
+/**
+ * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's Couchbase Reactive
+ * Repositories.
+ *
+ * @author Alex Derkach
+ * @since 2.0.0
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass({ Cluster.class, ReactiveCouchbaseRepository.class, Flux.class })
+@ConditionalOnRepositoryType(store = "couchbase", type = RepositoryType.REACTIVE)
+@ConditionalOnBean(ReactiveRepositoryOperationsMapping.class)
+@ConditionalOnMissingBean(ReactiveCouchbaseRepositoryFactoryBean.class)
+@Import(CouchbaseReactiveRepositoriesRegistrar.class)
+@AutoConfigureAfter(CouchbaseReactiveDataAutoConfiguration.class)
+public class CouchbaseReactiveRepositoriesAutoConfiguration {
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseReactiveRepositoriesRegistrar.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2012-2019 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.boot.autoconfigure.data.couchbase;
+
+import java.lang.annotation.Annotation;
+
+import org.springframework.boot.autoconfigure.data.AbstractRepositoryConfigurationSourceSupport;
+import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.data.couchbase.repository.config.EnableReactiveCouchbaseRepositories;
+import org.springframework.data.couchbase.repository.config.ReactiveCouchbaseRepositoryConfigurationExtension;
+import org.springframework.data.repository.config.RepositoryConfigurationExtension;
+
+/**
+ * {@link ImportBeanDefinitionRegistrar} used to auto-configure Spring Data Couchbase
+ * Reactive Repositories.
+ *
+ * @author Alex Derkach
+ */
+class CouchbaseReactiveRepositoriesRegistrar extends AbstractRepositoryConfigurationSourceSupport {
+
+	@Override
+	protected Class<? extends Annotation> getAnnotation() {
+		return EnableReactiveCouchbaseRepositories.class;
+	}
+
+	@Override
+	protected Class<?> getConfiguration() {
+		return EnableReactiveCouchbaseRepositoriesConfiguration.class;
+	}
+
+	@Override
+	protected RepositoryConfigurationExtension getRepositoryConfigurationExtension() {
+		return new ReactiveCouchbaseRepositoryConfigurationExtension();
+	}
+
+	@EnableReactiveCouchbaseRepositories
+	private static class EnableReactiveCouchbaseRepositoriesConfiguration {
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseRepositoriesAutoConfiguration.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2012-2019 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.boot.autoconfigure.data.couchbase;
+
+import com.couchbase.client.java.Bucket;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.data.ConditionalOnRepositoryType;
+import org.springframework.boot.autoconfigure.data.RepositoryType;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.couchbase.repository.CouchbaseRepository;
+import org.springframework.data.couchbase.repository.config.RepositoryOperationsMapping;
+import org.springframework.data.couchbase.repository.support.CouchbaseRepositoryFactoryBean;
+
+/**
+ * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's Couchbase
+ * Repositories.
+ *
+ * @author Eddú Meléndez
+ * @author Stephane Nicoll
+ * @since 1.4.0
+ */
+@Configuration(proxyBeanMethods = false)
+@ConditionalOnClass({ Bucket.class, CouchbaseRepository.class })
+@ConditionalOnBean(RepositoryOperationsMapping.class)
+@ConditionalOnRepositoryType(store = "couchbase", type = RepositoryType.IMPERATIVE)
+@ConditionalOnMissingBean(CouchbaseRepositoryFactoryBean.class)
+@Import(CouchbaseRepositoriesRegistrar.class)
+public class CouchbaseRepositoriesAutoConfiguration {
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseRepositoriesRegistrar.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2012-2019 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.boot.autoconfigure.data.couchbase;
+
+import java.lang.annotation.Annotation;
+
+import org.springframework.boot.autoconfigure.data.AbstractRepositoryConfigurationSourceSupport;
+import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.data.couchbase.repository.config.CouchbaseRepositoryConfigurationExtension;
+import org.springframework.data.couchbase.repository.config.EnableCouchbaseRepositories;
+import org.springframework.data.repository.config.RepositoryConfigurationExtension;
+
+/**
+ * {@link ImportBeanDefinitionRegistrar} used to auto-configure Spring Data Couchbase
+ * Repositories.
+ *
+ * @author Eddú Meléndez
+ */
+class CouchbaseRepositoriesRegistrar extends AbstractRepositoryConfigurationSourceSupport {
+
+	@Override
+	protected Class<? extends Annotation> getAnnotation() {
+		return EnableCouchbaseRepositories.class;
+	}
+
+	@Override
+	protected Class<?> getConfiguration() {
+		return EnableCouchbaseRepositoriesConfiguration.class;
+	}
+
+	@Override
+	protected RepositoryConfigurationExtension getRepositoryConfigurationExtension() {
+		return new CouchbaseRepositoryConfigurationExtension();
+	}
+
+	@EnableCouchbaseRepositories
+	private static class EnableCouchbaseRepositoriesConfiguration {
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/data/couchbase/package-info.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2012-2019 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.
+ */
+
+/**
+ * Auto-configuration for Spring Data Couchbase.
+ */
+package org.springframework.boot.autoconfigure.data.couchbase;

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/domain/EntityScan.java

@@ -38,9 +38,11 @@ import org.springframework.core.annotation.AliasFor;
  * {@link org.springframework.data.mapping.context.AbstractMappingContext#setInitialEntitySet(java.util.Set)
  * initial entity set} used with Spring Data
  * {@link org.springframework.data.mongodb.core.mapping.MongoMappingContext MongoDB},
- * {@link org.springframework.data.neo4j.core.mapping.Neo4jMappingContext Neo4j} and
+ * {@link org.springframework.data.neo4j.core.mapping.Neo4jMappingContext Neo4j},
  * {@link org.springframework.data.cassandra.core.mapping.CassandraMappingContext
- * Cassandra} mapping contexts.</li>
+ * Cassandra} and
+ * {@link org.springframework.data.couchbase.core.mapping.CouchbaseMappingContext
+ * Couchbase} mapping contexts.</li>
  * </ul>
  * <p>
  * One of {@link #basePackageClasses()}, {@link #basePackages()} or its alias

spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

@@ -39,6 +39,10 @@ org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfigura
 org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
+org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
+org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
+org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
+org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
 org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/AbstractCacheAutoConfigurationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2020 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.
@@ -33,6 +33,7 @@ import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
 import org.springframework.cache.support.SimpleCacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.cache.CouchbaseCacheManager;
 import org.springframework.data.redis.cache.RedisCacheManager;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -97,6 +98,13 @@ abstract class AbstractCacheAutoConfigurationTests {
 			};
 		}
 
+		@Bean
+		CacheManagerCustomizer<CouchbaseCacheManager> couchbaseCacheManagerCustomizer() {
+			return new CacheManagerTestCustomizer<CouchbaseCacheManager>() {
+
+			};
+		}
+
 		@Bean
 		CacheManagerCustomizer<RedisCacheManager> redisCacheManagerCustomizer() {
 			return new CacheManagerTestCustomizer<>() {

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfigurationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2020 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.
@@ -59,6 +59,10 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
+import org.springframework.data.couchbase.CouchbaseClientFactory;
+import org.springframework.data.couchbase.cache.CouchbaseCache;
+import org.springframework.data.couchbase.cache.CouchbaseCacheConfiguration;
+import org.springframework.data.couchbase.cache.CouchbaseCacheManager;
 import org.springframework.data.redis.cache.RedisCacheConfiguration;
 import org.springframework.data.redis.cache.RedisCacheManager;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
@@ -185,6 +189,64 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
 				});
 	}
 
+	@Test
+	void couchbaseCacheExplicit() {
+		this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
+				.withPropertyValues("spring.cache.type=couchbase").run((context) -> {
+					CouchbaseCacheManager cacheManager = getCacheManager(context, CouchbaseCacheManager.class);
+					assertThat(cacheManager.getCacheNames()).isEmpty();
+				});
+	}
+
+	@Test
+	void couchbaseCacheWithCustomizers() {
+		this.contextRunner.withUserConfiguration(CouchbaseWithCustomizersConfiguration.class)
+				.withPropertyValues("spring.cache.type=couchbase")
+				.run(verifyCustomizers("allCacheManagerCustomizer", "couchbaseCacheManagerCustomizer"));
+	}
+
+	@Test
+	void couchbaseCacheExplicitWithCaches() {
+		this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
+				.withPropertyValues("spring.cache.type=couchbase", "spring.cache.cacheNames[0]=foo",
+						"spring.cache.cacheNames[1]=bar")
+				.run((context) -> {
+					CouchbaseCacheManager cacheManager = getCacheManager(context, CouchbaseCacheManager.class);
+					assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
+					Cache cache = cacheManager.getCache("foo");
+					assertThat(cache).isInstanceOf(CouchbaseCache.class);
+					assertThat(((CouchbaseCache) cache).getCacheConfiguration().getExpiry()).hasSeconds(0);
+				});
+	}
+
+	@Test
+	void couchbaseCacheExplicitWithTtl() {
+		this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
+				.withPropertyValues("spring.cache.type=couchbase", "spring.cache.cacheNames=foo,bar",
+						"spring.cache.couchbase.expiration=2000")
+				.run((context) -> {
+					CouchbaseCacheManager cacheManager = getCacheManager(context, CouchbaseCacheManager.class);
+					assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
+					Cache cache = cacheManager.getCache("foo");
+					assertThat(cache).isInstanceOf(CouchbaseCache.class);
+					assertThat(((CouchbaseCache) cache).getCacheConfiguration().getExpiry()).hasSeconds(2);
+				});
+	}
+
+	@Test
+	void couchbaseCacheWithCouchbaseCacheManagerBuilderCustomizer() {
+		this.contextRunner.withUserConfiguration(CouchbaseConfiguration.class)
+				.withPropertyValues("spring.cache.type=couchbase", "spring.cache.couchbase.expiration=15s")
+				.withBean(CouchbaseCacheManagerBuilderCustomizer.class, () -> (builder) -> builder.cacheDefaults(
+						CouchbaseCacheConfiguration.defaultCacheConfig().entryExpiry(java.time.Duration.ofSeconds(10))))
+				.run((context) -> {
+					CouchbaseCacheManager cacheManager = getCacheManager(context, CouchbaseCacheManager.class);
+					CouchbaseCacheConfiguration couchbaseCacheConfiguration = getDefaultCouchbaseCacheConfiguration(
+							cacheManager);
+					assertThat(couchbaseCacheConfiguration.getExpiry()).isEqualTo(java.time.Duration.ofSeconds(10));
+				});
+	}
+
 	@Test
 	void redisCacheExplicit() {
 		this.contextRunner.withUserConfiguration(RedisConfiguration.class)
@@ -550,6 +612,10 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
 		assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount()).isEqualTo(1L);
 	}
 
+	private CouchbaseCacheConfiguration getDefaultCouchbaseCacheConfiguration(CouchbaseCacheManager cacheManager) {
+		return (CouchbaseCacheConfiguration) ReflectionTestUtils.getField(cacheManager, "defaultCacheConfig");
+	}
+
 	private RedisCacheConfiguration getDefaultRedisCacheConfiguration(RedisCacheManager cacheManager) {
 		return (RedisCacheConfiguration) ReflectionTestUtils.getField(cacheManager, "defaultCacheConfig");
 	}
@@ -601,6 +667,23 @@ class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
 
 	}
 
+	@Configuration(proxyBeanMethods = false)
+	@EnableCaching
+	static class CouchbaseConfiguration {
+
+		@Bean
+		CouchbaseClientFactory couchbaseClientFactory() {
+			return mock(CouchbaseClientFactory.class);
+		}
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@Import({ CouchbaseConfiguration.class, CacheManagerCustomizersConfiguration.class })
+	static class CouchbaseWithCustomizersConfiguration {
+
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	@EnableCaching
 	static class RedisConfiguration {

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/alt/couchbase/CityCouchbaseRepository.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012-2019 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.boot.autoconfigure.data.alt.couchbase;
+
+import org.springframework.boot.autoconfigure.data.couchbase.city.City;
+import org.springframework.data.repository.Repository;
+
+public interface CityCouchbaseRepository extends Repository<City, Long> {
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/alt/couchbase/ReactiveCityCouchbaseRepository.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2012-2019 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.boot.autoconfigure.data.alt.couchbase;
+
+import org.springframework.boot.autoconfigure.data.couchbase.city.City;
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+
+public interface ReactiveCityCouchbaseRepository extends ReactiveCrudRepository<City, Long> {
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseDataAutoConfigurationTests.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import java.util.Collections;
+import java.util.Set;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseProperties;
+import org.springframework.boot.autoconfigure.data.couchbase.city.City;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.couchbase.config.BeanNames;
+import org.springframework.data.couchbase.core.CouchbaseTemplate;
+import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions;
+import org.springframework.data.couchbase.core.convert.DefaultCouchbaseTypeMapper;
+import org.springframework.data.couchbase.core.convert.MappingCouchbaseConverter;
+import org.springframework.data.couchbase.core.mapping.CouchbaseMappingContext;
+import org.springframework.data.couchbase.core.mapping.event.ValidatingCouchbaseEventListener;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CouchbaseDataAutoConfiguration}.
+ *
+ * @author Stephane Nicoll
+ */
+class CouchbaseDataAutoConfigurationTests {
+
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
+			.withConfiguration(AutoConfigurations.of(ValidationAutoConfiguration.class,
+					CouchbaseAutoConfiguration.class, CouchbaseDataAutoConfiguration.class));
+
+	@Test
+	void disabledIfCouchbaseIsNotConfigured() {
+		this.contextRunner.run((context) -> assertThat(context).doesNotHaveBean(CouchbaseTemplate.class));
+	}
+
+	@Test
+	void validatorIsPresent() {
+		this.contextRunner.run((context) -> assertThat(context).hasSingleBean(ValidatingCouchbaseEventListener.class));
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	void entityScanShouldSetInitialEntitySet() {
+		this.contextRunner.withUserConfiguration(EntityScanConfig.class).run((context) -> {
+			CouchbaseMappingContext mappingContext = context.getBean(CouchbaseMappingContext.class);
+			Set<Class<?>> initialEntitySet = (Set<Class<?>>) ReflectionTestUtils.getField(mappingContext,
+					"initialEntitySet");
+			assertThat(initialEntitySet).containsOnly(City.class);
+		});
+	}
+
+	@Test
+	void typeKeyDefault() {
+		this.contextRunner.withUserConfiguration(CouchbaseMockConfiguration.class)
+				.run((context) -> assertThat(context.getBean(MappingCouchbaseConverter.class).getTypeKey())
+						.isEqualTo(DefaultCouchbaseTypeMapper.DEFAULT_TYPE_KEY));
+	}
+
+	@Test
+	void typeKeyCanBeCustomized() {
+		this.contextRunner.withUserConfiguration(CouchbaseMockConfiguration.class)
+				.withPropertyValues("spring.data.couchbase.type-key=_custom")
+				.run((context) -> assertThat(context.getBean(MappingCouchbaseConverter.class).getTypeKey())
+						.isEqualTo("_custom"));
+	}
+
+	@Test
+	void customConversions() {
+		this.contextRunner.withUserConfiguration(CustomConversionsConfig.class).run((context) -> {
+			CouchbaseTemplate template = context.getBean(CouchbaseTemplate.class);
+			assertThat(
+					template.getConverter().getConversionService().canConvert(CouchbaseProperties.class, Boolean.class))
+							.isTrue();
+		});
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@Import(CouchbaseMockConfiguration.class)
+	static class CustomConversionsConfig {
+
+		@Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
+		CouchbaseCustomConversions myCustomConversions() {
+			return new CouchbaseCustomConversions(Collections.singletonList(new MyConverter()));
+		}
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@EntityScan("org.springframework.boot.autoconfigure.data.couchbase.city")
+	@Import(CouchbaseMockConfiguration.class)
+	static class EntityScanConfig {
+
+	}
+
+	static class MyConverter implements Converter<CouchbaseProperties, Boolean> {
+
+		@Override
+		public Boolean convert(CouchbaseProperties value) {
+			return true;
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseDataPropertiesTests.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.data.couchbase.core.convert.DefaultCouchbaseTypeMapper;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CouchbaseDataProperties}.
+ *
+ * @author Stephane Nicoll
+ */
+class CouchbaseDataPropertiesTests {
+
+	@Test
+	void typeKeyHasConsistentDefault() {
+		assertThat(new CouchbaseDataProperties().getTypeKey()).isEqualTo(DefaultCouchbaseTypeMapper.DEFAULT_TYPE_KEY);
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseMockConfiguration.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.couchbase.CouchbaseClientFactory;
+
+import static org.mockito.Mockito.mock;
+
+/**
+ * Test configuration that mocks access to Couchbase.
+ *
+ * @author Stephane Nicoll
+ */
+@Configuration(proxyBeanMethods = false)
+class CouchbaseMockConfiguration {
+
+	@Bean
+	CouchbaseClientFactory couchbaseClientFactory() {
+		return mock(CouchbaseClientFactory.class);
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseReactiveAndImperativeRepositoriesAutoConfigurationTests.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2012-2021 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.boot.autoconfigure.data.couchbase;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.autoconfigure.TestAutoConfigurationPackage;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration;
+import org.springframework.boot.autoconfigure.data.couchbase.city.CityRepository;
+import org.springframework.boot.autoconfigure.data.couchbase.city.ReactiveCityRepository;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.ImportSelector;
+import org.springframework.core.type.AnnotationMetadata;
+import org.springframework.data.couchbase.repository.config.EnableCouchbaseRepositories;
+import org.springframework.data.couchbase.repository.config.EnableReactiveCouchbaseRepositories;
+import org.springframework.util.StringUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CouchbaseRepositoriesAutoConfiguration} and
+ * {@link CouchbaseReactiveRepositoriesAutoConfiguration}.
+ *
+ * @author Stephane Nicoll
+ */
+class CouchbaseReactiveAndImperativeRepositoriesAutoConfigurationTests {
+
+	@Test
+	void shouldCreateInstancesForReactiveAndImperativeRepositories() {
+		new ApplicationContextRunner()
+				.withUserConfiguration(ImperativeAndReactiveConfiguration.class, BaseConfiguration.class)
+				.run((context) -> assertThat(context).hasSingleBean(CityRepository.class)
+						.hasSingleBean(ReactiveCityRepository.class));
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@TestAutoConfigurationPackage(CouchbaseAutoConfiguration.class)
+	@EnableCouchbaseRepositories(basePackageClasses = CityRepository.class)
+	@EnableReactiveCouchbaseRepositories(basePackageClasses = ReactiveCityRepository.class)
+	static class ImperativeAndReactiveConfiguration {
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@Import({ CouchbaseMockConfiguration.class, Registrar.class })
+	static class BaseConfiguration {
+
+	}
+
+	static class Registrar implements ImportSelector {
+
+		@Override
+		public String[] selectImports(AnnotationMetadata importingClassMetadata) {
+			List<String> names = new ArrayList<>();
+			for (Class<?> type : new Class<?>[] { CouchbaseAutoConfiguration.class,
+					CouchbaseDataAutoConfiguration.class, CouchbaseRepositoriesAutoConfiguration.class,
+					CouchbaseReactiveDataAutoConfiguration.class,
+					CouchbaseReactiveRepositoriesAutoConfiguration.class }) {
+				names.add(type.getName());
+			}
+			return StringUtils.toStringArray(names);
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseReactiveDataAutoConfigurationTests.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import java.util.Collections;
+import java.util.Set;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseProperties;
+import org.springframework.boot.autoconfigure.data.couchbase.city.City;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.couchbase.config.BeanNames;
+import org.springframework.data.couchbase.core.ReactiveCouchbaseTemplate;
+import org.springframework.data.couchbase.core.convert.CouchbaseCustomConversions;
+import org.springframework.data.couchbase.core.mapping.CouchbaseMappingContext;
+import org.springframework.data.couchbase.core.mapping.event.ValidatingCouchbaseEventListener;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CouchbaseReactiveDataAutoConfiguration}.
+ *
+ * @author Alex Derkach
+ * @author Stephane Nicoll
+ */
+class CouchbaseReactiveDataAutoConfigurationTests {
+
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().withConfiguration(
+			AutoConfigurations.of(ValidationAutoConfiguration.class, CouchbaseAutoConfiguration.class,
+					CouchbaseDataAutoConfiguration.class, CouchbaseReactiveDataAutoConfiguration.class));
+
+	@Test
+	void disabledIfCouchbaseIsNotConfigured() {
+		this.contextRunner.run((context) -> assertThat(context).doesNotHaveBean(ReactiveCouchbaseTemplate.class));
+	}
+
+	@Test
+	void validatorIsPresent() {
+		this.contextRunner.run((context) -> assertThat(context).hasSingleBean(ValidatingCouchbaseEventListener.class));
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	void entityScanShouldSetInitialEntitySet() {
+		this.contextRunner.withUserConfiguration(EntityScanConfig.class).run((context) -> {
+			CouchbaseMappingContext mappingContext = context.getBean(CouchbaseMappingContext.class);
+			Set<Class<?>> initialEntitySet = (Set<Class<?>>) ReflectionTestUtils.getField(mappingContext,
+					"initialEntitySet");
+			assertThat(initialEntitySet).containsOnly(City.class);
+		});
+	}
+
+	@Test
+	void customConversions() {
+		this.contextRunner.withUserConfiguration(CustomConversionsConfig.class).run((context) -> {
+			ReactiveCouchbaseTemplate template = context.getBean(ReactiveCouchbaseTemplate.class);
+			assertThat(
+					template.getConverter().getConversionService().canConvert(CouchbaseProperties.class, Boolean.class))
+							.isTrue();
+		});
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@Import(CouchbaseMockConfiguration.class)
+	static class CustomConversionsConfig {
+
+		@Bean(BeanNames.COUCHBASE_CUSTOM_CONVERSIONS)
+		CouchbaseCustomConversions myCustomConversions() {
+			return new CouchbaseCustomConversions(Collections.singletonList(new MyConverter()));
+		}
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@EntityScan("org.springframework.boot.autoconfigure.data.couchbase.city")
+	@Import(CouchbaseMockConfiguration.class)
+	static class EntityScanConfig {
+
+	}
+
+	static class MyConverter implements Converter<CouchbaseProperties, Boolean> {
+
+		@Override
+		public Boolean convert(CouchbaseProperties value) {
+			return true;
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseReactiveRepositoriesAutoConfigurationTests.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.autoconfigure.TestAutoConfigurationPackage;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration;
+import org.springframework.boot.autoconfigure.data.alt.couchbase.CityCouchbaseRepository;
+import org.springframework.boot.autoconfigure.data.alt.couchbase.ReactiveCityCouchbaseRepository;
+import org.springframework.boot.autoconfigure.data.couchbase.city.City;
+import org.springframework.boot.autoconfigure.data.couchbase.city.ReactiveCityRepository;
+import org.springframework.boot.autoconfigure.data.empty.EmptyDataPackage;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.data.couchbase.repository.config.EnableCouchbaseRepositories;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CouchbaseReactiveRepositoriesAutoConfiguration}.
+ *
+ * @author Alex Derkach
+ * @author Stephane Nicoll
+ */
+class CouchbaseReactiveRepositoriesAutoConfigurationTests {
+
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().withConfiguration(
+			AutoConfigurations.of(CouchbaseAutoConfiguration.class, CouchbaseDataAutoConfiguration.class,
+					CouchbaseRepositoriesAutoConfiguration.class, CouchbaseReactiveDataAutoConfiguration.class,
+					CouchbaseReactiveRepositoriesAutoConfiguration.class));
+
+	@Test
+	void couchbaseNotAvailable() {
+		this.contextRunner.run((context) -> assertThat(context).doesNotHaveBean(ReactiveCityRepository.class));
+	}
+
+	@Test
+	void defaultRepository() {
+		this.contextRunner.withUserConfiguration(DefaultConfiguration.class)
+				.run((context) -> assertThat(context).hasSingleBean(ReactiveCityRepository.class));
+	}
+
+	@Test
+	void imperativeRepositories() {
+		this.contextRunner.withUserConfiguration(DefaultConfiguration.class)
+				.withPropertyValues("spring.data.couchbase.repositories.type=imperative")
+				.run((context) -> assertThat(context).doesNotHaveBean(ReactiveCityRepository.class));
+	}
+
+	@Test
+	void disabledRepositories() {
+		this.contextRunner.withUserConfiguration(DefaultConfiguration.class)
+				.withPropertyValues("spring.data.couchbase.repositories.type=none")
+				.run((context) -> assertThat(context).doesNotHaveBean(ReactiveCityRepository.class));
+	}
+
+	@Test
+	void noRepositoryAvailable() {
+		this.contextRunner.withUserConfiguration(NoRepositoryConfiguration.class)
+				.run((context) -> assertThat(context).doesNotHaveBean(ReactiveCityRepository.class));
+	}
+
+	@Test
+	void doesNotTriggerDefaultRepositoryDetectionIfCustomized() {
+		this.contextRunner.withUserConfiguration(CustomizedConfiguration.class)
+				.run((context) -> assertThat(context).doesNotHaveBean(ReactiveCityCouchbaseRepository.class));
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@TestAutoConfigurationPackage(City.class)
+	@Import(CouchbaseMockConfiguration.class)
+	static class DefaultConfiguration {
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@TestAutoConfigurationPackage(EmptyDataPackage.class)
+	@Import(CouchbaseMockConfiguration.class)
+	static class NoRepositoryConfiguration {
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@TestAutoConfigurationPackage(CouchbaseReactiveRepositoriesAutoConfigurationTests.class)
+	@EnableCouchbaseRepositories(basePackageClasses = CityCouchbaseRepository.class)
+	@Import(CouchbaseMockConfiguration.class)
+	static class CustomizedConfiguration {
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/CouchbaseRepositoriesAutoConfigurationTests.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.autoconfigure.TestAutoConfigurationPackage;
+import org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration;
+import org.springframework.boot.autoconfigure.data.couchbase.city.City;
+import org.springframework.boot.autoconfigure.data.couchbase.city.CityRepository;
+import org.springframework.boot.autoconfigure.data.empty.EmptyDataPackage;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CouchbaseRepositoriesAutoConfiguration}.
+ *
+ * @author Eddú Meléndez
+ * @author Stephane Nicoll
+ */
+class CouchbaseRepositoriesAutoConfigurationTests {
+
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
+			.withConfiguration(AutoConfigurations.of(CouchbaseAutoConfiguration.class,
+					CouchbaseDataAutoConfiguration.class, CouchbaseRepositoriesAutoConfiguration.class));
+
+	@Test
+	void couchbaseNotAvailable() {
+		this.contextRunner.run((context) -> assertThat(context).doesNotHaveBean(CityRepository.class));
+	}
+
+	@Test
+	void defaultRepository() {
+		this.contextRunner.withUserConfiguration(DefaultConfiguration.class)
+				.run((context) -> assertThat(context).hasSingleBean(CityRepository.class));
+	}
+
+	@Test
+	void reactiveRepositories() {
+		this.contextRunner.withUserConfiguration(DefaultConfiguration.class)
+				.withPropertyValues("spring.data.couchbase.repositories.type=reactive")
+				.run((context) -> assertThat(context).doesNotHaveBean(CityRepository.class));
+	}
+
+	@Test
+	void disabledRepositories() {
+		this.contextRunner.withUserConfiguration(DefaultConfiguration.class)
+				.withPropertyValues("spring.data.couchbase.repositories.type=none")
+				.run((context) -> assertThat(context).doesNotHaveBean(CityRepository.class));
+	}
+
+	@Test
+	void noRepositoryAvailable() {
+		this.contextRunner.withUserConfiguration(NoRepositoryConfiguration.class)
+				.run((context) -> assertThat(context).doesNotHaveBean(CityRepository.class));
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@TestAutoConfigurationPackage(City.class)
+	static class CouchbaseNotAvailableConfiguration {
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@TestAutoConfigurationPackage(City.class)
+	@Import(CouchbaseMockConfiguration.class)
+	static class DefaultConfiguration {
+
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	@TestAutoConfigurationPackage(EmptyDataPackage.class)
+	@Import(CouchbaseMockConfiguration.class)
+	static class NoRepositoryConfiguration {
+
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/city/City.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2012-2020 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.boot.autoconfigure.data.couchbase.city;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.couchbase.core.mapping.Document;
+import org.springframework.data.couchbase.core.mapping.Field;
+
+@Document
+public class City {
+
+	@Id
+	private String id;
+
+	@Field
+	private String name;
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/city/CityRepository.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2012-2019 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.boot.autoconfigure.data.couchbase.city;
+
+import org.springframework.data.repository.Repository;
+
+public interface CityRepository extends Repository<City, Long> {
+
+}

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/couchbase/city/ReactiveCityRepository.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2012-2019 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.boot.autoconfigure.data.couchbase.city;
+
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.repository.Repository;
+
+public interface ReactiveCityRepository extends Repository<City, Long> {
+
+	Mono<City> save(City city);
+
+	Mono<City> findById(Long id);
+
+}