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 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): 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): # 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 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 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 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): # 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): # 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): 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): # 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())
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): # 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): #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) -> 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 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): 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())
class PhoneBookTest(unittest.TestCase): def setUp(self) -> None: self.phonebook = PhoneBook() def tearDown(self) -> None: 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") # Skipping a testcase @unittest.skip("WIP") def test_empty_phonebook_is_consistent(self): #phonebook = PhoneBook() self.assertTrue(self.phonebook.is_consistent())
def test_empty_phonebook_is_consistent(self): phonebook = PhoneBook() self.assertTrue(phonebook.is_consistent())