py2: Split up about_strings. Removed __name__ tests in favor of educating on __class__ in a wiki page. Added an extra __class__ koan in about_asserts as a primer

Author: gregmalcolm

python2/koans/about_asserts.py

@@ -44,8 +44,31 @@ def test_a_better_way_of_asserting_equality(self):
 
     def test_that_unittest_asserts_work_the_same_way_as_python_asserts(self):
         """
-        Knowing how things really work is half the battle
+        Understand what lies within.
         """
 
         # This throws an AssertionError exception
         assert False
+
+    def test_that_sometimes_we_need_to_know_the_class_type(self):
+        """
+        What is in a class name?
+        """
+
+        # Sometimes we will ask you what the class type of an object is.
+        #
+        # For example, contemplate the text string "naval". What is it's class type?
+        # The koans runner will include this feedback for this koan:
+        #
+        #   AssertionError: '-=> FILL ME IN! <=-' != <type 'str'>
+        #
+        # So "naval".__class__ is equal to <type 'str'>? No not quite. This
+        # is just what it displays. The answer is simply str.
+        #
+        # See for yourself:
+
+        self.assertEqual(__, "naval".__class__) # It's str, not <type 'str'>
+
+        # Need an illustration? More reading can be found here:
+        #
+        # https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute

python2/koans/about_attribute_access.py

@@ -19,7 +19,7 @@ def test_calling_undefined_functions_normally_results_in_errors(self):
         try:
             typical.foobar()
         except Exception as exception:
-            self.assertEqual(__, type(exception).__name__)
+            self.assertEqual(__, exception.__class__)
             self.assertMatch(__, exception[0])
 
     def test_calling_getattribute_causes_an_attribute_error(self):
@@ -160,7 +160,7 @@ def test_getattr_only_catches_unknown_attributes(self):
         catcher.free_pie()
 
         self.assertEqual(__,
-            type(catcher.give_me_duff_or_give_me_death()).__name__)
+            catcher.give_me_duff_or_give_me_death().__class__)
 
         self.assertEqual(__, catcher.no_of_getattr_calls)
 

python2/koans/about_classes.py

@@ -10,7 +10,7 @@ class Dog(object):
 
     def test_instances_of_classes_can_be_created_adding_parentheses(self):
         fido = self.Dog()
-        self.assertEqual(__, type(fido).__name__)
+        self.assertEqual(__, fido.__class__)
 
     def test_classes_have_docstrings(self):
         self.assertMatch(__, self.Dog.__doc__)

python2/koans/about_method_bindings.py

@@ -77,8 +77,8 @@ def test_get_descriptor_resolves_attribute_binding(self):
         #   binding_owner = obj
         #   owner_type = cls
 
-        self.assertEqual(__, type(bound_obj).__name__)
-        self.assertEqual(__, type(binding_owner).__name__)
+        self.assertEqual(__, bound_obj.__class__)
+        self.assertEqual(__, binding_owner.__class__)
         self.assertEqual(AboutMethodBindings, owner_type)
 
     # ------------------------------------------------------------------

python2/koans/about_methods.py

@@ -22,7 +22,7 @@ def test_calling_functions_with_wrong_number_of_arguments(self):
         try:
             my_global_function()
         except Exception as exception:
-            self.assertEqual(__, type(exception).__name__)
+            self.assertEqual(__, exception.__class__)
             self.assertMatch(
                 r'my_global_function\(\) takes exactly 2 arguments \(0 given\)',
                 exception[0])
@@ -158,7 +158,7 @@ def test_double_underscore_attribute_prefixes_cause_name_mangling(self):
             #This may not be possible...
             password = rover.__password()
         except Exception as ex:
-            self.assertEqual(__, type(ex).__name__)
+            self.assertEqual(__, ex.__class__)
 
         # But this still is!
         self.assertEqual(__, rover._Dog__password())

python2/koans/about_new_style_classes.py

@@ -34,7 +34,7 @@ def test_new_style_classes_have_more_attributes(self):
     # ------------------------------------------------------------------
 
     def test_old_style_classes_have_type_but_no_class_attribute(self):
-        self.assertEqual(__, type(self.OldStyleClass).__name__)
+        self.assertEqual(__, self.OldStyleClass.__class__)
 
         try:
             cls = self.OldStyleClass.__class__
@@ -45,7 +45,7 @@ def test_old_style_classes_have_type_but_no_class_attribute(self):
 
     def test_new_style_classes_have_same_class_as_type(self):
         new_style = self.NewStyleClass()
-        self.assertEqual(__, type(self.NewStyleClass).__name__)
+        self.assertEqual(__, self.NewStyleClass.__class__)
         self.assertEqual(
             __,
             type(self.NewStyleClass) == self.NewStyleClass.__class__)
@@ -54,10 +54,9 @@ def test_new_style_classes_have_same_class_as_type(self):
 
     def test_in_old_style_instances_class_is_different_to_type(self):
         old_style = self.OldStyleClass()
-        self.assertEqual(__, type(old_style).__name__)
-        self.assertEqual(__, old_style.__class__.__name__)
+        self.assertEqual(__, old_style.__class__)
 
     def test_new_style_instances_have_same_class_as_type(self):
         new_style = self.NewStyleClass()
-        self.assertEqual(__, type(new_style).__name__)
+        self.assertEqual(__, new_style.__class__)
         self.assertEqual(__, type(new_style) == new_style.__class__)

python2/koans/about_none.py

@@ -33,7 +33,11 @@ def test_what_exception_do_you_get_when_calling_nonexistent_methods(self):
             None.some_method_none_does_not_know_about()
         except Exception as ex:
             # What exception has been caught?
-            self.assertEqual(__, ex.__class__.__name__)
+            #
+            # Need a recap on how to evaluate __class__ attributes?
+            #   https://github.com/gregmalcolm/python_koans/wiki/Class-Attribute
+
+            self.assertEqual(__, ex.__class__)
 
             # What message was attached to the exception?
             # (HINT: replace __ with part of the error message.)

python2/koans/about_string_manipulation.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from runner.koan import *
+
+
+class AboutStringManipulation(Koan):
+
+    def test_use_format_to_interpolate_variables(self):
+        value1 = 'one'
+        value2 = 2
+        string = "The values are {0} and {1}".format(value1, value2)
+        self.assertEqual(__, string)
+
+    def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
+        value1 = 'doh'
+        value2 = 'DOH'
+        string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2)
+        self.assertEqual(__, string)
+
+    def test_any_python_expression_may_be_interpolated(self):
+        import math  # import a standard python module with math functions
+
+        decimal_places = 4
+        string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5), \
+            decimal_places)
+        self.assertEqual(__, string)
+
+    def test_you_can_get_a_substring_from_a_string(self):
+        string = "Bacon, lettuce and tomato"
+        self.assertEqual(__, string[7:10])
+
+    def test_you_can_get_a_single_character_from_a_string(self):
+        string = "Bacon, lettuce and tomato"
+        self.assertEqual(__, string[1])
+
+    def test_single_characters_can_be_represented_by_integers(self):
+        self.assertEqual(__, ord('a'))
+        self.assertEqual(__, ord('b') == (ord('a') + 1))
+
+    def test_strings_can_be_split(self):
+        string = "Sausage Egg Cheese"
+        words = string.split()
+        self.assertEqual([__, __, __], words)
+
+    def test_strings_can_be_split_with_different_patterns(self):
+        import re  # import python regular expression library
+
+        string = "the,rain;in,spain"
+        pattern = re.compile(',|;')
+
+        words = pattern.split(string)
+
+        self.assertEqual([__, __, __, __], words)
+
+        # `pattern` is a Python regular expression pattern which matches
+        # ',' or ';'
+
+    def test_raw_strings_do_not_interpret_escape_characters(self):
+        string = r'\n'
+        self.assertNotEqual('\n', string)
+        self.assertEqual(__, string)
+        self.assertEqual(__, len(string))
+
+        # Useful in regular expressions, file paths, URLs, etc.
+
+    def test_strings_can_be_joined(self):
+        words = ["Now", "is", "the", "time"]
+        self.assertEqual(__, ' '.join(words))
+
+    def test_strings_can_change_case(self):
+        self.assertEqual(__, 'guido'.capitalize())
+        self.assertEqual(__, 'guido'.upper())
+        self.assertEqual(__, 'TimBot'.lower())
+        self.assertEqual(__, 'guido van rossum'.title())
+        self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase())

python2/koans/about_strings.py

@@ -92,72 +92,3 @@ def test_most_strings_interpret_escape_characters(self):
         self.assertEqual('\n', string)
         self.assertEqual("""\n""", string)
         self.assertEqual(__, len(string))
-
-    def test_use_format_to_interpolate_variables(self):
-        value1 = 'one'
-        value2 = 2
-        string = "The values are {0} and {1}".format(value1, value2)
-        self.assertEqual(__, string)
-
-    def test_formatted_values_can_be_shown_in_any_order_or_be_repeated(self):
-        value1 = 'doh'
-        value2 = 'DOH'
-        string = "The values are {1}, {0}, {0} and {1}!".format(value1, value2)
-        self.assertEqual(__, string)
-
-    def test_any_python_expression_may_be_interpolated(self):
-        import math  # import a standard python module with math functions
-
-        decimal_places = 4
-        string = "The square root of 5 is {0:.{1}f}".format(math.sqrt(5), \
-            decimal_places)
-        self.assertEqual(__, string)
-
-    def test_you_can_get_a_substring_from_a_string(self):
-        string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[7:10])
-
-    def test_you_can_get_a_single_character_from_a_string(self):
-        string = "Bacon, lettuce and tomato"
-        self.assertEqual(__, string[1])
-
-    def test_single_characters_can_be_represented_by_integers(self):
-        self.assertEqual(__, ord('a'))
-        self.assertEqual(__, ord('b') == (ord('a') + 1))
-
-    def test_strings_can_be_split(self):
-        string = "Sausage Egg Cheese"
-        words = string.split()
-        self.assertEqual([__, __, __], words)
-
-    def test_strings_can_be_split_with_different_patterns(self):
-        import re  # import python regular expression library
-
-        string = "the,rain;in,spain"
-        pattern = re.compile(',|;')
-
-        words = pattern.split(string)
-
-        self.assertEqual([__, __, __, __], words)
-
-        # `pattern` is a Python regular expression pattern which matches
-        # ',' or ';'
-
-    def test_raw_strings_do_not_interpret_escape_characters(self):
-        string = r'\n'
-        self.assertNotEqual('\n', string)
-        self.assertEqual(__, string)
-        self.assertEqual(__, len(string))
-
-        # Useful in regular expressions, file paths, URLs, etc.
-
-    def test_strings_can_be_joined(self):
-        words = ["Now", "is", "the", "time"]
-        self.assertEqual(__, ' '.join(words))
-
-    def test_strings_can_change_case(self):
-        self.assertEqual(__, 'guido'.capitalize())
-        self.assertEqual(__, 'guido'.upper())
-        self.assertEqual(__, 'TimBot'.lower())
-        self.assertEqual(__, 'guido van rossum'.title())
-        self.assertEqual(__, 'ToTaLlY aWeSoMe'.swapcase())

python2/koans/about_tuples.py

@@ -39,8 +39,8 @@ def test_tuples_can_only_be_changed_through_replacement(self):
         self.assertEqual(__, count_of_three)
 
     def test_tuples_of_one_look_peculiar(self):
-        self.assertEqual(__, (1).__class__.__name__)
-        self.assertEqual(__, (1,).__class__.__name__)
+        self.assertEqual(__, (1).__class__)
+        self.assertEqual(__, (1,).__class__)
         self.assertEqual(__, ("Hello comma!", ))
 
     def test_tuple_constructor_can_be_surprising(self):

python2/runner/path_to_enlightenment.py

@@ -6,11 +6,12 @@
 import unittest
 
 from koans.about_asserts import AboutAsserts
+from koans.about_strings import AboutStrings
 from koans.about_none import AboutNone
 from koans.about_lists import AboutLists
 from koans.about_list_assignments import AboutListAssignments
+from koans.about_string_manipulation import AboutStringManipulation
 from koans.about_dictionaries import AboutDictionaries
-from koans.about_strings import AboutStrings
 from koans.about_tuples import AboutTuples
 from koans.about_methods import AboutMethods
 from koans.about_control_statements import AboutControlStatements
@@ -48,11 +49,12 @@ def koans():
     suite = unittest.TestSuite()
     loader.sortTestMethodsUsing = None
     suite.addTests(loader.loadTestsFromTestCase(AboutAsserts))
+    suite.addTests(loader.loadTestsFromTestCase(AboutStrings))
     suite.addTests(loader.loadTestsFromTestCase(AboutNone))
     suite.addTests(loader.loadTestsFromTestCase(AboutLists))
     suite.addTests(loader.loadTestsFromTestCase(AboutListAssignments))
+    suite.addTests(loader.loadTestsFromTestCase(AboutStringManipulation))
     suite.addTests(loader.loadTestsFromTestCase(AboutDictionaries))
-    suite.addTests(loader.loadTestsFromTestCase(AboutStrings))
     suite.addTests(loader.loadTestsFromTestCase(AboutTuples))
     suite.addTests(loader.loadTestsFromTestCase(AboutMethods))
     suite.addTests(loader.loadTestsFromTestCase(AboutControlStatements))