Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

spring-4/src/test/java/com/baeldung/flips/controller/FlipControllerIntegrationTest.java

@@ -0,0 +1,74 @@
+package com.baeldung.flips.controller;
+
+import org.hamcrest.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(properties = {
+    "feature.foo.by.id=Y",
+    "feature.new.foo=Y",
+    "last.active.after=2018-03-14T00:00:00Z",
+    "first.active.after=2999-03-15T00:00:00Z",
+    "logging.level.org.flips=info"
+
+}, webEnvironment = SpringBootTest.WebEnvironment.MOCK)
+@AutoConfigureMockMvc
+@ActiveProfiles("dev")
+public class FlipControllerIntegrationTest {
+
+    @Autowired private MockMvc mvc;
+
+    @Test
+    public void givenValidDayOfWeek_APIAvailable() throws Exception {
+        mvc.perform(MockMvcRequestBuilders.get("/foo/1"))
+            .andExpect(MockMvcResultMatchers.status().is(200))
+            .andExpect(MockMvcResultMatchers.jsonPath("$.name", Matchers.equalTo("Foo1")))
+            .andExpect(MockMvcResultMatchers.jsonPath("$.id", Matchers.equalTo(1)));
+    }
+
+    @Test
+    public void givenValidDate_APIAvailable() throws Exception {
+        mvc.perform(MockMvcRequestBuilders.get("/foo/last"))
+            .andExpect(MockMvcResultMatchers.status().is(200))
+            .andExpect(MockMvcResultMatchers.jsonPath("$.name", Matchers.equalTo("Foo6")))
+            .andExpect(MockMvcResultMatchers.jsonPath("$.id", Matchers.equalTo(6)));
+    }
+
+    @Test
+    public void givenInvalidDate_APINotAvailable() throws Exception {
+        mvc.perform(MockMvcRequestBuilders.get("/foo/first"))
+            .andExpect(MockMvcResultMatchers.status().is(501));
+    }
+
+    @Test
+    public void givenCorrectProfile_APIAvailable() throws Exception {
+        mvc.perform(MockMvcRequestBuilders.get("/foos"))
+            .andExpect(MockMvcResultMatchers.status().isOk())
+            .andExpect(MockMvcResultMatchers.jsonPath("$", Matchers.hasSize(6)));
+    }
+
+    @Test
+    public void givenPropertySet_APIAvailable() throws Exception {
+        mvc.perform(MockMvcRequestBuilders.get("/foos/1"))
+            .andExpect(MockMvcResultMatchers.status().isOk())
+            .andExpect(MockMvcResultMatchers.jsonPath("$.name", Matchers.equalTo("Foo1")))
+            .andExpect(MockMvcResultMatchers.jsonPath("$.id", Matchers.equalTo(1)));
+    }
+
+    @Test
+    public void getValidExpression_FlipBean() throws Exception {
+        mvc.perform(MockMvcRequestBuilders.get("/foo/new"))
+            .andExpect(MockMvcResultMatchers.status().is(200))
+            .andExpect(MockMvcResultMatchers.jsonPath("$.name", Matchers.equalTo("Shiny New Foo!")))
+            .andExpect(MockMvcResultMatchers.jsonPath("$.id", Matchers.equalTo(100)));
+    }
+}

spring-4/src/test/java/com/baeldung/hikari/ApplicationWithHikariConnectionPool.java

@@ -0,0 +1,12 @@
+package com.baeldung.hikari;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class ApplicationWithHikariConnectionPool {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ApplicationWithHikariConnectionPool.class, args);
+    }
+}

spring-4/src/test/java/com/baeldung/hikari/HikariIntegrationTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.hikari;
+
+import static org.junit.Assert.*;
+
+import javax.sql.DataSource;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(
+    // instead of setting this property, we can exclude the dependency to org.apache.tomcat:tomcat-jdbc in pom.xml
+    properties = "spring.datasource.type=com.zaxxer.hikari.HikariDataSource")
+public class HikariIntegrationTest {
+
+    @Autowired
+    private DataSource dataSource;
+
+    @Test
+    public void hikariConnectionPoolIsConfigured() {
+        assertEquals("com.zaxxer.hikari.HikariDataSource", dataSource.getClass()
+            .getName());
+    }
+
+}

spring-4/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,20 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+
+import com.baeldung.flips.ApplicationConfig;
+
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = ApplicationConfig.class)
+@WebAppConfiguration
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-4/src/test/java/org/baeldung/SpringContextTest.java

@@ -0,0 +1,20 @@
+package org.baeldung;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.web.WebAppConfiguration;
+
+import com.baeldung.flips.ApplicationConfig;
+
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = ApplicationConfig.class)
+@WebAppConfiguration
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

spring-4/src/test/java/org/baeldung/spring43/attributeannotations/AttributeAnnotationConfiguration.java

@@ -0,0 +1,30 @@
+package org.baeldung.spring43.attributeannotations;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.ViewResolver;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+import org.springframework.web.servlet.view.InternalResourceViewResolver;
+
+@Configuration
+@ComponentScan
+@EnableWebMvc
+public class AttributeAnnotationConfiguration extends WebMvcConfigurerAdapter {
+
+    @Bean
+    public ViewResolver viewResolver() {
+        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
+        viewResolver.setPrefix("/WEB-INF/jsp/view/");
+        viewResolver.setSuffix(".jsp");
+        return viewResolver;
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(new ParamInterceptor());
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/attributeannotations/AttributeAnnotationIntegrationTest.java

@@ -0,0 +1,39 @@
+package org.baeldung.spring43.attributeannotations;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@ContextConfiguration(classes = AttributeAnnotationConfiguration.class)
+@WebAppConfiguration
+public class AttributeAnnotationIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    private WebApplicationContext wac;
+
+    @Before
+    public void setup() {
+        this.mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
+    }
+
+    @Test
+    public void whenInterceptorAddsRequestAndSessionParams_thenParamsInjectedWithAttributesAnnotations() throws Exception {
+        String result = this.mockMvc.perform(get("/test").accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+
+        Assert.assertEquals("login = john, query = invoices", result);
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/cache/CacheRefinementsConfiguration.java

@@ -0,0 +1,25 @@
+package org.baeldung.spring43.cache;
+
+import java.util.Collections;
+
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.concurrent.ConcurrentMapCache;
+import org.springframework.cache.support.SimpleCacheManager;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan
+@EnableCaching
+public class CacheRefinementsConfiguration {
+
+    @Bean
+    public CacheManager cacheManager() {
+        SimpleCacheManager manager = new SimpleCacheManager();
+        manager.setCaches(Collections.singletonList(new ConcurrentMapCache("foos")));
+        return manager;
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/cache/CacheRefinementsIntegrationTest.java

@@ -0,0 +1,31 @@
+package org.baeldung.spring43.cache;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+
+import static org.junit.Assert.assertEquals;
+
+@ContextConfiguration(classes = CacheRefinementsConfiguration.class)
+public class CacheRefinementsIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    private ExecutorService executorService = Executors.newFixedThreadPool(10);
+
+    @Autowired
+    private FooService service;
+
+    @Test
+    public void whenMultipleThreadsExecuteCacheableMethodWithSyncTrue_thenMethodIsExecutedOnlyOnce() throws InterruptedException {
+        for (int i = 0; i < 10; i++) {
+            executorService.execute(() -> service.getFoo("test").printInstanceNumber());
+        }
+        executorService.awaitTermination(1, TimeUnit.SECONDS);
+        assertEquals(1, Foo.getInstanceCount());
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/composedmapping/ComposedMappingConfiguration.java

@@ -0,0 +1,46 @@
+package org.baeldung.spring43.composedmapping;
+
+import java.util.Collections;
+
+import org.easymock.EasyMock;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.ViewResolver;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.view.InternalResourceViewResolver;
+import org.springframework.beans.factory.InjectionPoint;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.springframework.context.annotation.Scope;
+
+import static org.easymock.EasyMock.replay;
+
+@Configuration
+@ComponentScan
+@EnableWebMvc
+public class ComposedMappingConfiguration {
+
+    @Bean
+    public ViewResolver viewResolver() {
+        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
+        viewResolver.setPrefix("/WEB-INF/jsp/view/");
+        viewResolver.setSuffix(".jsp");
+        return viewResolver;
+    }
+
+    @Bean
+    public AppointmentService appointmentBook() {
+        AppointmentService book = EasyMock.mock(AppointmentService.class);
+        EasyMock.expect(book.getAppointmentsForToday()).andReturn(Collections.emptyMap());
+        replay(book);
+        return book;
+    }
+
+    @Bean
+    @Scope("prototype")
+    public Logger logger(InjectionPoint injectionPoint) {
+        return LogManager.getLogger(injectionPoint.getField().getDeclaringClass());
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/composedmapping/ComposedMappingIntegrationTest.java

@@ -0,0 +1,41 @@
+package org.baeldung.spring43.composedmapping;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+
+import static org.easymock.EasyMock.verify;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@ContextConfiguration(classes = ComposedMappingConfiguration.class)
+@WebAppConfiguration
+public class ComposedMappingIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    @Autowired
+    private AppointmentService appointmentService;
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    private WebApplicationContext wac;
+
+    @Before
+    public void setup() {
+        this.mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
+    }
+
+    @Test
+    public void whenRequestingMethodWithGetMapping_thenReceiving200Answer() throws Exception {
+        this.mockMvc.perform(get("/appointments").accept(MediaType.ALL)).andExpect(status().isOk());
+        verify(appointmentService);
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/ctor/ConfigurationConstructorInjectionIntegrationTest.java

@@ -0,0 +1,21 @@
+package org.baeldung.spring43.ctor;
+
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+
+import static org.junit.Assert.assertNotNull;
+
+@ContextConfiguration(classes = { FooRepositoryConfiguration.class, FooServiceConfiguration.class })
+public class ConfigurationConstructorInjectionIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    @Autowired
+    public FooService fooService;
+
+    @Test
+    public void whenSingleCtorInConfiguration_thenContextLoadsNormally() {
+        assertNotNull(fooService.getRepository());
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/ctor/FooRepositoryConfiguration.java

@@ -0,0 +1,14 @@
+package org.baeldung.spring43.ctor;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class FooRepositoryConfiguration {
+
+    @Bean
+    public FooRepository fooRepository() {
+        return new FooRepository();
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/ctor/FooServiceConfiguration.java

@@ -0,0 +1,19 @@
+package org.baeldung.spring43.ctor;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class FooServiceConfiguration {
+
+    private final FooRepository repository;
+
+    public FooServiceConfiguration(FooRepository repository) {
+        this.repository = repository;
+    }
+
+    @Bean
+    public FooService fooService() {
+        return new FooService(this.repository);
+    }
+}

spring-4/src/test/java/org/baeldung/spring43/ctor/ImplicitConstructorIntegrationTest.java

@@ -0,0 +1,21 @@
+package org.baeldung.spring43.ctor;
+
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+
+import static org.junit.Assert.assertNotNull;
+
+@ContextConfiguration("classpath:implicit-ctor-context.xml")
+public class ImplicitConstructorIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    @Autowired
+    private FooService fooService;
+
+    @Test
+    public void whenBeanWithoutAutowiredCtor_thenInjectIntoSingleCtor() {
+        assertNotNull(fooService.getRepository());
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/defaultmethods/DefaultMethodsInjectionIntegrationTest.java

@@ -0,0 +1,23 @@
+package org.baeldung.spring43.defaultmethods;
+
+import java.time.LocalDate;
+
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+
+import static org.junit.Assert.assertEquals;
+
+@ContextConfiguration("classpath:defaultmethods-context.xml")
+public class DefaultMethodsInjectionIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    @Autowired
+    private IDateHolder dateHolder;
+
+    @Test
+    public void whenInjectingToDefaultInterfaceMethod_thenInjectionShouldHappen() {
+        assertEquals(LocalDate.of(1982, 10, 15), dateHolder.getLocalDate());
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/defaultmethods/ITransactionalUnitTest.java

@@ -0,0 +1,22 @@
+package org.baeldung.spring43.defaultmethods;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.test.context.transaction.AfterTransaction;
+import org.springframework.test.context.transaction.BeforeTransaction;
+
+public interface ITransactionalUnitTest {
+
+    Logger log = LoggerFactory.getLogger(ITransactionalUnitTest.class);
+
+    @BeforeTransaction
+    default void beforeTransaction() {
+        log.info("Opening transaction");
+    }
+
+    @AfterTransaction
+    default void afterTransaction() {
+        log.info("Closing transaction");
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/defaultmethods/TransactionalIntegrationTest.java

@@ -0,0 +1,14 @@
+package org.baeldung.spring43.defaultmethods;
+
+import org.junit.Test;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
+
+@ContextConfiguration(classes = TransactionalTestConfiguration.class)
+public class TransactionalIntegrationTest extends AbstractTransactionalJUnit4SpringContextTests implements ITransactionalUnitTest {
+
+    @Test
+    public void whenDefaultMethodAnnotatedWithBeforeTransaction_thenDefaultMethodIsExecuted() {
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/defaultmethods/TransactionalTestConfiguration.java

@@ -0,0 +1,29 @@
+package org.baeldung.spring43.defaultmethods;
+
+import javax.sql.DataSource;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.jdbc.datasource.SimpleDriverDataSource;
+import org.springframework.transaction.PlatformTransactionManager;
+
+@Configuration
+public class TransactionalTestConfiguration {
+
+    @Bean
+    public DataSource getDataSource() {
+        SimpleDriverDataSource simpleDriverDataSource = new SimpleDriverDataSource();
+        simpleDriverDataSource.setDriverClass(org.hsqldb.jdbcDriver.class);
+        simpleDriverDataSource.setUrl("jdbc:hsqldb:mem:app-db");
+        simpleDriverDataSource.setUsername("sa");
+        simpleDriverDataSource.setPassword("");
+        return simpleDriverDataSource;
+    }
+
+    @Bean
+    public PlatformTransactionManager transactionManager() {
+        return new DataSourceTransactionManager(getDataSource());
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/depresolution/ObjectProviderConfiguration.java

@@ -0,0 +1,9 @@
+package org.baeldung.spring43.depresolution;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan
+public class ObjectProviderConfiguration {
+}

spring-4/src/test/java/org/baeldung/spring43/depresolution/ObjectProviderIntegrationTest.java

@@ -0,0 +1,23 @@
+package org.baeldung.spring43.depresolution;
+
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+
+import static org.junit.Assert.assertNotNull;
+
+@ContextConfiguration(classes = ObjectProviderConfiguration.class)
+public class ObjectProviderIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    @Autowired
+    private FooService fooService;
+
+    @Test
+    public void whenArgumentIsObjectProvider_thenObjectProviderInjected() {
+
+        assertNotNull(fooService.getRepository());
+
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/scopeannotations/ScopeAnnotationsConfiguration.java

@@ -0,0 +1,23 @@
+package org.baeldung.spring43.scopeannotations;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.ViewResolver;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.view.InternalResourceViewResolver;
+
+@Configuration
+@ComponentScan
+@EnableWebMvc
+public class ScopeAnnotationsConfiguration {
+
+    @Bean
+    public ViewResolver viewResolver() {
+        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
+        viewResolver.setPrefix("/WEB-INF/jsp/view/");
+        viewResolver.setSuffix(".jsp");
+        return viewResolver;
+    }
+
+}

spring-4/src/test/java/org/baeldung/spring43/scopeannotations/ScopeAnnotationsIntegrationTest.java

@@ -0,0 +1,74 @@
+package org.baeldung.spring43.scopeannotations;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.mock.web.MockHttpSession;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@ContextConfiguration(classes = ScopeAnnotationsConfiguration.class)
+@WebAppConfiguration
+public class ScopeAnnotationsIntegrationTest extends AbstractJUnit4SpringContextTests {
+
+    private MockMvc mockMvc;
+
+    @Autowired
+    private WebApplicationContext wac;
+
+    @Before
+    public void setup() {
+        this.mockMvc = MockMvcBuilders.webAppContextSetup(wac).build();
+    }
+
+    @Test
+    public void whenDifferentRequests_thenDifferentInstancesOfRequestScopedBeans() throws Exception {
+        MockHttpSession session = new MockHttpSession();
+
+        String requestScopedServiceInstanceNumber1 = this.mockMvc.perform(get("/appointments/request").session(session).accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+
+        String requestScopedServiceInstanceNumber2 = this.mockMvc.perform(get("/appointments/request").session(session).accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+
+        assertNotEquals(requestScopedServiceInstanceNumber1, requestScopedServiceInstanceNumber2);
+    }
+
+    @Test
+    public void whenDifferentSessions_thenDifferentInstancesOfSessionScopedBeans() throws Exception {
+
+        MockHttpSession session1 = new MockHttpSession();
+        MockHttpSession session2 = new MockHttpSession();
+
+        String sessionScopedServiceInstanceNumber1 = this.mockMvc.perform(get("/appointments/session").session(session1).accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+        String sessionScopedServiceInstanceNumber2 = this.mockMvc.perform(get("/appointments/session").session(session1).accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+        String sessionScopedServiceInstanceNumber3 = this.mockMvc.perform(get("/appointments/session").session(session2).accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+
+        assertEquals(sessionScopedServiceInstanceNumber1, sessionScopedServiceInstanceNumber2);
+
+        assertNotEquals(sessionScopedServiceInstanceNumber1, sessionScopedServiceInstanceNumber3);
+
+    }
+
+    @Test
+    public void whenDifferentSessionsAndRequests_thenAlwaysSingleApplicationScopedBean() throws Exception {
+
+        MockHttpSession session1 = new MockHttpSession();
+        MockHttpSession session2 = new MockHttpSession();
+
+        String applicationScopedServiceInstanceNumber1 = this.mockMvc.perform(get("/appointments/application").session(session1).accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+        String applicationScopedServiceInstanceNumber2 = this.mockMvc.perform(get("/appointments/application").session(session2).accept(MediaType.ALL)).andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+
+        assertEquals(applicationScopedServiceInstanceNumber1, applicationScopedServiceInstanceNumber2);
+
+    }
+
+}