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_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())
def test_phonebook_gives_access_to_names_and_numbers():
phonebook = Phonebook()
phonebook.add('Alice', '12345')
phonebook.add("Bob", "123")
assert set(phonebook.names()) == {'Alice', 'Bob'}
assert '12345' in phonebook.numbers()
assert '123' in phonebook.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"))
def run(self):
# This block was moved from server file to try and make it handled here instead
phonebook = Phonebook() # called from the phonebook.py
filename = "AddressBook.txt"
while True:
try:
file = open(filename, "r") # opens in read only
contents = file.readlines()
for line in contents:
information = line.split(
" "
) # This splits each line of the text file by spaces
phonebook.add(information[0], information[1])
break
except ReferenceError:
print("File not found.")
filename = input(
"Please enter the name of the phonebook to be loaded: ")
# End of test block
# create string of phonebook to send to client on connection
start_book = phonebook.__str__()
encrypt(start_book)
self.client.send(bytes(encrypt(start_book.encode()))
) # encrypts start_book for delivery to client
self.client.send(bytes("Welcome to the phone book application!", ))
while True:
message = decode(self.client.recv(BUFSIZE), )
decrypt(message) # decrypts incoming message
if not message:
print("Client disconnected")
self.client.close()
break
else:
request = message.split()
command = request[0]
if command == "FIND":
number = self.phonebook.get(request[1])
if not number:
reply = "Number not found."
else:
reply = "The number is " + number
else:
self.phonebook.add(request[1], request[2])
# write it to the file:
filename = "AddressBook.txt"
phonebook_file = open(filename, "a") # opens in read only
phonebook_file.write(request[1] + " " + request[2] + "\n")
phonebook_file.close()
reply = "Name and number added to phone book and file.\nPress Update to update the table."
self.client.send(bytes(reply, ))
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):
# 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):
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_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 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 PhonebookTest(unittest.TestCase):
def setUp(self):
self.phonebook = Phonebook()
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(self):
phonebook = Phonebook()
with self.assertRaises(KeyError):
phonebook.lookup("missing")
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.assertTrue(self.phonebook.is_consistent())
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):
# 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_lookop_entry():
phonebook = Phonebook()
phonebook.add("Bob", "123")
assert "123" == phonebook.lookup("Bob")
def test_phonebook_gives_access_to_names_and_numbers(phonebook):
phonebook = Phonebook()
phonebook.add("Alice", "12345")
assert "Alice" in phonebook.names()
assert "12345" in phonebook.numbers()
class PhoneBookTest(unittest.TestCase):
def setUp(self) -> None:
self.phonebook = Phonebook()
def test_lookup_by_name(self):
self.phonebook.add("Bob", "12345")
number = phonebook.lookup("Bob")
self.assertEqual("12345", number)
def test_missing_name(self):
with self.assertRaises(KeyError):\
Phonebook.lookup("missing")
def test_empty_phonebook_is_consistent(self):
phonebook = Phonebook()
self.assertTrue((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_inconsistent_with_duplicate_entries(self):
self.phonebook.add("Bob", "12345")
self.phonebook.add("Sue", "12345")
self.assertFalse((self.phonebook.is_consistent()))
def test_is_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_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())
def test_lookup_entry():
phonebook = Phonebook()
phonebook.add("Bob", "12345")
assert "12345" == phonebook.lookup("Bob")
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())
def test_lookup_by_name():
phonebook = Phonebook()
phonebook.add("Bob", "12345")
number = phonebook.lookup("Bob")
assert number == "12345"
def test_phonebook_gives_access_to_names_and_numbers():
phonebook = Phonebook()
phonebook.add("Alice", "12345")
phonebook.add("Bob", "123")
assert set(phonebook.names()) == {"Alice", "Bob"}
assert "12345" in phonebook.numbers()
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())
def test_lookup_by_name(self):
phonebook = Phonebook()
phonebook.add("Bob", "123456")
number = phonebook.lookup("Bob")
self.assertEqual("123456", number)
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) -> 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())
def test_lookup_entry_by_name(self):
phonebook = Phonebook()
phonebook.add('Bob', '12345')
self.assertEqual("12345", phonebook.lookup("Bob"))
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_add_and_lookup_entry():
pytest.skip("WIP")
phonebook = Phonebook()
phonebook.add("Bob", "123")
assert "123" == phonebook.lookup("Bob")
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_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):
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()
#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())
def test_phonebook_gives_access_to_names_and_numbers():
phonebook = Phonebook()
phonebook.add("Alice", "12345")
phonebook.add("Bob", "123")
assert set(phonebook.names()) == {"Alice", "Bob"}
assert "12345" in phonebook.numbers()
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):
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):
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())
def test_add_and_lookup_entry():
pytest.skip("WIP")
phonebook = Phonebook()
phonebook.add("Bob", "123")
assert "123" == phonebook.lookup("Bob")
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())
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_a_number_that_prefixes_another_is_inconsistent(self):
self.phonebook.add('Bob', '12345')
self.phonebook.add('Mary', '123')
self.assertFalse(self.phonebook.is_consistent())
@unittest.skip('WIP')
def test_phonebook_adds_names(self):
self.phonebook.add('Sue', '12345')
self.assertIn('Sue', phonebook.get_names())
@unittest.skip('WIP')
def test_phonebook_adds_numbers(self):
self.phonebook.add('Sue', '12345')
self.assertIn('12345', 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()
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):
def setUp(self):
self.phonebook = Phonebook()
def test_lookup_entry_by_name(self):
self.phonebook.add('Bob', '12345')
self.assertEqual('12345', self.phonebook.lookup_entry_by_name('Bob'))
def test_missing_entry_raises_KeyError(self):
with self.assertRaises(KeyError):
self.phonebook.lookup_entry_by_name('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_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_numbers())
