Issue #152: Made simple-cipher more approachable (#224)

* Issue #152: Made simple-cipher more approachable by splitting test classes in a more sensible way and making clear which steps they relate to.

* Changed SimpleCipherTest to use the junit Rule annotation for expected exceptions. Changed variable names in SimpleCipherTest to be more descriptive and moved the test cipherThrowsWithEmptyKey from step three to step two.

* Added HINT.md which explains how to run only one test class.

* Changed HINT.md in simple-cipher to refer to the actual test file names and not to contain the same information as in SETUP.md

exercises/simple-cipher/HINT.md

@@ -0,0 +1,6 @@
+This exercise has three test classes: SimpleCipherStepOneTest.java, SimpleCipherStepTwoTest.java and SimpleCipherStepThreeTest.java.
+
+To run only one test class (e.g. in this example SimpleCipherStepOneTest.java):
+```
+$ gradle test --tests *StepOne*
+```

exercises/simple-cipher/src/test/java/IncorrectKeyCipherTest.java

@@ -1,35 +0,0 @@
-import org.junit.Test;
-import org.junit.Ignore;
-
-public class IncorrectKeyCipherTest {
-
-
-    @Test(expected = IllegalArgumentException.class)
-    public void cipherThrowsWithAllCapsKey() {
-        new Cipher("ABCDEF");
-    }
-
-    @Ignore
-    @Test(expected = IllegalArgumentException.class)
-    public void cipherThrowsWithAnyCapsKey() {
-        new Cipher("abcdEFg");
-    }
-
-    @Ignore
-    @Test(expected = IllegalArgumentException.class)
-    public void cipherThrowsWithNumericKey() {
-        new Cipher("12345");
-    }
-
-    @Ignore
-    @Test(expected = IllegalArgumentException.class)
-    public void cipherThrowsWithAnyNumericKey() {
-        new Cipher("abcd345ef");
-    }
-
-    @Ignore
-    @Test(expected = IllegalArgumentException.class)
-    public void cipherThrowsWithEmptyKey() {
-        new Cipher("");
-    }
-}

exercises/simple-cipher/src/test/java/RandomKeyCipherTest.java

@@ -1,62 +0,0 @@
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.Ignore;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-public class RandomKeyCipherTest {
-
-    private Cipher cipher;
-
-    @Before
-    public void setup() {
-        this.cipher = new Cipher();
-    }
-
-
-    @Test
-    public void cipherKeyIsMadeOfLetters() {
-        assertTrue(cipher.getKey().matches("[a-z]+"));
-    }
-
-    @Ignore
-    @Test
-    public void defaultCipherKeyIs100Characters() {
-        assertEquals(100, cipher.getKey().length());
-    }
-
-    @Ignore
-    @Test
-    public void cipherKeysAreRandomlyGenerated() {
-        assertTrue(!(new Cipher().getKey().equals(cipher.getKey())));
-    }
-
-    /**
-     * Here we take advantage of the fact that plaintext of "aaa..." doesn't output the key. This is a critical problem
-     * with shift ciphers, some characters will always output the key verbatim.
-     */
-    @Ignore
-    @Test
-    public void cipherCanEncode() {
-        String expectedOutput = cipher.getKey().substring(0, 10);
-
-        assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDecode() {
-        String expectedOutput = "aaaaaaaaaa";
-
-        assertEquals(expectedOutput, cipher.decode(cipher.getKey().substring(0, 10)));
-    }
-
-    @Ignore
-    @Test
-    public void cipherIsReversible() {
-        String plainText = "abcdefghij";
-
-        assertEquals(plainText, cipher.decode(cipher.encode(plainText)));
-    }
-}

exercises/simple-cipher/src/test/java/SimpleCipherStepOneTest.java

@@ -0,0 +1,41 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Step 1: Make a simple shift cipher
+ */
+public class SimpleCipherStepOneTest {
+    private Cipher cipherWithDefaultKey;
+
+    @Before
+    public void setup() {
+        cipherWithDefaultKey = new Cipher();
+    }
+
+    /**
+     * Here we take advantage of the fact that plaintext of "aaa..." doesn't output the key. This is a critical problem
+     * with shift ciphers, some characters will always output the key verbatim.
+     */
+    @Test
+    public void cipherCanEncode() {
+        String cipherText = cipherWithDefaultKey.getKey().substring(0, 10);
+        assertEquals(cipherText, cipherWithDefaultKey.encode("aaaaaaaaaa"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDecode() {
+        String cipherText = "aaaaaaaaaa";
+        assertEquals(cipherText, cipherWithDefaultKey.decode(cipherWithDefaultKey.getKey().substring(0, 10)));
+    }
+
+    @Ignore
+    @Test
+    public void cipherIsReversible() {
+        String plainText = "abcdefghij";
+        assertEquals(plainText, cipherWithDefaultKey.decode(cipherWithDefaultKey.encode(plainText)));
+    }
+}

exercises/simple-cipher/src/test/java/SimpleCipherStepThreeTest.java

@@ -0,0 +1,63 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.*;
+
+/**
+ * Step 3: Generate random key if key isn't specified. Check key is right format
+ */
+public class SimpleCipherStepThreeTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Ignore
+    @Test
+    public void cipherKeyIsMadeOfLetters() {
+        assertTrue(new Cipher().getKey().matches("[a-z]+"));
+    }
+
+    @Ignore
+    @Test
+    public void defaultCipherKeyIs100Characters() {
+        assertEquals(100, new Cipher().getKey().length());
+    }
+
+    @Ignore
+    @Test
+    public void cipherKeysAreRandomlyGenerated() {
+        String newKey = new Cipher().getKey();
+        assertFalse("Cipher constructor without argument should generate a random key. No two calls to the" +
+                " constructor should generate the same key. Two calls to the constructor " +
+                "both returned key: " + newKey, newKey.equals(new Cipher().getKey()));
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithAllCapsKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("ABCDEF");
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithAnyCapsKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("abcdEFg");
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithNumericKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("12345");
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithAnyNumericKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("abcd345ef");
+    }
+}

exercises/simple-cipher/src/test/java/SimpleCipherStepTwoTest.java

@@ -0,0 +1,86 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Step 2: Specify key and use that for shift distance : substitution cipher
+ */
+public class SimpleCipherStepTwoTest {
+    private Cipher cipherWithSetKey;
+    private static final String key = "abcdefghij";
+
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Before
+    public void setup() {
+        cipherWithSetKey = new Cipher(key);
+    }
+
+    @Ignore
+    @Test
+    public void cipherKeepsTheSubmittedKey() {
+        assertEquals(key, cipherWithSetKey.getKey());
+    }
+
+    @Ignore
+    @Test
+    public void cipherThrowsWithEmptyKey() {
+        expectedException.expect(IllegalArgumentException.class);
+        new Cipher("");
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanEncodeWithGivenKey() {
+        String cipherText = "abcdefghij";
+        assertEquals(cipherText, cipherWithSetKey.encode("aaaaaaaaaa"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDecodeWithGivenKey() {
+        String cipherText = "aaaaaaaaaa";
+        assertEquals(cipherText, cipherWithSetKey.decode("abcdefghij"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherIsReversibleGivenKey() {
+        String plainText = "abcdefghij";
+        assertEquals(plainText, cipherWithSetKey.decode(cipherWithSetKey.encode("abcdefghij")));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanWrapEncode() {
+        String cipherText = "zabcdefghi";
+        assertEquals(cipherText, cipherWithSetKey.encode("zzzzzzzzzz"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanEncodeMessageThatIsShorterThanTheKey() {
+        String cipherText = "abcde";
+        assertEquals(cipherText, cipherWithSetKey.encode("aaaaa"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDecodeMessageThatIsShorterThanTheKey() {
+        String cipherText = "aaaaa";
+        assertEquals(cipherText, cipherWithSetKey.decode("abcde"));
+    }
+
+    @Ignore
+    @Test
+    public void cipherCanDoubleShiftEncode() {
+        String plainText = "iamapandabear";
+        String cipherText = "qayaeaagaciai";
+        assertEquals(cipherText, new Cipher(plainText).encode(plainText));
+    }
+}

exercises/simple-cipher/src/test/java/SimpleCipherTest.java

@@ -1,11 +0,0 @@
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
-        RandomKeyCipherTest.class,
-        IncorrectKeyCipherTest.class,
-        SubstitutionCipherTest.class
-})
-public class SimpleCipherTest {
-}

exercises/simple-cipher/src/test/java/SubstitutionCipherTest.java

@@ -1,79 +0,0 @@
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.Ignore;
-
-import static org.junit.Assert.assertEquals;
-
-public class SubstitutionCipherTest {
-
-    private static final String KEY = "abcdefghij";
-    private Cipher cipher;
-
-    @Before
-    public void setup() {
-        this.cipher = new Cipher(KEY);
-    }
-
-
-    @Test
-    public void cipherKeepsTheSubmittedKey() {
-        assertEquals(KEY, cipher.getKey());
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanEncodeWithGivenKey() {
-        String expectedOutput = "abcdefghij";
-
-        assertEquals(expectedOutput, cipher.encode("aaaaaaaaaa"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDecodeWithGivenKey() {
-        String expectedOutput = "aaaaaaaaaa";
-
-        assertEquals(expectedOutput, cipher.decode("abcdefghij"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherIsReversibleGivenKey() {
-        String plainText = "abcdefghij";
-
-        assertEquals(plainText, cipher.decode(cipher.encode("abcdefghij")));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDoubleShiftEncode() {
-        String plainText = "iamapandabear";
-        String expectedOutput = "qayaeaagaciai";
-
-        assertEquals(expectedOutput, new Cipher(plainText).encode(plainText));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanWrapEncode() {
-        String expectedOutput = "zabcdefghi";
-
-        assertEquals(expectedOutput, cipher.encode("zzzzzzzzzz"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanEncodeMessageThatIsShorterThanTheKey() {
-        String expectedOutput = "abcde";
-
-        assertEquals(expectedOutput, cipher.encode("aaaaa"));
-    }
-
-    @Ignore
-    @Test
-    public void cipherCanDecodeMessageThatIsShorterThanTheKey() {
-        String expectedOutput = "aaaaa";
-
-        assertEquals(expectedOutput, cipher.decode("abcde"));
-    }
-}