DATAKV-99 - Add KeyValueIterator.

We now offer the possibility to iterate through available key/value pairs via a KeyValueIterator. The default implementation for java.util.Map based Adapters is a ForwardingKeyValueIterator delegating to the underlying entrySet iterator.

Original pull request: #7.

src/test/java/org/springframework/data/keyvalue/core/ForwardingIteratorUnitTests.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.keyvalue.core;
+
+import static org.hamcrest.core.Is.*;
+import static org.hamcrest.core.IsNull.*;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+/**
+ * @author Christoph Strobl
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class ForwardingIteratorUnitTests<K, V> {
+
+	@Mock Iterator<Map.Entry<K, V>> iteratorMock;
+
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test
+	public void hasNextShoudDelegateToWrappedIterator() {
+
+		when(iteratorMock.hasNext()).thenReturn(true);
+
+		assertThat(new ForwardingKeyValueIterator<K, V>(iteratorMock).hasNext(), is(true));
+
+		verify(iteratorMock, times(1)).hasNext();
+	}
+
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test
+	public void nextShoudDelegateToWrappedIterator() {
+
+		when(iteratorMock.next()).thenReturn((Map.Entry<K, V>) mock(Map.Entry.class));
+
+		assertThat(new ForwardingKeyValueIterator<K, V>(iteratorMock).next(), notNullValue());
+
+		verify(iteratorMock, times(1)).next();
+	}
+
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test(expected = NoSuchElementException.class)
+	public void nextShoudThrowErrorWhenWrappedIteratorHasNoMoreElements() {
+
+		when(iteratorMock.next()).thenThrow(new NoSuchElementException());
+
+		new ForwardingKeyValueIterator<K, V>(iteratorMock).next();
+	}
+
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test
+	public void closeShouldDoNothing() throws IOException {
+
+		new ForwardingKeyValueIterator<K, V>(iteratorMock).close();
+
+		verifyZeroInteractions(iteratorMock);
+	}
+
+}

src/test/java/org/springframework/data/keyvalue/test/util/IsEntry.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.keyvalue.test.util;
+
+import org.hamcrest.CustomMatcher;
+import org.hamcrest.core.IsEqual;
+import org.springframework.data.keyvalue.core.Entry;
+
+/**
+ * @author Christoph Strobl
+ */
+public class IsEntry extends CustomMatcher<Entry<?, ?>> {
+
+	private final Entry<?, ?> expected;
+
+	private IsEntry(Entry<?, ?> entry) {
+		super(String.format("an entry %s=%s.", entry != null ? entry.getKey() : "null", entry != null ? entry.getValue()
+				: "null"));
+		this.expected = entry;
+	}
+
+	@Override
+	public boolean matches(Object item) {
+
+		if (item == null && expected == null) {
+			return true;
+		}
+
+		if (!(item instanceof Entry)) {
+			return false;
+		}
+
+		Entry<?, ?> actual = (Entry<?, ?>) item;
+
+		return new IsEqual<Object>(expected.getKey()).matches(actual.getKey())
+				&& new IsEqual<Object>(expected.getValue()).matches(actual.getValue());
+	}
+
+	public static IsEntry isEntry(Object key, Object value) {
+		return isEntry(new EntryImpl(key, value));
+	}
+
+	public static IsEntry isEntry(Entry<?, ?> entry) {
+		return new IsEntry(entry);
+	}
+
+	private static class EntryImpl implements Entry<Object, Object> {
+
+		private final Object key;
+		private final Object value;
+
+		private EntryImpl(Object key, Object value) {
+			this.key = key;
+			this.value = value;
+		}
+
+		@Override
+		public Object getKey() {
+			return key;
+		}
+
+		@Override
+		public Object getValue() {
+			return value;
+		}
+
+		@Override
+		public Object setValue(Object value) {
+			throw new UnsupportedOperationException();
+		}
+	}
+}

src/test/java/org/springframework/data/map/MapKeyValueAdapterUnitTests.java

@@ -20,10 +20,13 @@ import static org.hamcrest.core.Is.*;
 import static org.hamcrest.core.IsEqual.*;
 import static org.hamcrest.core.IsNull.*;
 import static org.junit.Assert.*;
+import static org.springframework.data.keyvalue.test.util.IsEntry.*;
+
+import java.io.Serializable;
 
 import org.junit.Before;
 import org.junit.Test;
-import org.springframework.data.map.MapKeyValueAdapter;
+import org.springframework.data.keyvalue.core.KeyValueIterator;
 import org.springframework.util.ObjectUtils;
 
 /**
@@ -186,6 +189,45 @@ public class MapKeyValueAdapterUnitTests {
 		assertThat(adapter.delete("1", COLLECTION_1), is(object1));
 	}
 
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test
+	public void scanShouldIterateOverAvailableEntries() {
+
+		adapter.put("1", object1, COLLECTION_1);
+		adapter.put("2", object2, COLLECTION_1);
+
+		KeyValueIterator<Serializable, ?> iterator = adapter.entries(COLLECTION_1);
+
+		assertThat(iterator.next(), isEntry("1", object1));
+		assertThat(iterator.next(), isEntry("2", object2));
+		assertThat(iterator.hasNext(), is(false));
+	}
+
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test
+	public void scanShouldReturnEmptyIteratorWhenNoElementsAvailable() {
+		assertThat(adapter.entries(COLLECTION_1).hasNext(), is(false));
+	}
+
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test
+	public void scanDoesNotMixResultsFromMultipleKeyspaces() {
+
+		adapter.put("1", object1, COLLECTION_1);
+		adapter.put("2", object2, COLLECTION_2);
+
+		KeyValueIterator<Serializable, ?> iterator = adapter.entries(COLLECTION_1);
+
+		assertThat(iterator.next(), isEntry("1", object1));
+		assertThat(iterator.hasNext(), is(false));
+	}
+
 	static class SimpleObject {
 
 		protected String stringValue;