def test_delete_customer(self): self.assertGreater(Customer.select().count(), 0) # Delete Bob bo.delete_customer(1) self.assertEqual(0, Customer.select().count()) # Delete non-existent ID bo.delete_customer(6)
def test_delete_customer(self): ''' Tests method to delete customer from database ''' # Add customer to database self.add_customer_to_database() # Delete customer from database basic_operations.delete_customer(self.new_customer['id']) # Verify that trying to retrive the customer yields a DoesNotExist Error with self.assertRaises(DoesNotExist): Customer.get(Customer.id == self.new_customer['id'])
def test_list_active_customers(_list_active_customers): """ actives """ for customer in _list_active_customers: l.add_customer(customer[0], customer[1], customer[2], customer[3], customer[4], customer[5], customer[6], customer[7]) actives = l.list_active_customers() assert actives == 2 for customer in _list_active_customers: l.delete_customer(customer[0])
def test_delete_customer(): create_sample_database() number_of_customer2s = (cm.Customer.select().where(cm.Customer.customer_id == "2").count()) assert number_of_customer2s == 1 bo.delete_customer("2") new_number_of_customer2s = (cm.Customer.select().where(cm.Customer.customer_id == "2").count()) assert new_number_of_customer2s == 0 clear_database()
def test_delete_customer_count(): create_customer_db() number_of_customers = (cm.Customer.select().count()) assert number_of_customers == 2 bo.delete_customer("W54Hi66") current_number_of_customers = (cm.Customer.select().count()) assert current_number_of_customers == 1 drop_db()
def test_delete_customer(self): """ Verify that customers can be deleted correctly """ create_database() add_customer(1738, 'Bartholomew', 'Simpson', '742 Evergreen Terrace', 12065554682, '*****@*****.**', True, 101.50) add_customer(1739, 'Monty', 'Burns', '1 Money Street', 12065554531, '*****@*****.**', True, 1000000) delete_customer(1738) self.assertRaises(ValueError, search_customer, 1738) self.assertRaises(ValueError, delete_customer, 2000)
def test_3_delete_records(self): """Test that a record is deleted if it exists.""" self.assertEqual(basic_operations.list_active_customers(), 2) self.assertEqual(basic_operations.delete_customer(1), True) self.assertEqual(basic_operations.delete_customer(2), True) self.assertEqual(basic_operations.delete_customer(3), False) self.assertEqual(basic_operations.delete_customer(4), True) self.assertEqual(basic_operations.list_active_customers(), 0)
def test_list_active_users(_list_active_customers): """ Testing to ensure users status is set and retrieved properly. """ for customer in _list_active_customers: bo.add_customer(customer[0], customer[1], customer[2], customer[3], customer[4], customer[5], customer[6], customer[7]) assert bo.list_active_customers() == 4 for customer in _list_active_customers: bo.delete_customer(customer[0]) assert bo.list_active_customers() == 0
def test_add_customer(self): """tests add_customer function""" add_customer("C00001", "Tim", "Cook", "123 fake st, Seattle, WA", "206-123-4567", "*****@*****.**", True, 10000.00) self.assertEqual(Customer.get(Customer.customer_id == "C00001").first_name, "Tim") delete_customer('C00001')
def test_list_active_customers(set_up_connection): ''' Test that list_active customers returns the amount of those active. First get an accurate count of active customers, add a new customerthat is active Test to see that the active customers number has increased. ''' num_active = list_active_customers() add_customer(**OK_CUSTOMER_3) # bad customer should work num_active_2 = list_active_customers() delete_customer(OK_CUSTOMER_3['customer_id']) assert (num_active + 1) == num_active_2
def test_delete_customer(self): """ Test deleting customers """ # Add a user to ensure we have something to delete bo.add_customer(**TEST_USER2) # Delete the test user bo.delete_customer(TEST_USER2['customer_id']) # Search for an invalid user with self.assertRaises(DoesNotExist): Customer.get(Customer.customer_id == TEST_USER2['customer_id'])
def test_delete_customer(self): """Test the ability to delete a customer""" database_setup() add_customer(1, 'Guy', 'Dudeman', '1139 Bro Street', '800-123-4567', '*****@*****.**', True, 1000000) delete_customer(1) self.assertEqual(search_customer(1), dict()) with self.assertRaises(pw.DoesNotExist): delete_customer(1)
def test_delete_customer_missing(): create_sample_database() number_of_customers = (cm.Customer.select().count()) assert number_of_customers == 4 bo.delete_customer("9") new_number_of_customers = (cm.Customer.select().count()) assert new_number_of_customers == 4 clear_database()
def test_delete_customer(self): ''' Tests if customer gets deleted or will return 0 if not ''' add_customer(300, 'John', 'Doe', '100 Main St', '123-456-6789', '*****@*****.**', 'active', 10000) number = delete_customer(300) number2 = delete_customer(400) #add logic here to check whether its empty self.assertEqual(number, 1) #add logic here for attempting to delete non-existing ID self.assertEqual(number2, 0)
def test_update_customer_credit(self): """tests update_customer_credit function""" add_customer("C00001", "Tim", "Cook", "123 fake st, Seattle, WA", "206-123-4567", "*****@*****.**", True, 10000.00) update_customer_credit('C00001', 50000.00) self.assertEqual(Customer.get(Customer.customer_id == "C00001").credit_limit, 50000.00) delete_customer('C00001')
def test_delete_customer(): create_empty_database() bo.add_customer(**ok_customer3) customer_count = cm.Customer.select().count() bo.delete_customer(ok_customer3['customer_id']) assert cm.Customer.select().count() == customer_count - 1 # bo.delete_customer(cm.Customer.get(cm.Customer.customer_id == ok_customer3['customer_id'])) # customer_deleted = bo.search_customer(ok_customer3['customer_id']) # assert customer_deleted is None clear_database()
def test_list_active_customers(_list_active_customers): """ actives """ for customer in _list_active_customers: l.add_customer(customer[0], customer[1], customer[2], customer[3], customer[4], customer[5], customer[6], customer[7]) actives = l.list_active_customers() # Obvious bug in this test file (just like the last one). _list_active_customers contains 4 active, not 2 # assert actives == 2 assert actives == 4 for customer in _list_active_customers: l.delete_customer(customer[0])
def test_delete_customer(self): """tests delete_customer function""" add_customer("C00001", "Tim", "Cook", "123 fake st, Seattle, WA", "206-123-4567", "*****@*****.**", True, 10000.00) delete_customer('C00001') active_customers = list_active_customers() self.assertEqual(active_customers, 0)
def test_add_customer(_add_customers): """ additions """ for customer in _add_customers: l.add_customer(customer[0], customer[1], customer[2], customer[3], customer[4], customer[5], customer[6], customer[7]) added = l.search_customer(customer[0]) assert added["name"] == customer[1] assert added["lastname"] == customer[2] assert added["email"] == customer[5] assert added["phone_number"] == customer[4] for customer in _add_customers: l.delete_customer(customer[0])
def test_delete_customer(self): """ Test delete_customer() """ logging.info("test_delete_customer()") # Initial database set up set_up() # Populate customers data into the database for person in CLIENTS: add_customer(**person) # Delete customer with id = 1 delete_customer(1) self.assertDictEqual({}, search_customer(1)) # Remove data and exit database tear_down()
def test_delete_customer(self): bo.add_customer("888", "Name5", "Lastname6", "Address", "phone8", "email7", "Active", 999) expected_customer = { 'name': "Name5", 'lastname': "Lastname6", 'email_address': "email7", 'phone_number': "phone8", } found_customer = bo.search_customer("888") assert expected_customer == found_customer expected_customer = {} bo.delete_customer("888") found_customer = bo.search_customer("888") assert expected_customer == found_customer
def test_delete_customer(self): """ Test delete_customer() """ logging.info("test_delete_customer()") # Initial database set up set_up() # Populate customers data into the database for person in CLIENTS: add_customer(**person) # Delete customer with id = 1 delete_customer(1) self.assertDictEqual({}, search_customer(1)) logging.critical(f"Delete customer from database: {CLIENTS[0]['name']} {CLIENTS[0]['lastname']} (id={CLIENTS[0]['customer_id']})") # Remove data and exit database tear_down()
def test_add_customer(self): """ Test adding customers """ # Add a customer and ensure it is in the DB bo.add_customer(**TEST_USER1) test_customer = Customer.get(Customer.customer_id == TEST_USER1['customer_id']) self.assertEqual(test_customer.name, TEST_USER1['name']) # Ensure adding a non-unique customer_id fails with self.assertRaises(IntegrityError): bo.add_customer(**TEST_USER1) # Delete the test user bo.delete_customer(TEST_USER1['customer_id'])
def test_delete_customer_fail(self): """ testing deleting a customer fail """ setup() bo.add_customer('1150', 'Mark', 'Rollins', '46 Hawthorne Lane, Great Falls, MT 59404', '406-604-4060', '*****@*****.**', True, 575.00) bo.add_customer('3030', 'Joseph', 'Tribbiani', '43 Foster Avenue, New York, NY 10003', '212-013-7564', '*****@*****.**', False, 1000.00) with self.assertRaises(pw.DoesNotExist): bo.delete_customer('5102')
def test_delete_customers(self): """ Tests the delete customer functionality of basic_operations.py :return: none """ # Prove Customer 1 exists return_dict = search_customer(1) self.assertIsNotNone(return_dict) # Delete Customer 1 delete_customer(1) return_dict2 = search_customer(1) self.assertEqual(0, len(return_dict2))
def test_delete_customer(self): '''Tests the delete_customer function.''' reset_db() basic_operations.add_customers(TEST_LIST) # Testing the delete_customer function basic_operations.delete_customer(123) self.assertEqual( basic_operations.search_customer(101)['f_name'], TEST_LIST[0][1]) self.assertEqual( basic_operations.search_customer(53)['f_name'], TEST_LIST[2][1]) self.assertEqual(basic_operations.search_customer(123), {}) # Testing the delete_customer not in the database with self.assertRaises(ValueError): basic_operations.delete_customer(55)
def test_integration(self): """ Test the following all together -add new customers to the database -search customers in the database -delete existing customers from the database -update customers credit -list the number of active customers in the database """ # add a couple users all active ba.add_customer(1, 'Fran', 'K', '100 New York Ave, NYC, 98109', '248-331-6243', '*****@*****.**', 'Active', 1000) ba.add_customer(2, 'Emily', 'H', '200 New York Ave, MA, 98109', '248-331-6243', '*****@*****.**', 'Active', 2000) ba.add_customer(3, 'John', 'H', '300 New York Ave, MA, 98109', '248-331-6243', '*****@*****.**', 'Active', 3000) # check the credit limit for an added user customer_1 = Customer.get(Customer.customer_id == 1) self.assertEqual(customer_1.credit_limit, 1000) # update the credit limit for a user and search for that user customer_3 = ba.search_customer(3) self.assertEqual(customer_3['credit_limit'], 3000) ba.update_customer_credit(3, 3333) customer_3 = ba.search_customer(3) self.assertEqual(customer_3['credit_limit'], 3333) # add a couple more users some active some not ba.add_customer(4, 'John', 'H', '300 New York Ave, MA, 98109', '248-331-6243', '*****@*****.**', 'Inative', 4000) ba.add_customer(5, 'John', 'H', '300 New York Ave, MA, 98109', '248-331-6243', '*****@*****.**', 'Inactive', 5000) ba.add_customer(6, 'John', 'H', '300 New York Ave, MA, 98109', '248-331-6243', '*****@*****.**', 'Active', 6000) # add an existing customer, should throw out a warning ba.add_customer(3, 'John', 'H', '300 New York Ave, MA, 98109', '248-331-6243', '*****@*****.**', 'Active', 3000) # check how many active users we have active_users = ba.list_active_customers() self.assertEqual(active_users, 4) # delete all our active users ba.delete_customer(1) ba.delete_customer(2) ba.delete_customer(3) ba.delete_customer(6) # ensure we don't have any active users left active_users_2 = ba.list_active_customers() self.assertEqual(active_users_2, 0)
def test_integration(self): """Test functionality of entire application.""" self.assertIsInstance(main.CUSTOMER_DB, SqliteDatabase) reset_database() test_db = [ (1, 'John', 'Smith', '123 Main Street', '2065551234', '*****@*****.**', 'Active', 10000), (2, 'Jane', 'Doe', '1000 Market Street', '2065555678', '*****@*****.**', 'Active', 5000), (3, 'Alice', 'Wonderland', '200 Cherry Street', '2065551357', '*****@*****.**', 'Active', 1000), (3, 'Mark', 'Allen', '555 Columbia Avenue', '2065552468', '*****@*****.**', 'Active', 8500) ] main.add_customer(*test_db[0]) main.add_customer(*test_db[1]) main.add_customer(*test_db[2]) customer_1 = Customer.get(Customer.customer_id == 1) customer_2 = Customer.get(Customer.customer_id == 2) customer_3 = Customer.get(Customer.customer_id == 3) self.assertEqual(test_db[0][1], customer_1.first_name) self.assertEqual(test_db[1][2], customer_2.last_name) self.assertEqual(test_db[2][3], customer_3.home_address) with self.assertRaises(ValueError): main.add_customer(*test_db[3]) search = main.search_customer(1) expected = { 'First Name': 'John', 'Last Name': 'Smith', 'Email Address': '*****@*****.**', 'Phone Number': '2065551234' } self.assertEqual(search, expected) self.assertEqual(main.search_customer(4), {}) main.delete_customer(2) search = main.delete_customer(2) self.assertEqual(search, None) main.update_customer_credit(1, 12000) customer = Customer.get(Customer.customer_id == 1) self.assertEqual(12000, customer.credit_limit) update = main.update_customer_credit(4, 2000) self.assertEqual(update, None)
def test_delete_customer(self): """ test delete_customer function """ logger.info('Test delete_customer') op.delete_customer('4') names = [] for customer in db.Customer: names.append(customer.name) self.assertTrue('Enrico Fermi' not in names) # Test customer not found exception op.delete_customer('40') db.database.close()
def test_delete_customer(self): """ test delete_customer function """ op.delete_customer('4') names = [] for customer in db.Customer.select(): names.append(customer.name) self.assertTrue('Enrico Fermi' not in names) # Test customer not found exception op.delete_customer('40') self.assertRaises(peewee.DoesNotExist) db.database.close()