Corrected tests docstring and cleaned up tests

Author: Bernardo-MG

tests/parser/dice/test_dice_parser_dice.py

@@ -15,7 +15,7 @@
 
 class TestSimpleDice(unittest.TestCase):
     """
-    Tests that simple dice expressions can be parsed into the Dice class.
+    Tests that simple dice expressions can be parsed.
     """
 
     def setUp(self):
@@ -33,9 +33,9 @@ def test_simpleDice(self):
         self.assertEqual(1, dice.quantity)
         self.assertEqual(6, dice.sides)
 
-    def test_simpleDice_alternativeSeparator(self):
+    def test_simpleDice_upperCaseSeparator(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that the upper case dice separator can be parsed.
         """
         dice = self.parser.parse("1D6")
 
@@ -44,7 +44,7 @@ def test_simpleDice_alternativeSeparator(self):
 
     def test_onesDice(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that dice notation with a single dice and a single side can be parsed.
         """
         dice = self.parser.parse("1d1")
 
@@ -53,7 +53,7 @@ def test_onesDice(self):
 
     def test_zeroQuantity(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that dice notation with zero dice is parsed.
         """
         dice = self.parser.parse("0d6")
 
@@ -62,7 +62,7 @@ def test_zeroQuantity(self):
 
     def test_zeroSides(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that dice notation with zero sides is parsed.
         """
         dice = self.parser.parse("1d0")
 
@@ -71,7 +71,7 @@ def test_zeroSides(self):
 
     def test_zerosDice(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that dice notation with zero dice and zero sides is parsed.
         """
         dice = self.parser.parse("0d0")
 
@@ -80,7 +80,7 @@ def test_zerosDice(self):
 
     def test_max(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that dice notation with the maximum integer values dice is parsed.
         """
         dice = self.parser.parse(str(sys.maxsize) + "d" + str(sys.maxsize))
 

tests/parser/dice/test_dice_parser_dice_binary_operation.py

@@ -5,7 +5,7 @@
 from dice_notation.parser import DiceParser
 
 """
-Dice parser tests for expressions only containing dice.
+Dice parser tests for binary operation expressions only containing dice.
 """
 
 __author__ = 'Bernardo Martínez Garrido'
@@ -14,7 +14,7 @@
 
 class TestDiceBinaryOperation(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that binary operation dice expressions can be parsed.
     """
 
     def setUp(self):
@@ -25,7 +25,7 @@ def setUp(self):
 
     def test_add(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that dice additions can be parsed.
         """
         result = self.parser.parse("1d6+2d20")
 
@@ -40,7 +40,7 @@ def test_add(self):
 
     def test_sub(self):
         """
-        Tests that numeric subtractions are done correctly.
+        Tests that dice subtractions can be parsed.
         """
         result = self.parser.parse("3d12-1D6")
 

tests/parser/dice/test_dice_parser_dice_rollable.py

@@ -6,7 +6,7 @@
 from dice_notation.parser import DiceParser
 
 """
-Dice parser tests for expressions only containing dice.
+Dice parser tests for dice expressions, validating the output class.
 """
 
 __author__ = 'Bernardo Martínez Garrido'
@@ -15,7 +15,7 @@
 
 class TestRollable(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that dice expressions return instances of Rollable.
     """
 
     def setUp(self):
@@ -26,23 +26,23 @@ def setUp(self):
 
     def test_simpleDice_rollable(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that parsing simple dice notation returns a Rollable.
         """
         dice = self.parser.parse("1d6")
 
         self.assertTrue(isinstance(dice, Rollable))
 
     def test_add_rollable(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that parsing dice notation additions return a Rollable.
         """
         result = self.parser.parse("1d6+2d20")
 
         self.assertTrue(isinstance(result, Rollable))
 
     def test_sub_rollable(self):
         """
-        Tests that numeric subtractions are done correctly.
+        Tests that parsing dice notation subtractions return a Rollable.
         """
         result = self.parser.parse("3d12-1D6")
 

tests/parser/number/test_dice_parser_number.py

@@ -14,7 +14,7 @@
 
 class TestNumber(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that numeric expressions can be parsed.
     """
 
     def setUp(self):
@@ -25,23 +25,23 @@ def setUp(self):
 
     def test_positive(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that positive numbers can be parsed.
         """
         result = self.parser.parse("5")
 
         self.assertEqual(5, result)
 
     def test_zero(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that the zero value can be parsed.
         """
         result = self.parser.parse("0")
 
         self.assertEqual(0, result)
 
     def test_negative(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that negative numbers can be parsed.
         """
         result = self.parser.parse("-5")
 

tests/parser/number/test_dice_parser_number_add.py

@@ -5,7 +5,7 @@
 from dice_notation.parser import DiceParser
 
 """
-Dice parser tests for purely numeric expressions.
+Dice parser tests for purely numeric addition expressions.
 """
 
 __author__ = 'Bernardo Martínez Garrido'
@@ -14,7 +14,7 @@
 
 class TestAdd(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that numeric addition expressions can be parsed.
     """
 
     def setUp(self):
@@ -25,15 +25,15 @@ def setUp(self):
 
     def test_add(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that additions can be parsed, and the result is the expected one.
         """
         result = self.parser.parse("1+2")
 
         self.assertEqual(3, result)
 
     def test_add_toNegative(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that additions to a negative value can be parsed, and the result is the expected one.
         """
         result = self.parser.parse("-1+2")
 
@@ -43,7 +43,7 @@ def test_add_toNegative(self):
 
 class TestAddLong(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that long numeric addition expressions can be parsed.
     """
 
     def setUp(self):
@@ -54,15 +54,15 @@ def setUp(self):
 
     def test_longAdd(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that long additions can be parsed, and the result is the expected one.
         """
         result = self.parser.parse("1+2+3")
 
         self.assertEqual(6, result)
 
     def test_longerAdd(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that longer additions can be parsed, and the result is the expected one.
         """
         result = self.parser.parse("1+2+3+4+5")
 

tests/parser/number/test_dice_parser_number_binary_op_mixed.py

@@ -5,7 +5,9 @@
 from dice_notation.parser import DiceParser
 
 """
-Dice parser tests for purely numeric expressions.
+Dice parser tests for mixed numeric binary operation expressions.
+
+A mixer operation contains additions and subtractions.
 """
 
 __author__ = 'Bernardo Martínez Garrido'
@@ -14,7 +16,7 @@
 
 class TestNumericBinaryOperationMixed(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that mixed numeric binary operation expressions can be parsed.
     """
 
     def setUp(self):
@@ -25,15 +27,15 @@ def setUp(self):
 
     def test_addAndSub(self):
         """
-        Tests that numeric additions are done correctly.
+        Tests that additions followed by subtractions can be parsed, and the result is the expected one.
         """
         result = self.parser.parse("1+2-3")
 
         self.assertEqual(0, result)
 
     def test_subAndAdd(self):
         """
-        Tests that numeric subtractions are done correctly.
+        Tests that subtractions followed by additions can be parsed, and the result is the expected one.
         """
         result = self.parser.parse("3-1+2")
 

tests/parser/number/test_dice_parser_number_rollable.py

@@ -6,7 +6,7 @@
 from dice_notation.parser import DiceParser
 
 """
-Dice parser tests for purely numeric expressions.
+Dice parser tests for numeric expressions, validating the output class.
 """
 
 __author__ = 'Bernardo Martínez Garrido'
@@ -15,7 +15,7 @@
 
 class TestRollable(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that numeric expressions return instances of Rollable.
     """
 
     def setUp(self):
@@ -26,23 +26,23 @@ def setUp(self):
 
     def test_number_rollable(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that parsing numbers returns a Rollable.
         """
         result = self.parser.parse("1")
 
         self.assertTrue(isinstance(result, Rollable))
 
     def test_add_rollable(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that parsing numeric additions returns a Rollable.
         """
         result = self.parser.parse("1+2")
 
         self.assertTrue(isinstance(result, Rollable))
 
     def test_sub_rollable(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that parsing numeric subtractions returns a Rollable.
         """
         result = self.parser.parse("1-2")
 
@@ -51,7 +51,7 @@ def test_sub_rollable(self):
 
 class TestRoll(unittest.TestCase):
     """
-    Tests that the parser can work with pure numeric operations.
+    Tests that rolling the result from parsing numeric expressions returns the expected value.
     """
 
     def setUp(self):
@@ -60,25 +60,25 @@ def setUp(self):
         """
         self.parser = DiceParser()
 
-    def test_number_rollable(self):
+    def test_number_roll(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that rolling a parsed number returns the expected value.
         """
         result = self.parser.parse("1")
 
         self.assertEqual(1, result.roll())
 
-    def test_add_rollable(self):
+    def test_add_roll(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that rolling a parsed numeric addition returns the expected value.
         """
         result = self.parser.parse("1+2")
 
         self.assertEqual(3, result.roll())
 
-    def test_sub_rollable(self):
+    def test_sub_roll(self):
         """
-        Tests that a simple dice notation can be parsed.
+        Tests that rolling a parsed numeric subtraction returns the expected value.
         """
         result = self.parser.parse("1-2")