Polish for spring-projects#2696.

Closes spring-projects#2701
Original pull request: spring-projects#2696

src/main/java/org/springframework/data/redis/core/ConvertingCursor.java

@@ -40,8 +40,9 @@ public class ConvertingCursor<S, T> implements Cursor<T> {
  */
  public ConvertingCursor(Cursor<S> cursor, Converter<S, T> converter) {
 
- Assert.notNull(cursor, "Cursor delegate must not be 'null'");
- Assert.notNull(converter, "Converter must not be 'null'");
+ Assert.notNull(cursor, "Cursor must not be null");
+ Assert.notNull(converter, "Converter must not be null");
+
  this.delegate = cursor;
  this.converter = converter;
  }

src/test/java/org/springframework/data/redis/core/ConvertingCursorUnitTests.java

@@ -0,0 +1,196 @@
+/*
+ * Copyright 2017-2023 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.data.redis.core;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.core.convert.converter.Converter;
+
+/**
+ * Unit Tests for {@link ConvertingCursor}.
+ *
+ * @author John Blum
+ */
+@SuppressWarnings("unchecked")
+class ConvertingCursorUnitTests {
+
+ @Test // #2701
+ void constructConvertingCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ new ConvertingCursor<>(mockCursor, mockConverter);
+
+ verifyNoInteractions(mockConverter, mockCursor);
+ }
+
+ @Test // #2701
+ @SuppressWarnings("all")
+ void constructConvertingCursorWithNullConverter() {
+
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ assertThatIllegalArgumentException()
+ .isThrownBy(() -> new ConvertingCursor<>(mockCursor, null))
+ .withMessage("Converter must not be null")
+ .withNoCause();
+
+ verifyNoInteractions(mockCursor);
+ }
+
+ @Test // #2701
+ @SuppressWarnings("all")
+ void constructConvertingCursorWithNullCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+
+ assertThatIllegalArgumentException()
+ .isThrownBy(() -> new ConvertingCursor<>(null, mockConverter))
+ .withMessage("Cursor must not be null")
+ .withNoCause();
+
+ verifyNoInteractions(mockConverter);
+ }
+
+ @Test
+ void hasNextDelegatesToCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ doReturn(true).when(mockCursor).hasNext();
+
+ ConvertingCursor<?, ?> convertingCursor = new ConvertingCursor<>(mockCursor, mockConverter);
+
+ assertThat(convertingCursor.hasNext()).isTrue();
+
+ verify(mockCursor, times(1)).hasNext();
+ verifyNoMoreInteractions(mockCursor);
+ verifyNoInteractions(mockConverter);
+ }
+
+ @Test
+ void nextDelegatesToCursorAndIsConverted() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ doReturn("test").when(mockCursor).next();
+ doAnswer(invocation -> invocation.getArgument(0).toString().toUpperCase()).when(mockConverter).convert(any());
+
+ ConvertingCursor<?, ?> convertingCursor = new ConvertingCursor<>(mockCursor, mockConverter);
+
+ assertThat(convertingCursor.next()).isEqualTo("TEST");
+
+ verify(mockCursor, times(1)).next();
+ verify(mockConverter, times(1)).convert(eq("test"));
+ verifyNoMoreInteractions(mockCursor, mockConverter);
+ }
+
+ @Test
+ void removeDelegatesToCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ ConvertingCursor<?, ?> convertingCursor = new ConvertingCursor<>(mockCursor, mockConverter);
+
+ convertingCursor.remove();
+
+ verify(mockCursor, times(1)).remove();
+ verifyNoMoreInteractions(mockCursor);
+ verifyNoInteractions(mockConverter);
+ }
+
+ @Test
+ void closeDelegatesToCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ ConvertingCursor<?, ?> convertingCursor = new ConvertingCursor<>(mockCursor, mockConverter);
+
+ convertingCursor.close();
+
+ verify(mockCursor, times(1)).close();
+ verifyNoMoreInteractions(mockCursor);
+ verifyNoInteractions(mockConverter);
+ }
+
+ @Test
+ void getCursorIdDelegatesToCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ doReturn(1L).when(mockCursor).getCursorId();
+
+ ConvertingCursor<?, ?> convertingCursor = new ConvertingCursor<>(mockCursor, mockConverter);
+
+ assertThat(convertingCursor.getCursorId()).isOne();
+
+ verify(mockCursor, times(1)).getCursorId();
+ verifyNoMoreInteractions(mockCursor);
+ verifyNoInteractions(mockConverter);
+ }
+
+ @Test
+ void isClosedDelegatesToCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ doReturn(false).when(mockCursor).isClosed();
+
+ ConvertingCursor<?, ?> convertingCursor = new ConvertingCursor<>(mockCursor, mockConverter);
+
+ assertThat(convertingCursor.isClosed()).isFalse();
+
+ verify(mockCursor, times(1)).isClosed();
+ verifyNoMoreInteractions(mockCursor);
+ verifyNoInteractions(mockConverter);
+ }
+
+ @Test
+ void getPositionDelegatesToCursor() {
+
+ Converter<Object, Object> mockConverter = mock(Converter.class);
+ Cursor<Object> mockCursor = mock(Cursor.class);
+
+ doReturn(12L).when(mockCursor).getPosition();
+
+ ConvertingCursor<?, ?> convertingCursor = new ConvertingCursor<>(mockCursor, mockConverter);
+
+ assertThat(convertingCursor.getPosition()).isEqualTo(12L);
+
+ verify(mockCursor, times(1)).getPosition();
+ verifyNoMoreInteractions(mockCursor);
+ verifyNoInteractions(mockConverter);
+ }
+}