class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
#work in progress"
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "123")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "123")
self.assertTrue(self.phonebook.is_consistent())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add('Ali', '12345')
self.assertEqual('12345', self.phonebook.lookup('Ali'))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Ali", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_consistent(self):
self.phonebook.add("Ali", "12345")
self.phonebook.add("Mary", "12345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_number_prefix_one_is_consistent(self):
self.phonebook.add("Ali", "12345")
self.phonebook.add("Mary", "123")
self.assertTrue(self.phonebook.is_consistent())
# For memory management and should be after all the test ran
# teardown only runs if the setup is successful
def tearDown(self):
pass
class PhonebookTest(unittest.TestCase):
def setUp(self):
logger = Mock(Logger)
self.phonebook = Phonebook(logger)
# def tearDown(self):
# pass
def test_create_phonebook(self):
phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_miising_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_gives_access_to_names(self):
self.phonebook.add("Alice", "123")
self.assertIn("Alice", self.phonebook.names())
def test_phonebook_gives_access_to_numbers(self):
self.phonebook.add("Alice", "123")
self.assertIn("123", self.phonebook.numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
self.phonebook = Phonebook()
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_consistent(
self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "123")
self.assertFalse(self.phonebook.is_consistent())
class PhonebookTest(unittest.TestCase):
# The setUp() and tearDown() methods allow you to define instructions that will
# be executed before and after each test method.
def setUp(self):
self.phonebook = Phonebook()
def tearDown(self):
pass
def test_create_phonebook(self):
pass
def test_lookup_entry_by_name(self):
# phonebook = Phonebook()
self.phonebook.add('bob', '12345')
self.assertEqual('12345', self.phonebook.lookup("bob"))
def test_missing_entry_raises_KeyError(self):
# phonebook = Phonebook()
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
# @unittest.skip("not complete")
def test_empty_phonebook_is_consistent(self):
# phonebook = Phonebook()
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip("poor example")
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("sue", "12345") #identical to bob
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("bob", "12345")
self.phonebook.add("mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("bob", "12345")
self.phonebook.add("mary", "12345")
self.assertFalse(self.phonebook.is_consistent())
@unittest.skip("not ready")
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistent(self):
self.phonebook.add("bob", "12345")
self.phonebook.add("mary", "123")
self.assertFalse(self.phonebook.is_consistent())
# @unittest.skip("not ready")
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("sue", "12345")
self.assertIn("sue", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
class TestPhonebook(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def tearDown(self):
# to clean up
pass
def test_lookup_entry_by_name(self):
print(id(self.phonebook))
self.phonebook.add("Bob", "12345")
# By convention first should go the expected values
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_raises_KeyErro(self):
print(id(self.phonebook))
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip("poor exampless")
# if one the assert fails, fails the test case
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "12345")
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add("Sue", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_entries_is_inconsistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistent(
self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "123")
self.assertFalse(self.phonebook.is_consistent())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
# @unittest.skip("poor example")
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "12345") # identical to Bob
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add("Sue", "123") # prefix of Bob
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistent(
self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
# self.phonebook.add("Sue", "12345")
# self.assertIn("Sue", phonebook.get_names())
# self.assertIn("12345", phonebook.get_numbers())
self.phonebook.add("Sue", "12345")
self.assertIn("Sue", self.phonebook.get_names)
self.assertIn("12345", self.phonebook.get_numbers)
class PhonebookTest(unittest.TestCase):
#TestFixture: setUp: generate avaible elements for all test functions
def setUp(self):
self.phonebook = Phonebook()
#TestFixture: tearDown: Run after every test function (clean up func)
def tearDown(self):
pass
#Look Up
def test_lookup_entry_by_name(self):
self.phonebook.add('Bob', '12345')
self.assertEqual('12345', self.phonebook.lookup('Bob'))
#throw a key error when missing a key
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup('missing')
#assertTrue: function return TRUE/FALSE
#@unittest.skip("WIP")
def test_empty_phoneboo_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
#CONSISTENT - ONE queation one test!!!
def test_phonebook_with_normal_entries_is_consistent(self):
#ARRANGE
self.phonebook.add('Bob', '123456')
#ACT
self.phonebook.add('Mary', '012345')
#ASSERT
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip("WIP")
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add('Bob', '123456')
self.phonebook.add('Mary', '123456')
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistent(
self):
self.phonebook.add('Bob', '123456')
self.phonebook.add('Mary', '123')
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add('Sue', '123456')
#assertIn: check if the elem is in an iterable
self.assertIn('Sue', self.phonebook.get_names())
self.assertIn('123456', self.phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("Viki", "12345")
self.assertEqual("12345", self.phonebook.lookup("Viki"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
# @unittest.skip("WIP")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip("Too many things in one case")
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Marci", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Csilla", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Erika", "12345") #same as Marci
self.assertFalse(self.phonebook.is_consistent)
self.phonebook.add("Erika", "123") #prefix of Marci
self.assertFalse(self.phonebook.is_consistent)
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Marci", "12345")
self.phonebook.add("Csilla", "012345")
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip("WIP")
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("Marci", "12345")
self.phonebook.add("Erika", "12345")
self.assertFalse(self.phonebook.is_consistent)
@unittest.skip("WIP")
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistance(
self):
self.phonebook.add("Marci", "12345")
self.phonebook.add("Erika", "123")
self.assertFalse(self.phonebook.is_consistent)
@unittest.skip("WIP")
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Andi", "12345")
self.assertIn("Andi", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def tearDown(self):
pass
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "123456")
self.assertEqual("123456", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def teste_empty_phonebook_is_cnsistent(self):
self.assertTrue(self.phonebook.is_consistent())
#@unittest.skip("poor example")
def test_is_consistent(self):
self.asserttrue(self.phonebook.is_consistent())
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "12345") # identica to Bob
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add("Sue", "123") # prefix of Bob
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phone_adds_names_and_numbers(self):
self.phonebook.add("Sue", "12345")
self.assertIn("Sue", phonebook.get_names())
self.assertIn("12345", phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def tearDown(self):
pass
def test_lookup_entry_by_name(self):
self.phonebook.add('Bob', '12345')
self.assertEqual('12345', self.phonebook.lookup('Bob'))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup('missing')
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip('poor example')
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add('Bob', '12345')
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add('Mary', '012345')
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add('Sue', '12345') # identical to Bob
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add('Sue', '123') # prefix of Bob
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Mary', '012345')
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_consistent(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Mary', '12345')
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_consisten(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Mary', '12345')
self.assertFalse(self.phonebook.is_consistent())
@unittest.skip('WIP')
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add('Sue', '12345')
self.assertIn('Sue', self.phonebook.get_names())
self.assertIn('12345', self.phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook=Phonebook()
def tearDown(self):
self.phonebook=None
def test_lookup_entry_by_name(self):
self.phonebook.add('Bob', '12345')
self.assertEqual('12345', self.phonebook.lookup('Bob'))
def test_missing_enrty_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup('missing')
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip('example not good')
def test_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add('Bob', '123')
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add('Sue', '456')
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add('Mary', '123')
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add('Charlie', '456')
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_normal_entries_is_consistent(self):
self.phonebook.add('Bob', '123')
self.phonebook.add('Sue', '456')
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_duplicate_entries_is_inconsistent(self):
self.phonebook.add('Bob', '123')
self.phonebook.add('Sue', '123')
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_numbers_that_prefix_one_another_is_inconsistent(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Sue', '123')
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_add_names_and_numbers(self):
self.phonebook('Bob', '123')
self.assertIn('Bob', self.phonebook.get_names())
self.assertIn('123', self.phonebook.get_phone_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
class PhoneBookTest(unittest.TestCase):
def setUp(self) -> None:
self.phonebook = Phonebook()
def test_lookup_by_name(self):
self.phonebook.add("Bob","1234")
number = self.phonebook.lookup("Bob")
self.assertEqual("1234", number)
def test_missing_name(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
@unittest.skip("WIP")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
class PhoneBookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
self.phonebook = Phonebook()
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.phonebook = Phonebook()
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip("This is poor unittest design")
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "12345") # identical to Bob
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add("Sue", "123") # prefix of Bob
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consitent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsitent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Sue", "12345") # identical to Bob
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_same_prefix_is_inconsistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Sue", "123") # prefix of Bob
self.assertFalse(self.phonebook.is_consistent())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
#used to clean up depenencies
def tearDown(self):
pass
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("foobar")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("foo", "12345")
self.phonebook.add("bar", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("foo", "12345")
self.phonebook.add("bar", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_another(self):
self.phonebook.add("foo", "1234")
self.phonebook.add("bar", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("foo", "12345")
self.assertIn("foo", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add('Bob', '12345')
self.assertEqual('12345', self.phonebook.lookup('Bob'))
# def test_missing_entry_raises_KeyError(self):
# phonebook = Phonebook()
# with self.assertRaises(KeyError):
# phonebook.lookup('jams')
def test_missing_entry_return_none(self):
self.assertEqual(None, self.phonebook.lookup('Bobjam'))
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_keyerror(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
# @unittest.skip("WIP")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistent(
self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Sue", "12345")
self.assertIn("Sue", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_names())
def tearDown(self):
self.phonebook = None
print("End of the test")
class PhonebookTest(unittest.TestCase):
# setUp method -> runner will run that method prior to each test
def setUp(self):
self.phonebook = Phonebook()
# tearDown method -> runner will run that method after each test
def test_lookup_entry_by_name(self):
self.phonebook.add("test1", "12345")
self.assertEqual("12345", self.phonebook.lookup("test1"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_book_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("test1", "12345")
self.phonebook.add("test2", "67890")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("test1", "12345")
self.phonebook.add("test2", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_inconsistent(
self):
self.phonebook.add("test1", "12345")
self.phonebook.add("test2", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("test1", "12345")
self.assertIn("test1", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_create_phonebook(self):
pass
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_keyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Sue", "12345")
self.assertIn("Sue", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
class TestPhonebook(unittest.TestCase):
def setUp(self):
self.new = Phonebook()
def test_create(self):
self.new.create()
self.assertEqual(self.new.create_flag, True)
def test_add(self):
self.new.add("James Ray", "123456789")
self.new.add("Laura Rose", "23456")
self.new.add("Ambulance", "911")
self.assertEqual(len(set(self.new.database.hashkeys)), 4)
self.assertEqual(self.new.database["Laura Rose"], "23456")
def test_remove(self):
self.new.create()
self.new.add("James Ray", "123456789")
self.new.add("Laura Rose", "23456")
self.new.add("Ambulance", "911")
self.new.remove("James Ray")
self.assertRaises(KeyError)
def test_change(self):
self.new.create()
self.new.add("James Ray", "123456789")
self.new.add("Laura Rose", "23456")
self.new.add("Ambulance", "911")
self.new.change("Laura Rose", "9999999")
self.assertEqual(self.new.database["Laura Rose"], "9999999")
def test_lookup(self):
self.new.create()
self.new.add("Laura Rose", "23456")
self.assertEqual(self.new.lookup("Laura Rose"), "23456")
def test_reverse_lookup(self):
self.new.create()
self.new.add("Laura Rose", "23456")
self.assertEqual(self.new.reverse_lookup("23456"), "Laura Rose")
def test_save(self):
self.new.create()
self.new.add("James Ray", "123456789")
self.new.add("Laura Rose", "23456")
self.new.add("Ambulance", "911")
self.new.save()
self.new2 = Phonebook()
self.assertEqual(self.new.reverse_lookup("23456"), "Laura Rose")
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
#used to clean up depenencies
def tearDown(self):
pass
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("foobar")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("foo", "12345")
self.phonebook.add("bar", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("foo", "12345")
self.phonebook.add("bar", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_another(self):
self.phonebook.add("foo", "1234")
self.phonebook.add("bar", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("foo", "12345")
self.assertIn("foo", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add("alice", "12345")
self.assertEqual("12345", self.phonebook.lookup("alice"))
def test_miss_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup('missing')
def test_less_than_2_pounds_stop_publishing(self):
mock_phys = Mock(PhysicalDimensions())
"""
`mock_phys.weight = 1` if commented out
yields this error from unittest: TypeError: '<' not supported between instances of 'Mock' and 'int'
if real Phys defaults to weight=0, why not the mock?
why can we set the field only after instantiation?
"""
mock_phys.weight = 1
pb = Phonebook(dimensions=mock_phys)
self.assertEqual('stop publishing', pb.keep_publishing())
class TestPhonebook(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
# phonebook = Phonebook()
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
# @unittest.skip("WIP")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def tearDown(self):
pass
@unittest.skip("bad example")
def test_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Bob","12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Bob","12345")
def test_phonebook_with_normal_entries_is_consistent(self):
self.phonebook.add("Bob","12345")
self.phonebook.add("Mary","12345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_is_inconsistent(self):
self.phonebook.add("Bob","12345")
self.phonebook.add("Mary","12345")
self.assertFalse(self.phonebook.is_consistent())
class PhonebookTest(unittest.TestCase):
def setUp(self) -> None:
self.phonebook = Phonebook()
def test_lookup_by_name(self):
self.phonebook.add("Bob", "1234")
number = self.phonebook.lookup("Bob")
self.assertEqual("1234", number)
def test_missing_name_raises_error(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent_with_different_entries(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Sue", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_entries(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Sue", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_prefix(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Sue", "123")
self.assertFalse(self.phonebook.is_consistent())
@unittest.skip('WIP')
def test_phonebook_has_the_name_and_number(self):
# transaction的なものについては、同時に複数のassertを行う
self.phonebook.add("Sue", "123343")
self.assertIn("Sue", self.phonebook.get_names())
self.assertIn("123343", self.phonebook.get_numbers())
class PhonebookTest(unittest.TestCase):
def setUp(self):
# arrange
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
# arrange
expected_number = "12345"
name = "Bob"
self.phonebook.add(name, expected_number)
# act
actual_number = self.phonebook.lookup(name)
# assert
self.assertEqual(expected_number, actual_number)
def test_missing_entry_raises_KeyError(self):
# act and assert
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
# act
phonebook_is_consistent = self.phonebook.is_consistent()
# assert
self.assertTrue(phonebook_is_consistent)
def test_phonebook_with_normal_entries_is_consistent(self):
# arrange
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
# act
phonebook_is_consistent = self.phonebook.is_consistent()
# assert
self.assertTrue(phonebook_is_consistent)
def test_phonebook_with_duplicate_numbers_is_consistent(self):
# arrange
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "12345")
# act
phonebook_is_consistent = self.phonebook.is_consistent()
# assert
self.assertEqual(1, len(self.phonebook.entries), "Should be len of 1 because duplicate phone number rejected")
self.assertEqual("Bob", list(self.phonebook.entries.keys())[0], "Should be Bob because Mary was rejected")
self.assertTrue(phonebook_is_consistent, "Should be True because phonebook add rejects duplicate phone numbers")
def test_phonebook_with_duplicate_names_is_consistent(self):
# arrange
self.phonebook.add("Mary", "12345")
self.phonebook.add("Mary", "678900")
# act
phonebook_is_consistent = self.phonebook.is_consistent()
# assert
self.assertEqual(1, len(self.phonebook.entries), "Should be len of 1 because duplicate name rejected")
self.assertEqual("Mary", list(self.phonebook.entries.keys())[0],
"Should be Mary because second Mary was rejected")
self.assertTrue(phonebook_is_consistent, "Should be True because phonebook add rejects duplicate names")
def test_phonebook_with_numbers_that_prefix_one_another_is_consistent(self):
# arrange
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "123")
# act
phonebook_is_consistent = self.phonebook.is_consistent()
# assert
self.assertEqual(1, len(self.phonebook.entries), "Should be len of 1 because duplicate name rejected")
self.assertEqual("Bob", list(self.phonebook.entries.keys())[0],
"Should be Bob because second entry Mary was rejected")
self.assertTrue(phonebook_is_consistent, "Should be True because phonebook add rejects number prefixes")
def test_phonebook_with_numbers_that_contain_one_another_is_consistent(self):
# arrange
self.phonebook.add("Mary", "123")
self.phonebook.add("Bob", "12345")
# act
phonebook_is_consistent = self.phonebook.is_consistent()
# assert
self.assertEqual(1, len(self.phonebook.entries), "Should be len of 1 because duplicate name rejected")
self.assertEqual("Mary", list(self.phonebook.entries.keys())[0],
"Should be Mary because Bob was rejected")
self.assertTrue(phonebook_is_consistent, "Should be True because phonebook add rejects number contained in others")
def test_phonebook_adds_names_and_numbers(self):
# arrange
self.phonebook.add("Sue", "12345")
# act
names = self.phonebook.get_all_names()
numbers = self.phonebook.get_all_numbers()
# assert
self.assertIn("Sue", names, "Should contain the name Sue because we just added it")
self.assertIn("12345", numbers, "Should contain the number 12345 because we just added it")
def test_add_and_lookup_entry():
pytest.skip("WIP")
phonebook = Phonebook()
phonebook.add("Bob", "123")
assert "123" == phonebook.lookup("Bob")
def test_lookup_by_name(self):
phonebook = Phonebook()
phonebook.add("Bob", "123456")
number = phonebook.lookup("Bob")
self.assertEqual("123456", number)
def test_lookup_entry_by_name(self):
phonebook = Phonebook()
phonebook.add('Bob', '12345')
self.assertEqual("12345", phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError():
phonebook = Phonebook()
with pytest.raises(KeyError):
phonebook.lookup("missing")
def test_missing_entry_raises_KeyError(self):
phonebook = Phonebook()
with self.assertRaises(KeyError):
phonebook.lookup("missing")
def test_missing_name(self):
with self.assertRaises(KeyError):\
Phonebook.lookup("missing")
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
# run after test to do clean-up
def tearDown(self):
pass
def test_lookup_entry_by_name(self):
self.phonebook.add("Bob", "12345")
self.assertEqual("12345", self.phonebook.lookup("Bob"))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
# mark a test to be skipped
# @unittest.skip("WIP")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
@unittest.skip("poor example")
def test_is_consistent(self):
"""
Example of bad testing:
- if an assertion statement fails,
rest of test is abandoned.
"""
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "12345") # identical to Bob
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add("Bob", "123") # prefix of Bob
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_several_compatible_entries_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_a_duplicate_number_is_inconsistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_numbers_that_prefix_one_another_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Mary", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
"""
If the implementation of the `add` method is incorrect,
the likelihood is that both of these `assert`s would fail.
"""
self.phonebook.add("Sue", "12345")
# assertIn - takes an iterable and check for membership
self.assertIn("Sue", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
def test_missing_entry_raises_KeyError():
phonebook = Phonebook()
with pytest.raises(KeyError):
phonebook.lookup("missing")
def test_lookup_entry():
phonebook = Phonebook()
phonebook.add("Bob", "12345")
assert "12345" == phonebook.lookup("Bob")
def test_add_and_lookup_entry():
pytest.skip("WIP")
phonebook = Phonebook()
phonebook.add("Bob", "123")
assert "123" == phonebook.lookup("Bob")
def test_lookup_by_name():
phonebook = Phonebook()
phonebook.add("Bob", "12345")
number = phonebook.lookup("Bob")
assert number == "12345"
