Suggestion implemented

junit-team · Jan 19, 2016 · 73347b3 · 73347b3
1 parent 69d6e1d
commit 73347b3
Show file tree

Hide file tree

Showing 8 changed files with 208 additions and 263 deletions.
diff --git a/junit-tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionContextTests.java b/junit-tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionContextTests.java
@@ -122,45 +122,25 @@ public void reportEntriesArePublishedToExecutionContext() {
 	}
 
 	@Test
-	public void storingAttributesWithDefaultNamespace() {
+	public void usingStore() {
 		MethodTestDescriptor methodTestDescriptor = methodDescriptor();
 		ClassTestDescriptor classTestDescriptor = outerClassDescriptor(methodTestDescriptor);
 		ExtensionContext parentContext = new ClassBasedContainerExtensionContext(null, null, classTestDescriptor);
 		MethodBasedTestExtensionContext childContext = new MethodBasedTestExtensionContext(parentContext, null,
 			methodTestDescriptor, new OuterClass());
 
-		childContext.put("a key", "a value");
+		ExtensionContext.Store store = childContext.getStore();
-		assertEquals("a value", childContext.get("a key"));
 
-		assertEquals("other value", childContext.getOrComputeIfAbsent("other key", key -> "other value"));
+		store.put("a key", "a value");
+		assertEquals("a value", store.get("a key"));
 
-		childContext.remove("a key");
+		assertEquals("other value", store.getOrComputeIfAbsent("other key", key -> "other value"));
-		assertNull(childContext.get("a key"));
 
-		parentContext.put("parent key", "parent value");
+		assertEquals("a value", store.remove("a key"));
-		assertEquals("parent value", childContext.get("parent key"));
+		assertNull(store.get("a key"));
-	}
-
-	@Test
-	public void storingAttributesWithNamespace() {
-		MethodTestDescriptor methodTestDescriptor = methodDescriptor();
-		ClassTestDescriptor classTestDescriptor = outerClassDescriptor(methodTestDescriptor);
-		ExtensionContext parentContext = new ClassBasedContainerExtensionContext(null, null, classTestDescriptor);
-		MethodBasedTestExtensionContext childContext = new MethodBasedTestExtensionContext(parentContext, null,
-			methodTestDescriptor, new OuterClass());
-
-		String namespace = "a namespace";
-
-		childContext.put("a key", "a value", namespace);
-		assertEquals("a value", childContext.get("a key", namespace));
-
-		assertEquals("other value", childContext.getOrComputeIfAbsent("other key", key -> "other value"), namespace);
-
-		childContext.remove("a key", namespace);
-		assertNull(childContext.get("a key", namespace));
 
-		parentContext.put("parent key", "parent value", namespace);
+		store.put("parent key", "parent value");
-		assertEquals("parent value", childContext.get("parent key", namespace));
+		assertEquals("parent value", store.get("parent key"));
 	}
 
 	private ClassTestDescriptor nestedClassDescriptor() {

diff --git a/...tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStoreTest.java b/...tests/src/test/java/org/junit/gen5/engine/junit5/descriptor/ExtensionValuesStoreTest.java
@@ -15,7 +15,7 @@
 import org.junit.gen5.api.BeforeEach;
 import org.junit.gen5.api.Nested;
 import org.junit.gen5.api.Test;
-import org.junit.gen5.engine.junit5.descriptor.ExtensionValuesStore.Namespace;
+import org.junit.gen5.api.extension.ExtensionContext.*;
 
 /**
  * Microtests for {@link ExtensionValuesStore}
@@ -29,131 +29,134 @@ class ExtensionValuesStoreTests {
 
 	private Object value = createObject("value");
 
+	private Namespace namespace = Namespace.of("ns");
+
 	@BeforeEach
 	void initializeStore() {
 		parentStore = new ExtensionValuesStore();
 		store = new ExtensionValuesStore(parentStore);
 	}
 
 	@Nested
-	class UsingDefaultNamespaceTests {
+	class StoringValuesTests {
 
 		@Test
 		void getWithUnknownKeyReturnsNull() {
-			assertNull(store.get("unknown key"));
+			assertNull(store.get("unknown key", namespace));
 		}
 
 		@Test
 		void putAndGetWithSameKey() {
 
-			store.put(key, value);
+			store.put(key, value, namespace);
-			assertEquals(value, store.get(key));
+			assertEquals(value, store.get(key, namespace));
 		}
 
 		@Test
 		void valueCanBeReplaced() {
-			store.put(key, value);
+			store.put(key, value, namespace);
 
 			Object newValue = new Object();
-			store.put(key, newValue);
+			store.put(key, newValue, namespace);
 
-			assertEquals(newValue, store.get(key));
+			assertEquals(newValue, store.get(key, namespace));
 		}
 
 		@Test
 		void valueIsComputedIfAbsent() {
-			assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> value));
+			assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> value, namespace));
-			assertEquals(value, store.get(key));
+			assertEquals(value, store.get(key, namespace));
 		}
 
 		@Test
 		void valueIsNotComputedIfPresent() {
-			store.put(key, value);
+			store.put(key, value, namespace);
 
-			assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> "a different value"));
+			assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> "a different value", namespace));
-			assertEquals(value, store.get(key));
+			assertEquals(value, store.get(key, namespace));
 		}
 
 		@Test
 		void nullIsAValidValueToPut() {
-			store.put(key, null);
+			store.put(key, null, namespace);
 
-			assertEquals(null, store.getOrComputeIfAbsent(key, innerKey -> "a different value"));
+			assertEquals(null, store.getOrComputeIfAbsent(key, innerKey -> "a different value", namespace));
-			assertEquals(null, store.get(key));
+			assertEquals(null, store.get(key, namespace));
 		}
 
 		@Test
 		void keysCanBeRemoved() {
-			store.put(key, value);
+			store.put(key, value, namespace);
-			store.remove(key);
+			assertEquals(value, store.remove(key, namespace));
 
-			assertNull(store.get(key));
+			assertNull(store.get(key, namespace));
-			assertEquals("a different value", store.getOrComputeIfAbsent(key, innerKey -> "a different value"));
+			assertEquals("a different value",
+				store.getOrComputeIfAbsent(key, innerKey -> "a different value", namespace));
 		}
 
-	}
+		@Test
+		void sameKeyWithDifferentNamespaces() {
+			Object value1 = createObject("value1");
+			Namespace namespace1 = Namespace.of("ns1");
 
-	@Nested
+			Object value2 = createObject("value2");
-	class InheritedValuesTests {
+			Namespace namespace2 = Namespace.of("ns2");
 
-		@Test
+			store.put(key, value1, namespace1);
-		void valueFromParentIsVisible() {
+			store.put(key, value2, namespace2);
-			parentStore.put(key, value);
+
-			assertEquals(value, store.get(key));
+			assertEquals(value1, store.get(key, namespace1));
+			assertEquals(value2, store.get(key, namespace2));
 		}
 
 		@Test
-		void valueFromParentCanBeOverriddenInChild() {
+		void valueIsComputedIfAbsentInDifferentNamespace() {
-			parentStore.put(key, value);
+			Namespace namespace1 = Namespace.of("ns1");
+			Namespace namespace2 = Namespace.of("ns2");
 
-			Object otherValue = new Object();
+			assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> value, namespace1));
-			store.put(key, otherValue);
+			assertEquals(value, store.get(key, namespace1));
-			assertEquals(otherValue, store.get(key));
 
-			assertEquals(value, parentStore.get(key));
+			assertNull(store.get(key, namespace2));
 		}
-	}
-
-	@Nested
-	class UsingExplicitNamespaceTests {
 
 		@Test
-		void sameKeyWithDifferentNamespaces() {
+		void keyIsOnlyRemovedInGivenNamespace() {
-			Object value1 = createObject("value1");
+			Namespace namespace1 = Namespace.of("ns1");
-			Namespace namespace1 = Namespace.sharedWith("ns1");
+			Namespace namespace2 = Namespace.of("ns2");
 
+			Object value1 = createObject("value1");
 			Object value2 = createObject("value2");
-			Namespace namespace2 = Namespace.sharedWith("ns2");
 
 			store.put(key, value1, namespace1);
 			store.put(key, value2, namespace2);
+			store.remove(key, namespace1);
 
-			assertEquals(value1, store.get(key, namespace1));
+			assertNull(store.get(key, namespace1));
 			assertEquals(value2, store.get(key, namespace2));
 		}
 
+	}
+
+	@Nested
+	class InheritedValuesTests {
+
 		@Test
-		void valueIsComputedIfAbsentInDifferentNamespace() {
+		void valueFromParentIsVisible() {
-			Namespace namespace = Namespace.sharedWith("ns");
+			parentStore.put(key, value, namespace);
-			assertEquals(value, store.getOrComputeIfAbsent(key, innerKey -> value, namespace));
 			assertEquals(value, store.get(key, namespace));
-
-			assertNull(store.get(key));
 		}
 
 		@Test
-		void keyIsOnlyRemovedInGivenNamespace() {
+		void valueFromParentCanBeOverriddenInChild() {
-			Namespace namespace = Namespace.sharedWith("ns");
+			parentStore.put(key, value, namespace);
-			Object valueInNamespace = createObject("valueInNamespace");
 
-			store.put(key, value);
+			Object otherValue = new Object();
-			store.put(key, valueInNamespace, namespace);
+			store.put(key, otherValue, namespace);
-			store.remove(key, namespace);
+			assertEquals(otherValue, store.get(key, namespace));
 
-			assertNull(store.get(key, namespace));
+			assertEquals(value, parentStore.get(key, namespace));
-			assertEquals(value, store.get(key));
 		}
-
 	}
 
 	private Object createObject(final String display) {