[BAEL-3392] Formatted code examples for [BAEL-3392]

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/SpringRedisReactiveApplication.java

@@ -0,0 +1,13 @@
+package com.baeldung.spring.data.reactive.redis;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class SpringRedisReactiveApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringRedisReactiveApplication.class, args);
+    }
+
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/config/RedisConfig.java

@@ -0,0 +1,56 @@
+package com.baeldung.spring.data.reactive.redis.config;
+
+
+import com.baeldung.spring.data.reactive.redis.model.Employee;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.ReactiveKeyCommands;
+import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
+import org.springframework.data.redis.connection.ReactiveStringCommands;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.RedisSerializationContext;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+import javax.annotation.PreDestroy;
+
+@Configuration
+public class RedisConfig {
+
+    @Autowired
+    RedisConnectionFactory factory;
+
+    @Bean
+    public ReactiveRedisTemplate<String, Employee> reactiveRedisTemplate(ReactiveRedisConnectionFactory factory) {
+        Jackson2JsonRedisSerializer<Employee> serializer = new Jackson2JsonRedisSerializer<>(Employee.class);
+        RedisSerializationContext.RedisSerializationContextBuilder<String, Employee> builder = RedisSerializationContext.newSerializationContext(new StringRedisSerializer());
+        RedisSerializationContext<String, Employee> context = builder.value(serializer)
+            .build();
+        return new ReactiveRedisTemplate<>(factory, context);
+    }
+
+    @Bean
+    public ReactiveRedisTemplate<String, String> reactiveRedisTemplateString(ReactiveRedisConnectionFactory connectionFactory) {
+        return new ReactiveRedisTemplate<>(connectionFactory, RedisSerializationContext.string());
+    }
+
+    @Bean
+    public ReactiveKeyCommands keyCommands(final ReactiveRedisConnectionFactory reactiveRedisConnectionFactory) {
+        return reactiveRedisConnectionFactory.getReactiveConnection()
+            .keyCommands();
+    }
+
+    @Bean
+    public ReactiveStringCommands stringCommands(final ReactiveRedisConnectionFactory reactiveRedisConnectionFactory) {
+        return reactiveRedisConnectionFactory.getReactiveConnection()
+            .stringCommands();
+    }
+
+    @PreDestroy
+    public void cleanRedis() {
+        factory.getConnection()
+            .flushDb();
+    }
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/model/Employee.java

@@ -0,0 +1,21 @@
+package com.baeldung.spring.data.reactive.redis.model;
+
+import java.io.Serializable;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+@Data
+@ToString
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode
+public class Employee implements Serializable {
+    private static final long serialVersionUID = 1603714798906422731L;
+    private String id;
+    private String name;
+    private String department;
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/config/RedisConfig.java

@@ -0,0 +1,59 @@
+package com.baeldung.spring.data.redis.config;
+
+import com.baeldung.spring.data.redis.queue.MessagePublisher;
+import com.baeldung.spring.data.redis.queue.RedisMessagePublisher;
+import com.baeldung.spring.data.redis.queue.RedisMessageSubscriber;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.listener.ChannelTopic;
+import org.springframework.data.redis.listener.RedisMessageListenerContainer;
+import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
+import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
+import org.springframework.data.redis.serializer.GenericToStringSerializer;
+
+@Configuration
+@ComponentScan("com.baeldung.spring.data.redis")
+@EnableRedisRepositories(basePackages = "com.baeldung.spring.data.redis.repo")
+@PropertySource("classpath:application.properties")
+public class RedisConfig {
+
+    @Bean
+    JedisConnectionFactory jedisConnectionFactory() {
+        return new JedisConnectionFactory();
+    }
+
+    @Bean
+    public RedisTemplate<String, Object> redisTemplate() {
+        final RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
+        template.setConnectionFactory(jedisConnectionFactory());
+        template.setValueSerializer(new GenericToStringSerializer<Object>(Object.class));
+        return template;
+    }
+
+    @Bean
+    MessageListenerAdapter messageListener() {
+        return new MessageListenerAdapter(new RedisMessageSubscriber());
+    }
+
+    @Bean
+    RedisMessageListenerContainer redisContainer() {
+        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
+        container.setConnectionFactory(jedisConnectionFactory());
+        container.addMessageListener(messageListener(), topic());
+        return container;
+    }
+
+    @Bean
+    MessagePublisher redisPublisher() {
+        return new RedisMessagePublisher(redisTemplate(), topic());
+    }
+
+    @Bean
+    ChannelTopic topic() {
+        return new ChannelTopic("pubsub:queue");
+    }
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/model/Student.java

@@ -0,0 +1,62 @@
+package com.baeldung.spring.data.redis.model;
+
+import java.io.Serializable;
+
+import org.springframework.data.redis.core.RedisHash;
+
+@RedisHash("Student")
+public class Student implements Serializable {
+
+    public enum Gender {
+        MALE, FEMALE
+    }
+
+    private String id;
+    private String name;
+    private Gender gender;
+    private int grade;
+
+    public Student(String id, String name, Gender gender, int grade) {
+        this.id = id;
+        this.name = name;
+        this.gender = gender;
+        this.grade = grade;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Gender getGender() {
+        return gender;
+    }
+
+    public void setGender(Gender gender) {
+        this.gender = gender;
+    }
+
+    public int getGrade() {
+        return grade;
+    }
+
+    public void setGrade(int grade) {
+        this.grade = grade;
+    }
+
+    @Override
+    public String toString() {
+        return "Student{" + "id='" + id + '\'' + ", name='" + name + '\'' + ", gender=" + gender + ", grade=" + grade + '}';
+    }
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/MessagePublisher.java

@@ -0,0 +1,6 @@
+package com.baeldung.spring.data.redis.queue;
+
+public interface MessagePublisher {
+
+    void publish(final String message);
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/RedisMessagePublisher.java

@@ -0,0 +1,27 @@
+package com.baeldung.spring.data.redis.queue;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.listener.ChannelTopic;
+import org.springframework.stereotype.Service;
+
+@Service
+public class RedisMessagePublisher implements MessagePublisher {
+
+    @Autowired
+    private RedisTemplate<String, Object> redisTemplate;
+    @Autowired
+    private ChannelTopic topic;
+
+    public RedisMessagePublisher() {
+    }
+
+    public RedisMessagePublisher(final RedisTemplate<String, Object> redisTemplate, final ChannelTopic topic) {
+        this.redisTemplate = redisTemplate;
+        this.topic = topic;
+    }
+
+    public void publish(final String message) {
+        redisTemplate.convertAndSend(topic.getTopic(), message);
+    }
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/RedisMessageSubscriber.java

@@ -0,0 +1,19 @@
+package com.baeldung.spring.data.redis.queue;
+
+import org.springframework.data.redis.connection.Message;
+import org.springframework.data.redis.connection.MessageListener;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+public class RedisMessageSubscriber implements MessageListener {
+
+    public static List<String> messageList = new ArrayList<String>();
+
+    public void onMessage(final Message message, final byte[] pattern) {
+        messageList.add(message.toString());
+        System.out.println("Message received: " + new String(message.getBody()));
+    }
+}

persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/repo/StudentRepository.java

@@ -0,0 +1,9 @@
+package com.baeldung.spring.data.redis.repo;
+
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Repository;
+
+import com.baeldung.spring.data.redis.model.Student;
+
+@Repository
+public interface StudentRepository extends CrudRepository<Student, String> {}

persistence-modules/spring-data-redis/src/main/resources/application.properties

@@ -0,0 +1,2 @@
+spring.redis.host=localhost
+spring.redis.port=6379

persistence-modules/spring-data-redis/src/main/resources/logback.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>web - %date [%thread] %-5level %logger{36} - %message%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="WARN" />
+    <logger name="org.springframework.transaction" level="WARN" />
+
+    <!-- in order to debug some marshalling issues, this needs to be TRACE -->
+    <logger name="org.springframework.web.servlet.mvc" level="WARN" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisKeyCommandsIntegrationTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.spring.data.reactive.redis.template;
+
+
+import com.baeldung.spring.data.reactive.redis.SpringRedisReactiveApplication;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+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.data.redis.connection.ReactiveKeyCommands;
+import org.springframework.data.redis.connection.ReactiveStringCommands;
+import org.springframework.data.redis.connection.ReactiveStringCommands.SetCommand;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+import redis.embedded.RedisServerBuilder;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = SpringRedisReactiveApplication.class)
+@DirtiesContext(classMode = ClassMode.BEFORE_CLASS)
+public class RedisKeyCommandsIntegrationTest {
+    
+    private static redis.embedded.RedisServer redisServer;
+
+    @Autowired
+    private ReactiveKeyCommands keyCommands;
+
+    @Autowired
+    private ReactiveStringCommands stringCommands;
+    
+    @BeforeClass
+    public static void startRedisServer() throws IOException {
+        redisServer = new RedisServerBuilder().port(6379).setting("maxheap 256M").build();
+        redisServer.start();
+    }
+    
+    @AfterClass
+    public static void stopRedisServer() throws IOException {
+        redisServer.stop();
+    }
+
+    @Test
+    public void givenFluxOfKeys_whenPerformOperations_thenPerformOperations() {
+        Flux<String> keys = Flux.just("key1", "key2", "key3", "key4");
+
+        Flux<SetCommand> generator = keys.map(String::getBytes)
+            .map(ByteBuffer::wrap)
+            .map(key -> SetCommand.set(key)
+                .value(key));
+
+        StepVerifier.create(stringCommands.set(generator))
+            .expectNextCount(4L)
+            .verifyComplete();
+
+        Mono<Long> keyCount = keyCommands.keys(ByteBuffer.wrap("key*".getBytes()))
+            .flatMapMany(Flux::fromIterable)
+            .count();
+
+        StepVerifier.create(keyCount)
+            .expectNext(4L)
+            .verifyComplete();
+
+    }
+}

persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateListOpsIntegrationTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.spring.data.reactive.redis.template;
+
+
+import com.baeldung.spring.data.reactive.redis.SpringRedisReactiveApplication;
+
+import java.io.IOException;
+
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+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.data.redis.core.ReactiveListOperations;
+import org.springframework.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.junit4.SpringRunner;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+import redis.embedded.RedisServerBuilder;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = SpringRedisReactiveApplication.class)
+@DirtiesContext(classMode = ClassMode.BEFORE_CLASS)
+public class RedisTemplateListOpsIntegrationTest {
+
+    private static final String LIST_NAME = "demo_list";
+    private static redis.embedded.RedisServer redisServer;
+
+    @Autowired
+    private ReactiveRedisTemplate<String, String> redisTemplate;
+
+    private ReactiveListOperations<String, String> reactiveListOps;
+    
+    @BeforeClass
+    public static void startRedisServer() throws IOException {
+        redisServer = new RedisServerBuilder().port(6379).setting("maxheap 128M").build();
+        redisServer.start();
+    }
+    
+    @AfterClass
+    public static void stopRedisServer() throws IOException {
+        redisServer.stop();
+    }
+
+    @Before
+    public void setup() {
+        reactiveListOps = redisTemplate.opsForList();
+    }
+
+    @Test
+    public void givenListAndValues_whenLeftPushAndLeftPop_thenLeftPushAndLeftPop() {
+        Mono<Long> lPush = reactiveListOps.leftPushAll(LIST_NAME, "first", "second")
+            .log("Pushed");
+
+        StepVerifier.create(lPush)
+            .expectNext(2L)
+            .verifyComplete();
+
+        Mono<String> lPop = reactiveListOps.leftPop(LIST_NAME)
+            .log("Popped");
+
+        StepVerifier.create(lPop)
+            .expectNext("second")
+            .verifyComplete();
+    }
+
+}

persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateValueOpsIntegrationTest.java

@@ -0,0 +1,93 @@
+package com.baeldung.spring.data.reactive.redis.template;
+
+
+import java.io.IOException;
+import java.time.Duration;
+
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+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.data.redis.core.ReactiveRedisTemplate;
+import org.springframework.data.redis.core.ReactiveValueOperations;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import com.baeldung.spring.data.reactive.redis.SpringRedisReactiveApplication;
+import com.baeldung.spring.data.reactive.redis.model.Employee;
+
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+import redis.embedded.RedisServerBuilder;
+
+@RunWith(SpringRunner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = SpringRedisReactiveApplication.class)
+@DirtiesContext(classMode = ClassMode.BEFORE_CLASS)
+public class RedisTemplateValueOpsIntegrationTest {
+    
+    private static redis.embedded.RedisServer redisServer;
+
+    @Autowired
+    private ReactiveRedisTemplate<String, Employee> redisTemplate;
+
+    private ReactiveValueOperations<String, Employee> reactiveValueOps;
+    
+    @BeforeClass
+    public static void startRedisServer() throws IOException {
+        redisServer = new RedisServerBuilder().port(6379).setting("maxheap 256M").build();
+        redisServer.start();
+    }
+    
+    @AfterClass
+    public static void stopRedisServer() throws IOException {
+        redisServer.stop();
+    }
+
+    @Before
+    public void setup() {
+        reactiveValueOps = redisTemplate.opsForValue();
+    }
+
+    @Test
+    public void givenEmployee_whenSet_thenSet() {
+
+        Mono<Boolean> result = reactiveValueOps.set("123", new Employee("123", "Bill", "Accounts"));
+
+        StepVerifier.create(result)
+            .expectNext(true)
+            .verifyComplete();
+    }
+
+    @Test
+    public void givenEmployeeId_whenGet_thenReturnsEmployee() {
+
+        Mono<Employee> fetchedEmployee = reactiveValueOps.get("123");
+
+        StepVerifier.create(fetchedEmployee)
+            .expectNext(new Employee("123", "Bill", "Accounts"))
+            .verifyComplete();
+    }
+
+    @Test
+    public void givenEmployee_whenSetWithExpiry_thenSetsWithExpiryTime() throws InterruptedException {
+
+        Mono<Boolean> result = reactiveValueOps.set("129", new Employee("129", "John", "Programming"), Duration.ofSeconds(1));
+
+        Mono<Employee> fetchedEmployee = reactiveValueOps.get("129");
+
+        StepVerifier.create(result)
+            .expectNext(true)
+            .verifyComplete();
+
+        Thread.sleep(2000L);
+
+        StepVerifier.create(fetchedEmployee)
+            .expectNextCount(0L)
+            .verifyComplete();
+    }
+
+}

persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/redis/RedisMessageListenerIntegrationTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.spring.data.redis;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.UUID;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.spring.data.redis.config.RedisConfig;
+import com.baeldung.spring.data.redis.queue.RedisMessagePublisher;
+import com.baeldung.spring.data.redis.queue.RedisMessageSubscriber;
+
+import redis.embedded.RedisServerBuilder;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = RedisConfig.class)
+@DirtiesContext(classMode = ClassMode.BEFORE_CLASS)
+public class RedisMessageListenerIntegrationTest {
+
+    private static redis.embedded.RedisServer redisServer;
+    
+    @Autowired
+    private RedisMessagePublisher redisMessagePublisher;
+    
+    @BeforeClass
+    public static void startRedisServer() throws IOException {
+        redisServer = new RedisServerBuilder().port(6379).setting("maxheap 256M").build();
+        redisServer.start();
+    }
+    
+    @AfterClass
+    public static void stopRedisServer() throws IOException {
+        redisServer.stop();
+    }
+
+    @Test
+    public void testOnMessage() throws Exception {
+        String message = "Message " + UUID.randomUUID();
+        redisMessagePublisher.publish(message);
+        Thread.sleep(100);
+        assertTrue(RedisMessageSubscriber.messageList.get(0).contains(message));
+    }
+}

persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/redis/repo/StudentRepositoryIntegrationTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.spring.data.redis.repo;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.baeldung.spring.data.redis.config.RedisConfig;
+import com.baeldung.spring.data.redis.model.Student;
+
+import redis.embedded.RedisServerBuilder;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = RedisConfig.class)
+@DirtiesContext(classMode = ClassMode.BEFORE_CLASS)
+public class StudentRepositoryIntegrationTest {
+
+    @Autowired
+    private StudentRepository studentRepository;
+    
+    private static redis.embedded.RedisServer redisServer;
+    
+    @BeforeClass
+    public static void startRedisServer() throws IOException {
+        redisServer = new RedisServerBuilder().port(6379).setting("maxheap 128M").build();
+        redisServer.start();
+    }
+    
+    @AfterClass
+    public static void stopRedisServer() throws IOException {
+        redisServer.stop();
+    }
+
+    @Test
+    public void whenSavingStudent_thenAvailableOnRetrieval() throws Exception {
+        final Student student = new Student("Eng2015001", "John Doe", Student.Gender.MALE, 1);
+        studentRepository.save(student);
+        final Student retrievedStudent = studentRepository.findById(student.getId()).get();
+        assertEquals(student.getId(), retrievedStudent.getId());
+    }
+
+    @Test
+    public void whenUpdatingStudent_thenAvailableOnRetrieval() throws Exception {
+        final Student student = new Student("Eng2015001", "John Doe", Student.Gender.MALE, 1);
+        studentRepository.save(student);
+        student.setName("Richard Watson");
+        studentRepository.save(student);
+        final Student retrievedStudent = studentRepository.findById(student.getId()).get();
+        assertEquals(student.getName(), retrievedStudent.getName());
+    }
+
+    @Test
+    public void whenSavingStudents_thenAllShouldAvailableOnRetrieval() throws Exception {
+        final Student engStudent = new Student("Eng2015001", "John Doe", Student.Gender.MALE, 1);
+        final Student medStudent = new Student("Med2015001", "Gareth Houston", Student.Gender.MALE, 2);
+        studentRepository.save(engStudent);
+        studentRepository.save(medStudent);
+        List<Student> students = new ArrayList<>();
+        studentRepository.findAll().forEach(students::add);
+        assertEquals(students.size(), 2);
+    }
+
+    @Test
+    public void whenDeletingStudent_thenNotAvailableOnRetrieval() throws Exception {
+        final Student student = new Student("Eng2015001", "John Doe", Student.Gender.MALE, 1);
+        studentRepository.save(student);
+        studentRepository.deleteById(student.getId());
+        final Student retrievedStudent = studentRepository.findById(student.getId()).orElse(null);
+        assertNull(retrievedStudent);
+    }
+}

persistence-modules/spring-data-redis/src/test/java/org/baeldung/SpringContextIntegrationTest.java

@@ -0,0 +1,17 @@
+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 com.baeldung.spring.data.redis.config.RedisConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = RedisConfig.class)
+public class SpringContextIntegrationTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}

persistence-modules/spring-data-redis/src/test/java/org/baeldung/SpringContextTest.java

@@ -0,0 +1,17 @@
+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 com.baeldung.spring.data.redis.config.RedisConfig;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = RedisConfig.class)
+public class SpringContextTest {
+
+    @Test
+    public void whenSpringContextIsBootstrapped_thenNoExceptions() {
+    }
+}