class PhoneBookTest(unittest.TestCase):
def setUp(self) -> None: # Super class
self.phonebook = PhoneBook()
# def tearDown(self) -> None: # With setUp we need use tearDown - this using to release from setUp test value.
# pass
# Because this setUp have everything in the memory we dosen't needed this.
def test_lookup_by_name(self):
# phonebook = PhoneBook()
self.phonebook.add("Bob", '12345') # Change to self.phonebook
number = self.phonebook.lookup("Bob") # Change to self.phonebook
self.assertEqual("12345", number)
def test_missing_name(self):
# phonebook = PhoneBook()
with self.assertRaises(KeyError):
self.phonebook.lookup("missing") # Change to self.phonebook
# @unittest.skip("WIP") # This features working to skip test after this command
def test_empty_phonebook_is_consisten(self):
# phonebook = PhoneBook() # We have 3 duplicates this line
self.assertTrue(
self.phonebook.is_consistent()) # Change to self.phonebook
class PhoneBookTest(unittest.TestCase):
def setUp(self):
self.phonebook = PhoneBook()
# This method is great to set something like write in files or database
# def tearDown(self):
# pass
def test_lookup_by_name(self):
self.phonebook.add('Luis', '12345')
number = self.phonebook.lookup('Luis')
self.assertEqual('12345', number)
def test_missing_name(self):
with self.assertRaises(KeyError):
self.phonebook.lookup('missing')
# @unittest.skip("WIP") -> to skip test
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent_with_different_entries(self):
self.phonebook.add('Luis', '12345')
self.phonebook.add('Vilella', '0012345')
self.assertTrue(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_entries(self):
self.phonebook.add('Luis', '12345')
self.phonebook.add('Felipe', '12345')
self.assertFalse(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_prefix(self):
self.phonebook.add('Luis', '12345')
self.phonebook.add('Felipe', '123')
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", "12345")
number = self.phonebook.lookup("Bob")
self.assertEqual("12345", number)
def test_missing_name(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_is_consistent_with_different_entries(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Anna", "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())
class PhoneBookTest(unittest.TestCase):
def setUp(self) -> None:
self.phonebook = PhoneBook()
def test_lookup_by_name(self): # Test Case name
self.phonebook.add("Bob", '12345') # Arrange
number = self.phonebook.lookup("Bob") # Act
self.assertEqual("12345", number) # Assert
def test_missing_name(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consisten(self):
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent(self): # Test Case Name
self.phonebook.add("Bob", '12345') # Act
self.assertTrue(self.phonebook.is_consistent()) # Assert
self.phonebook.add("Anna", '012345') # Act
self.assertTrue(self.phonebook.is_consistent()) # Assert
self.phonebook.add("Sue", '12345') # identical to Bob # Act
self.assertFalse(self.phonebook.is_consistent()) # Assert
self.phonebook.add("Sue", '123') # prefix of Bob # Act
self.assertFalse(self.phonebook.is_consistent()) # Assert
class TestPhoneBook(TestCase):
def setUp(self):
# Begining of every test
self.phonebook = PhoneBook()
def tearDown(self):
# End of every test
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_key_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_phonebook_with_normal_enteries_is_consistent(self):
self.phonebook.add("Bob", "123456")
self.phonebook.add("Marry", "986780")
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_enteries_is_not_consistent(self):
self.phonebook.add("Bob", "123456")
self.phonebook.add("Marry", "123456")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_with_similar_prefix_is_not_consistent(self):
self.phonebook.add("Bob", "123456")
self.phonebook.add("Marry", "123")
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', '12345')
number = self.phonebook.lookup('Bob')
self.assertEqual('12345', number)
def test_missing_name(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('Anna', '012345')
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent_with_duplicate_entries(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Sue', '12345')
self.assertFalse(self.phonebook.is_consistent())
def test_is_consistent_with_duplicate_prefix(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Sue', '123')
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
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) -> None:
self.phonebook = PhoneBook()
def test_lookup_by_name(self):
self.phonebook.add("Bob", "12345")
number = self.phonebook.lookup("Bob")
self.assertEqual("12345", number)
def test_missing_name(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
# @unittest.skip("WIP") # Work In Progress
def test_empty_phonebook_is_consistent(self):
phonebook = PhoneBook()
self.assertTrue(phonebook.is_consistent())
def test_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Anna", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "12345")
self.assertTrue(self.phonebook.is_consistent()
self.phonebook.add("Sue", "123")
self.assertTrue(self.phonebook.is_consistent())
# Run in terminal using command "python -m unittest"
class TestPhoneBook(unittest.TestCase):
def setUp(self):
self.phonebook = PhoneBook()
def test_lookup_entry_by_name(self):
self.phonebook.add('Person', '112233112233')
self.assertEqual('112233112233', self.phonebook.lookup('Person'))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup('Unknown Phone Number')
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_normal_entries_are_consistent(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Mary', '012345')
self.assertTrue(self.phonebook.is_consistent())
def test_phonebook_with_duplicate_entries_are_inconsistent(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Mary', '12345')
self.assertFalse(self.phonebook.is_consistent())
class PhoneBookTest(unittest.TestCase):
# Test fixture
def setUp(self):
self.phonebook = PhoneBook()
# Test fixture
# Tear down resources that were initialized in setUp
def tearDown(self):
pass
# Test case
def test_lookup_by_name(self): # Test case name
self.phonebook.add("Bob", "12345") # Arrange
number = self.phonebook.lookup("Bob") # Act
self.assertEqual("12345", number) # assert
def test_missing_name(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_is_consistent_with_empty_phonebook(self):
self.assertTrue(self.phonebook.is_consistent())
# Not good test case design. We'll miss a lot of the tests if there is a failure early in the test.
# Testing stops when an exception is encountered
# Name of test case isn't specific
@unittest.skip("Bad test case design.")
def test_is_consistent(self):
self.phonebook.add("Bob", "12345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Anna", "012345")
self.assertTrue(self.phonebook.is_consistent())
self.phonebook.add("Sue", "12345") # identitcal to Bob
self.assertFalse(self.phonebook.is_consistent())
self.phonebook.add("Sue", "123") # prefix of Bob
self.assertFalse(self.phonebook.is_consistent())
def test_is_consistent_with_different_entries(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Anna", "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())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Sue", "123343") # Act
self.assertIn(
"Sue", self.phonebook.get_names()) # assert made on the same Act
self.assertIn(
"123343",
self.phonebook.get_numbers()) # assert made on the same Act
class PhoneBookTest(unittest.TestCase):
# setUp method is inherited from TestCase super class and called BEFORE each test method
def setUp(self) -> None:
# construct a new phonebook instance before each test case executes
self.phonebook = PhoneBook()
# tearDown method is called AFTER each test method
# release resources reserved in setUp method OR during test
# not needed in memory but needed for CI testing of database connection or filesystems
# def tearDown(self) -> None:
# pass
def test_lookup_by_name(self):
# construct a new phonebook class instance
# phonebook = PhoneBook()
# insert new name and number into phonebook
self.phonebook.add("Bob", "12345")
# lookup same name I just added
number = self.phonebook.lookup("Bob")
# check that the name i've looked up is associated to the number
# first value is value were checking against, second argument is actual value from unit test
self.assertEqual("12345", number)
def test_missing_name(self):
# assertRaises ensures everything in with context manager will throw a KeyError exception
# KeyError is raised whenever a dictionary object is requested and the key is not present
# In our case the name Giles was not present in the phonbook
with self.assertRaises(KeyError):
self.phonebook.lookup("Giles")
# annotation to skip a unittest
# @unittest.skip("WIP")
def test_empty_phonebook_is_consistent(self):
# is_consistent method should return true for empty phonebook
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent_with_different_entries(self):
# Arrange step to add entries
# Act step where we check for consistency
# assert whether it is or not
self.phonebook.add("Bob", "12345")
self.phonebook.add("Anna", "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())
class PhoneBookTest(unittest.TestCase):
def setUp(self):
self.phonebook = PhoneBook()
def test_lookup_by_name(self):
self.phonebook.add("Bob", "12345")
number = self.phonebook.lookup("Bob")
self.assertEqual("12345", number)
def test_missing_name(self):
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
# poor design - have clear arrange, act ,assert
# def test_is_consistent(self):
# self.phonebook.add("Bob", "12345")
# self.assertTrue(self.phonebook.is_consistent())
# self.phonebook.add("Anna", "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_is_consistent_with_different_entries(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Anna", "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("Sue", "123")
self.phonebook.add("Bob", "12345")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Sue", "123343")
self.assertIn("Sue", self.phonebook.get_names())
self.assertIn("123343", self.phonebook.get_numbers())
class PhoneBookTest(unittest.TestCase):
# before every test
def setUp(self) -> None:
self.phonebook = PhoneBook()
# after every test - good for releasesnio
def tearDown(self) -> None:
pass
# all cases starts with test_
def test_lookup_by_name(self):
#phonebook = PhoneBook()
self.phonebook.add("David", "12345")
# number = phonebook.lookup("David")
number = self.phonebook.lookup("David")
# assertion case
self.assertEqual("12345", number)
def test_missing_name(self):
phonebook = PhoneBook()
# phonebook without args -> passes because the phonebook it is an dictionary
with self.assertRaises(KeyError):
self.phonebook.lookup("missing")
@unittest.skip("WIP") # skip WIP - Work in Progress
def test_empty_phonebook_is_consistent(self):
# phonebook = PhoneBook()
self.assertTrue(self.phonebook.is_consistent())
# solution to avoid bad design test (arrange, act, assert)
def test_is_consistent_with_different_entries(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Anna", "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())
def test_lookup_by_name(self):
phonebook = PhoneBook(
) # Click alt+enter and choose a create new class
phonebook.add(
"Bob", '12345'
) # PyCharm is highlight a word which needed to define -> click right ande choose 'Add method add() to class PhoneBook'
number = phonebook.lookup(
"Bob") # Click 'Add method lookup() to class PhoneBook'
self.assertEqual("12345", number)
class PhoneBookTest(unittest.TestCase):
# Runs before EVERY test
def setUp(self) -> None:
self.phonebook = PhoneBook()
# Runs after EVERY test
def tearDown(self) -> None:
pass
def test_lookup_by_name(self):
self.phonebook.add("Bob", "12345")
number = self.phonebook.lookup("Bob")
self.assertEqual("12345", number)
def test_missing_name_raises_error(self):
# This will test that any of the code below the "with" stmt throws a KeyError
with self.assertRaises(KeyError):
self.phonebook.lookup("fake number")
def test_is_consistent_when_empty(self):
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent_when_all_nums_different(self):
self.phonebook.add("Bob", "1234567")
self.phonebook.add("Sue", "6171830")
self.assertTrue(self.phonebook.is_consistent())
def test_is_NOT_consistent_when_duplicates(self):
self.phonebook.add("Bob", "1234567")
self.phonebook.add("Sue", "1234567")
self.assertFalse(self.phonebook.is_consistent())
def test_is_NOT_consistent_when_duplicate_prefixes(self):
self.phonebook.add("Bob", "1234567")
self.phonebook.add("Sue", "123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Sue", "12345")
self.phonebook.add("Bob", "1234567")
self.assertIn("Sue", self.phonebook.get_names())
self.assertIn("12345", self.phonebook.get_numbers())
self.assertIn("Bob", self.phonebook.get_names())
self.assertIn("1234567", self.phonebook.get_numbers())
class PhoneBookTest(unittest.TestCase):
def setUp(self):
self.phonebook = PhoneBook()
def tearDown(self):
pass
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_consistant())
class PhoneBookTest(unittest.TestCase):
#Arrang -Act-Assert
def setUp(self):
self.phonebook =PhoneBook()
def tearDown(self):
pass
def test_lookup_by_name(self):
#phonebook = PhoneBook()
self.phonebook.add("bob","12345")
number= self.phonebook.lookup("bob")
self.assertEqual("12345",number)
def test_missing_name(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_is_consistent_with_different_entries(self):
self.phonebook.add("Bob","12345")
self.phonebook.add("Anna","012345")
self.assertTrue(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_entries(self):
self.phonebook.add("Bob","12345")
self.phonebook.add("Bob","12345")
self.assertTrue(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_prefix(self):
self.phonebook.add("Bob","1234")
self.phonebook.add("Sue","123")
self.assertTrue(self.phonebook.is_consistent())
def tets_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Sue","123343")
self.assertIn("Sue",self.phonebook.get_names())
self.aseertIn("123343",self.phonebook.get_numbers())
class PhoneBookTest(unittest.TestCase):
def setUp(self) -> None:#called before every test method
self.phonebook =PhoneBook()
def tearDown(self) -> None:#called after every test method
pass
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("Bob")
# @unittest.skip("WIP")
def test_empty_phone_book_isconsistent(self):
self.phonebook = PhoneBook()
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent_with_different_entries(self):
self.phonebook.add("Bob",'1234')
self.phonebook.add("Anna",'01234')
self.assertTrue(self.phonebook.is_consistent)
def test_inconsistent_with_duplicate_entries(self):
self.phonebook.add("Bob",'1234')
self.phonebook.add("sue","1234")
self.assertFalse(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_prefix(self):
self.phonebook.add("sue","123")
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_adds_name_and_number(self):
self.phonebook.add("Bob","12345")
self.assertIn("Bob",self.phonebook.get_name())
self.assertIn("12345", self.phonebook.get_number())
class PhoneBookTest(unittest.TestCase):
def setUp(self) -> None:
"""
The setUp method is called each time a test case is executed.
:return: PhoneBook Class.
"""
self.phonebook = PhoneBook()
def tearDown(self) -> None:
"""
This class is used to release the resource which are used by the testcases like in the case of using some files for testing or maybe the use of some database or so. As of now in this code its not required and hence it is passed.
"""
pass
def test_lookup_by_name(self):
self.phonebook.add("Arjun", "12345")
number = self.phonebook.lookup("Arjun")
self.assertEqual("12345", number)
def test_missing_name(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", "123454")
self.phonebook.add("Anna", "012345")
self.assertTrue(self.phonebook.is_consistent())
def test_inconsistent_with_duplicate_entries(self):
self.phonebook.add("bob", "123454")
self.phonebook.add("Anna", "123454")
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())
class PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = PhoneBook()
def tearDown(self):
pass
def test_lookup_by_name(self):
self.phonebook.add('bob', "12345")
number = self.phonebook.lookup('bob')
self.assertEqual(number, '12345')
def test_lookup_missing_name(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('blue', '23456')
self.assertTrue(self.phonebook.is_consistent())
def test_is_consistent_with_duplicate_entries(self):
self.phonebook.add('bob', '12345')
self.phonebook.add('blue', '12345')
self.assertFalse(self.phonebook.is_consistent())
def test_is_consistent_with_duplicate_prefix(self):
self.phonebook.add('bob', '12345')
self.phonebook.add('blue', '1234')
self.assertFalse(self.phonebook.is_consistent())
@unittest.SkipTest
def test_skip_test_example(self):
"""This testcase is skipped because of decorator"""
pass
class PhoneBookTest(unittest.TestCase):
def setUp(self) -> None:
self.phonebook = PhoneBook()
def test_lookup_by_name(self):
self.phonebook.add("Bob", "12345")
number = self.phonebook.lookup("Bob")
self.assertEqual("12345", 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("Anna", "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())
# Unusually, to put two cases assertion in one test case!
def test_phonebook_adds_names_and_numbers(self):
self.phonebook.add("Sue", '123343')
self.assertIn("Sue", self.phonebook.get_names())
self.assertIn("123343", self.phonebook.get_numbers())
# python -m unittest unit test in command line
class PhoneBookTest(unittest.TestCase):
def setUp(self):
self.phonebook = PhoneBook()
def test_lookup_by_name(self):
self.phonebook.add('Bob','12345')
number = self.phonebook.lookup('Bob')
self.assertEqual(number,'12345')
def test_missing_name_raises_error(self):
with self.assertRaises(KeyError):
self.phonebook.lookup('missing_name')
# @unittest.skip('WIP')
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('Anna','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('Sue','123')
self.phonebook.add('Bob','12345')
self.assertFalse(self.phonebook.is_consistent())
def test_phonebook_add_names_and_numbers(self):
self.phonebook.add('Sue','12345')
self.assertIn('Sue',self.phonebook.get_names())
self.assertIn('123343',self.phonebook.get_numbers())
class PhoneBookTest(unittest.TestCase):
# This is run every time a test is set up
def setUp(self) -> None:
# this will be now created for each test cases, so no need to create instance in every test function
# rather use self.phonebook
self.phonebook = PhoneBook()
def tearDown(self) -> None:
pass
def test_lookup_by_name(self):
self.phonebook.add("Aftab", 12345)
number = self.phonebook.lookup("Aftab")
self.assertEqual(number, 12345)
def test_empty_phonebook_is_consistent(self):
self.assertTrue(self.phonebook.is_consistent())
def test_add_and_lookup_entry():
phonebook = PhoneBook()
phonebook.add("Bob", "12345")
assert "12345" == phonebook.lookup("Bob")
def test_missing_key_raises_error(phonebook):
phonebook = PhoneBook()
with pytest.raises(KeyError):
phonebook.lookup('missing')
def test_missing_name(
self
): # What happend if we have name which doesn;t exist in phonebook
phonebook = PhoneBook()
with self.assertRaises(KeyError):
phonebook.lookup("missing")
def test_lookup_by_name(self):
phonebook = PhoneBook()
phonebook.add("Bob", '12345')
number = phonebook.lookup("Bob")
self.assertEqual("12345", number)
