Merge branch 'master' of https://github.com/UWPCE-PythonCert/IntroPython-2017

Author: kmarguerite

examples/Session06/cigar_party.py

@@ -0,0 +1,15 @@
+
+"""
+When squirrels get together for a party, they like to have cigars.
+A squirrel party is successful when the number of cigars is between
+40 and 60, inclusive. Unless it is the weekend, in which case there
+is no upper bound on the number of cigars.
+
+Return True if the party with the given values is successful,
+or False otherwise.
+"""
+
+
+def cigar_party(num, weekend):
+    pass
+

examples/Session06/codingbat.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+"""
+Examples from: http://codingbat.com
+
+Put here so we can write unit tests for them ourselves
+"""
+
+# Python > Warmup-1 > sleep_in
+
+# The parameter weekday is True if it is a weekday, and the parameter
+# vacation is True if we are on vacation.
+#
+# We sleep in if it is not a weekday or we're on vacation.
+# Return True if we sleep in.
+
+
+def sleep_in(weekday, vacation):
+    return not weekday or vacation
+
+
+# We have two monkeys, a and b, and the parameters a_smile and b_smile
+# indicate if each is smiling.
+
+# We are in trouble if they are both smiling or if neither of them is
+# smiling.
+
+# Return True if we are in trouble.
+
+def monkey_trouble(a_smile, b_smile):
+    return a_smile is b_smile

examples/Session06/my_mod.py

@@ -0,0 +1,8 @@
+
+"""
+A trivial module to demonstrate testing
+"""
+
+
+def my_func(val1, val2):
+    return val1 * val2

examples/Session06/test_cigar_party.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+"""
+When squirrels get together for a party, they like to have cigars.
+A squirrel party is successful when the number of cigars is between
+40 and 60, inclusive. Unless it is the weekend, in which case there
+is no upper bound on the number of cigars.
+
+Return True if the party with the given values is successful,
+or False otherwise.
+"""
+
+
+# you can change this import to test different versions
+from cigar_party import cigar_party
+# from cigar_party import cigar_party2 as cigar_party
+# from cigar_party import cigar_party3 as cigar_party
+
+
+def test_1():
+    assert cigar_party(30, False) is False
+
+
+def test_2():
+
+    assert cigar_party(50, False) is True
+
+
+def test_3():
+
+    assert cigar_party(70, True) is True
+
+
+def test_4():
+    assert cigar_party(30, True) is False
+
+
+def test_5():
+    assert cigar_party(50, True) is True
+
+
+def test_6():
+    assert cigar_party(60, False) is True
+
+
+def test_7():
+    assert cigar_party(61, False) is False
+
+
+def test_8():
+    assert cigar_party(40, False) is True
+
+
+def test_9():
+    assert cigar_party(39, False) is False
+
+
+def test_10():
+    assert cigar_party(40, True) is True
+
+
+def test_11():
+    assert cigar_party(39, True) is False
+

examples/Session06/test_codingbat.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+"""
+test file for codingbat module
+
+This version can be run with nose or py.test
+"""
+
+from codingbat import sleep_in, monkey_trouble
+
+
+# tests for sleep_in
+def test_false_false():
+    assert sleep_in(False, False)
+
+
+def test_true_false():
+    assert not (sleep_in(True, False))
+
+
+def test_false_true():
+    assert sleep_in(False, True)
+
+
+def test_true_true():
+    assert sleep_in(True, True)
+
+
+# put tests for monkey_trouble here
+# monkey_trouble(True, True) → True
+# monkey_trouble(False, False) → True
+# monkey_trouble(True, False) → False
+
+def test_monkey_true_true():
+    assert monkey_trouble(True, True)
+
+def test_monkey_false_false():
+    assert monkey_trouble(False, False)
+
+def test_monkey_true_false():
+    assert monkey_trouble(True, False) is False
+
+# more!

examples/Session06/test_my_mod.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+import unittest
+from my_mod import my_func
+
+
+class MyFuncTestCase(unittest.TestCase):
+    def test_my_func(self):
+        test_vals = (2, 3)
+        expected = test_vals[0] * test_vals[1]
+        actual = my_func(*test_vals)
+        self.assertEquals(expected, actual)
+
+
+if __name__ == '__main__':
+    unittest.main()

examples/Session06/test_pytest_parameter.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+"""
+pytest example of a parameterized test
+
+NOTE: there is a failure in here! can you fix it?
+
+"""
+import pytest
+
+
+# a (really simple) function to test
+def add(a, b):
+    """
+    returns the sum of a and b
+    """
+    return a + b
+
+# now some test data:
+
+test_data = [((2, 3), 5),
+             ((-3, 2), -1),
+             ((2, 0.5), 2.5),
+             (("this", "that"), "this that"),
+             (([1, 2, 3], [6, 7, 8]), [1, 2, 3, 6, 7, 8]),
+             ]
+
+
+@pytest.mark.parametrize(("input", "result"), test_data)
+def test_add(input, result):
+    assert add(*input) == result

examples/Session06/test_random_pytest.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+"""
+port of the random unit tests from the python docs to py.test
+"""
+
+import random
+import pytest
+
+
+seq = list(range(10))
+
+
+def test_shuffle():
+    # make sure the shuffled sequence does not lose any elements
+    random.shuffle(seq)
+    # seq.sort()  # commenting this out will make it fail, so we can see output
+    print("seq:", seq)  # only see output if it fails
+    assert seq == list(range(10))
+
+
+def test_shuffle_immutable():
+    """should get a TypeError with an imutable type """
+    with pytest.raises(TypeError):
+        random.shuffle((1, 2, 3))
+
+
+def test_choice():
+    """make sure a random item selected is in the original sequence"""
+    element = random.choice(seq)
+    assert (element in seq)
+
+
+def test_sample():
+    """make sure all items returned by sample are there"""
+    for element in random.sample(seq, 5):
+        assert element in seq
+
+
+def test_sample_too_large():
+    """should get a ValueError if you try to sample too many"""
+    with pytest.raises(ValueError):
+        random.sample(seq, 20)

examples/Session06/test_random_unitest.py

@@ -0,0 +1,30 @@
+import random
+import unittest
+
+
+class TestSequenceFunctions(unittest.TestCase):
+
+    def setUp(self):
+        self.seq = list(range(10))
+
+    def test_shuffle(self):
+        # make sure the shuffled sequence does not lose any elements
+        random.shuffle(self.seq)
+        self.seq.sort()
+        self.assertEqual(self.seq, list(range(10)))
+
+        # should raise an exception for an immutable sequence
+        self.assertRaises(TypeError, random.shuffle, (1, 2, 3))
+
+    def test_choice(self):
+        element = random.choice(self.seq)
+        self.assertTrue(element in self.seq)
+
+    def test_sample(self):
+        with self.assertRaises(ValueError):
+            random.sample(self.seq, 20)
+        for element in random.sample(self.seq, 5):
+            self.assertTrue(element in self.seq)
+
+if __name__ == '__main__':
+    unittest.main()

materials/source/notes/session08.rst

@@ -33,32 +33,40 @@ If the object(s) you need to create are complex, then you can use "fixtures" to
 
 This will start to make more and more sense as we do more testing -- and particularly when we do TDD and write the tests along with the code.
 
-do you always need an __init__?
-------------------------------
-
-No -- you don't :-)
+Example:
+........
 
-The ONLY thing "special" about __init__ is that it is automatically called when and instance is created.  Other than that, it's a regular method. So if you don't define one, then the superclass' __init__ will be called.
-
-That's what inheritance is all about -- the subclass inherits ALL the superclasses methods -- including __init__.
+.. code-block:: python
 
-So never write an __init__ that does nothing but call the superclass __init__
+    def test_p_tag():
+        assert Para.tag == 'p'
 
+I know I started out that way -- 'cause there wasn't anything else to test. But this is really testing an implementation detail -- the Para elements has a attribute named "tag" that is 'p'. But is that a public part of the API? do we care? -- No. What we care about is that the correct tag gets rendered, so a test for THAT makes more sense:
 
-Bad OO design
--------------
+.. code-block:: python
 
-Script from work...depersonalized
+    def test_render_para():
+        my_stuff = 'spam, spam, spam'
+        p = Para(my_stuff)
+        more_stuff = 'eggs, eggs, eggs'
+        p.append(more_stuff)
+        contents = render_element(p).strip()
+        assert contents.startswith('<p>')
+        assert contents.endswith('</p>')
+        assert my_stuff in contents
+        assert more_stuff in contents
 
-In class repo: ``examples/session08/unnecessary_oo.py``
 
-Recall Jack Dietrich's talk: "Stop Writing Classes":
+Do you always need an __init__?
+------------------------------
 
-Also PEP8, etc....
+No -- you don't :-)
 
-let's do a code review.
+The ONLY thing "special" about __init__ is that it is automatically called when and instance is created.  Other than that, it's a regular method. So if you don't define one, then the superclass' __init__ will be called.
 
+That's what inheritance is all about -- the subclass inherits ALL the superclasses methods -- including __init__.
 
+So never write an __init__ that does nothing but call the superclass __init__