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
Пример #2
0
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())
Пример #3
0
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
Пример #5
0
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())
Пример #7
0
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"
Пример #8
0
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())
Пример #9
0
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
Пример #10
0
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())
Пример #11
0
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())
Пример #12
0
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())
Пример #13
0
 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())
Пример #15
0
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())
Пример #16
0
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())
Пример #17
0
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())
Пример #18
0
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())
Пример #19
0
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
Пример #20
0
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
Пример #21
0
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())
Пример #22
0
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())
Пример #23
0
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)