def test_integration(self):
"""Testing integration of the modules"""
bo.add_customer('100', 'Peter', 'Parker',
'135 W. 50th Street, New York City, NY 10011',
'212-576-4000', '*****@*****.**', True, 1000)
bo.add_customer('200', 'Iron', 'Man',
'17801 International Blvd, Seattle, WA 98101',
'206-787-5388', '*****@*****.**', True, 5000)
bo.update_customer_credit('200', 9000)
a_customer = cm.Customer.get(cm.Customer.customer_id == '200')
self.assertEqual(a_customer.credit_limit, 9000)
bo.add_customer('300', 'Ramkumar', 'Rajanbabu',
'7525 166th Ave NE, Redmond, WA 98052', '425-556-2900',
'*****@*****.**', False, 7078)
self.assertEqual(bo.list_active_customers(), 2)
a_customer_2 = bo.search_customer('100')
a_customer_2_dict = {
'first_name': 'Peter',
'last_name': 'Parker',
'email_address': '*****@*****.**',
'phone_number': '212-576-4000'
}
self.assertEqual(a_customer_2, a_customer_2_dict)
bo.delete_customer('100')
self.assertEqual(bo.search_customer('100'), {})
def test_search_customer(_search_customers):
""" search """
for customer in _search_customers[0]:
l.add_customer(customer[0],
customer[1],
customer[2],
customer[3],
customer[4],
customer[5],
customer[6],
customer[7]
)
result = l.search_customer(_search_customers[1][1])
assert result == {}
result = l.search_customer(_search_customers[1][0])
assert result["name"] == _search_customers[0][1][1]
assert result["lastname"] == _search_customers[0][1][2]
assert result["email"] == _search_customers[0][1][5]
assert result["phone_number"] == _search_customers[0][1][4]
# delete the customer ids, not sets
for customer in _search_customers[0]:
l.delete_customer(customer[0])
def test_search_customer(self):
"""tests search"""
TEST_DB.bind(MODELS, bind_refs=False, bind_backrefs=False)
TEST_DB.create_tables(MODELS)
add_customer(*CUSTOMERS[0])
test_c2 = search_customer('00001')
self.assertEqual(
{
'Customer ID': '00001',
'First Name': 'Dorothy',
'Last Name': 'Zbornak',
'Home Address': 'Miami',
'Phone Number': '5551234567',
'Email Address': '*****@*****.**',
'Status': 'Active',
'Credit Limit': 1000
}, test_c2)
add_customer(*CUSTOMERS[3])
test_c2 = search_customer('00004')
self.assertEqual(
{
'Customer ID': '00004',
'First Name': 'Rose',
'Last Name': 'Nylund',
'Home Address': 'Miami',
'Phone Number': '5551234570',
'Email Address': '*****@*****.**',
'Status': 'Inactive',
'Credit Limit': 2000
}, test_c2)
search_customer('00009')
self.assertRaises(Exception)
def test_integration(self):
"""Test the entire application functionality."""
self.assertIsInstance(basic_operations.CUSTOMER_DB,
peewee.SqliteDatabase)
cust_1 = {
'customer_id': 1,
'first_name': 'George',
'last_name': 'Washington',
'home_address': '4 Bowling Green',
'phone_number': 2125555555,
'email_address': '*****@*****.**',
'is_active': False,
'credit_limit': 5.00
}
cust_2 = {
'customer_id': 2,
'first_name': 'John',
'last_name': 'Adams',
'home_address': '524-30 Market St',
'phone_number': 2675551212,
'email_address': '*****@*****.**',
'is_active': False,
'credit_limit': 100.00
}
cust_3 = {
'customer_id': 3,
'first_name': 'Thoams',
'last_name': 'Jefferson',
'home_address': '1600 Pennsylvania Ave',
'phone_number': 2029999999,
'email_address': '*****@*****.**',
'is_active': True,
'credit_limit': 10000.00
}
self.assertEqual(basic_operations.list_active_customers(), 0)
self.assertEqual(basic_operations.add_customer(**cust_1), True)
self.assertEqual(basic_operations.add_customer(**cust_2), True)
self.assertEqual(basic_operations.add_customer(**cust_3), True)
self.assertEqual(basic_operations.list_active_customers(), 1)
self.assertEqual(basic_operations.update_customer_credit(1, 10000),
True)
self.assertEqual(basic_operations.update_customer_credit(3, 15000),
True)
self.assertEqual(
basic_operations.search_customer(1)['credit_limit'], 10000)
self.assertEqual(
basic_operations.search_customer(3)['credit_limit'], 15000)
self.assertEqual(basic_operations.delete_customer(1), True)
self.assertEqual(basic_operations.delete_customer(2), True)
self.assertEqual(basic_operations.delete_customer(3), True)
self.assertEqual(basic_operations.list_active_customers(), 0)
def test_whole_system(self):
'''make sure the database is exist'''
self.assertIsNotNone(basic_operations.DATABASE)
'''make sure the Customer table exist'''
self.assertIsNotNone(basic_operations.Customer)
'''start with an empty database'''
basic_operations.delete_all_customers()
'''add a new customer'''
basic_operations.add_customer(1, 'Michael', 'Jordan',
'3421 S Bull Street \
North Carolina', '203-231-3223', '*****@*****.**', 'Active', 212109)
customer = basic_operations.search_customer(1)
self.assertDictEqual(gold, customer)
'''add another customer'''
basic_operations.add_customer(2, 'Shawn', 'Kemp', '3423 Green Lake \
Street Seattle WA', '206-240-4023', '*****@*****.**', 'Active', 212109)
count = basic_operations.list_active_customers()
self.assertEqual(2, count)
'''update customer 1 credit'''
basic_operations.update_customer_credit(1, 200)
customer = basic_operations.search_customer(1)
self.assertEqual(200, customer['credit_limit'])
'''update non-exist customer and catch the error'''
try:
basic_operations.update_customer_credit(10, 300)
except ValueError:
self.assertRaises(ValueError)
'''delete customer 1'''
basic_operations.delete_customer(1)
customer = basic_operations.search_customer(1)
self.assertIsNone(customer)
def test_integration(self):
# Add customers 2 and 3
c2, c3 = next(self.def_tuples), next(self.def_tuples)
# alice = self.definitions['Alice']
# bob2 = self.definitions['Bob2']
bo.add_customer(*c2)
bo.add_customer(*c3)
# bo.add_customer(alice['id'], alice['name'], alice['last_name'], alice['address'],
# alice['phone'], alice['email'], alice['status'], alice['credit_limit'])
# bo.add_customer(bob2['id'], bob2['name'], bob2['last_name'], bob2['address'],
# bob2['phone'], bob2['email'], bob2['status'], bob2['credit_limit'])
# Assert that all 3 are in the DB
self.assertEqual(3, Customer.select().count())
# Modify c2's credit limit
bo.update_customer_credit(c2[0], 12.32)
self.assertEqual(12.32, float(Customer.get(Customer.name == c2[1]).credit_limit))
# Search for c3
res = bo.search_customer(c3[0])
for k in ['name', 'last_name', 'email', 'phone']:
self.assertEqual(c3[self.labels.index(k)], res[k])
# Delete c3
bo.delete_customer(c3[0])
res = bo.search_customer(c3[0])
self.assertEqual({}, res)
def test_delete_customers(self):
""" Tests function to delete multiple customers """
setup_db()
to_delete_list = [2, 3]
delete_customers(to_delete_list)
self.assertEqual(search_customer(2), {})
self.assertEqual(search_customer(3), {})
def test_delete_customer(self):
create_empty_db()
customer_1 = {
'customer_id': '0000',
'name': 'Victor',
'last_name': 'Medina',
'home_address': '809 Newton ave',
'phone_number': '5165996074',
'email_address': '*****@*****.**',
'status': True,
'credit_limit': 800
}
customer_2 = {
'customer_id': '9860',
'name': 'Roger',
'last_name': 'Fortune',
'home_address': '676 Grand ave',
'phone_number': '5165946824',
'email_address': '*****@*****.**',
'status': True,
'credit_limit': 750
}
add_customer(**customer_1)
add_customer(**customer_2)
delete_customer(customer_1['customer_id'])
search_customer(customer_1['customer_id'])
self.assertEqual({}, search_customer(customer_1['customer_id']))
def test_basic_operations(self):
"""" Integration test for the basic operations """
DATABASE.drop_tables([Customer])
DATABASE.close()
DATABASE.create_tables([Customer])
DATABASE.close()
# Add customers to the db
add_customers(self.test_customer)
cust_found = search_customer(2)
self.assertEqual(self.test_customer[1][5], cust_found.get("email"))
update_customer_credit(1, 500.00)
self.assertEqual(500.00, Customer.get_by_id(1).credit_limit)
# Find out how many customers are active
active_cust = list_active_customers()
self.assertEqual(2, active_cust)
# Delete a customer then try to find it
delete_customer(2)
self.assertDictEqual({}, search_customer(2))
# Find out how many customers are active and list their names
self.assertEqual(1, list_active_customers())
self.assertEqual(["Reed Richards"], list_active_customer_names())
def test_integration(self):
# Add Alice and Bob2
alice = self.definitions['Alice']
bob2 = self.definitions['Bob2']
bo.add_customer(alice['id'], alice['name'], alice['last_name'],
alice['address'], alice['phone'], alice['email'],
alice['status'], alice['credit_limit'])
bo.add_customer(bob2['id'], bob2['name'], bob2['last_name'],
bob2['address'], bob2['phone'], bob2['email'],
bob2['status'], bob2['credit_limit'])
# Assert that all 3 are in the DB
self.assertEqual(3, Customer.select().count())
# Modify Alice's credit limit
bo.update_customer_credit(alice['id'], 12.32)
self.assertEqual(
12.32, float(Customer.get(Customer.name == 'Alice').credit_limit))
# Search for Bob2
res = bo.search_customer(bob2['id'])
for k in ['name', 'last_name', 'email', 'phone']:
self.assertEqual(bob2[k], res[k])
# Delete Bob2
bo.delete_customer(bob2['id'])
res = bo.search_customer(bob2['id'])
self.assertEqual({}, res)
def test_integration(self):
""" Tests integration of modules """
database = cm.DATABASE
database.drop_tables([cm.Customer])
database.create_tables([cm.Customer])
bo.add_customer('1150', 'Mark', 'Rollins', '46 Hawthorne Lane, Great Falls, MT 59404',
'406-604-4060', '*****@*****.**', True, 575.00)
bo.add_customer('5102', 'Parker', 'Phan', '8811 Kingston Road, Boynton Beach, FL 33435',
'786-115-5125', '*****@*****.**', True, 250.00)
bo.update_customer('1150', 175.75)
a_customer = cm.Customer.get(cm.Customer.customer_id == '1150')
self.assertEqual(a_customer.customer_credit, 175.75)
bo.add_customer('3030', 'Joseph', 'Tribbiani', '43 Foster Avenue, New York, NY 10003',
'212-013-7564', '*****@*****.**', False, 1000.00)
self.assertEqual(bo.list_active_customers(), 2)
a_customer2 = bo.search_customer('3030')
a_customer2_dict = {'first_name': 'Joseph', 'last_name': 'Tribbiani',
'email_address': '43 Foster Avenue, New York, NY 10003',
'phone_number': '212-013-7564'}
self.assertEqual(a_customer2, a_customer2_dict)
bo.delete_customer('3030')
self.assertEqual(bo.search_customer('3030'), {})
all_customers = [{'1150': ('Mark', 'Rollins')}, {'5102': ('Parker', 'Phan')}]
self.assertEqual(bo.return_all_customers(), all_customers)
def test_integration(self):
'''
This fucntion tests the model and basic_fuctions classes
'''
add_customer(300, 'John', 'Doe', '100 Main St', '123-456-6789',
'*****@*****.**', 'active', 10000)
add_customer(400, 'Jane', 'Doe', '200 Main St', '123-456-6789',
'*****@*****.**', 'inactive', 20000)
searched_dict = search_customer(300)
self.assertEqual(search_customer(500), {})
self.assertEqual(
searched_dict, {
'name': 'John',
'lastname': 'Doe',
'email_address': '*****@*****.**',
'phone_number': '123-456-6789'
})
self.assertEqual(list_active_customers(), 1)
update_customer_credit(300, 40000)
updated_customer = Customer.select().where(
Customer.customer_id == 300).get()
self.assertEqual(updated_customer.credit_limit, 40000)
with self.assertRaises(ValueError):
update_customer_credit(500, 20000)
delete_customer(300)
number = delete_customer(400)
self.assertEqual(number, 1)
number = delete_customer(500)
self.assertEqual(number, 0)
self.assertEqual(list_active_customers(), 0)
add_customer('abc', 'John', 'Doe', '100 Main St', '123-456-6789',
'*****@*****.**', 'active', 10000)
customer = Customer.get_or_none()
self.assertIsNone(customer)
def test_delete_customer():
"""
sets up a new db, adds customer, runs assertions and tears down db
"""
setup_test_db()
# Add and assert to confirm record exists before deleting
add_customer(**OK_CUSTOMER)
valid_customer = search_customer(OK_CUSTOMER['customer_id'], stage='dev')
assert valid_customer.first_name == OK_CUSTOMER['name']
assert valid_customer.customer_id == OK_CUSTOMER['customer_id']
assert valid_customer.last_name == OK_CUSTOMER['lastname']
assert valid_customer.home_address == OK_CUSTOMER['home_address']
assert valid_customer.phone_number == OK_CUSTOMER['phone_number']
assert valid_customer.email_address == OK_CUSTOMER['email_address']
assert valid_customer.status == OK_CUSTOMER['status']
assert valid_customer.credit_limit == OK_CUSTOMER['credit_limit']
delete_customer(OK_CUSTOMER['customer_id'], stage='dev')
valid_customer = search_customer(OK_CUSTOMER['customer_id'], stage='dev')
assert valid_customer is False
teardown_test_db()
def test_basic_operations(self):
for test_customer in customers:
basic_operations.add_customer(test_customer[CUSTOMER_ID],
test_customer[CUSTOMER_NAME],
test_customer[CUSTOMER_LASTNAME],
test_customer[CUSTOMER_HOME_ADDRESS],
test_customer[CUSTOMER_PHONE_NUMBER],
test_customer[CUSTOMER_EMAIL_ADDRESS],
test_customer[CUSTOMER_STATUS],
test_customer[CUSTOMER_CREDIT_LIMIT])
customer = basic_operations.search_customer('1')
self.assertEqual(customer.lastname, 'Lillard')
basic_operations.update_customer_credit('2', 250.99)
customer = basic_operations.search_customer('2')
self.assertEqual(float(customer.credit_limit), 250.99)
self.assertEqual(basic_operations.list_active_customers(), 2)
index = 0
for customer in basic_operations.list_all_customers():
self.assertEqual(customer, pp_customers[index])
index = index + 1
self.assertEqual(basic_operations.delete_customer('3'), 1)
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_search_customer(self):
'''Tests search_customer function.'''
reset_db()
basic_operations.add_customers(TEST_LIST)
# Testing the search_customer function
self.assertEqual(
basic_operations.search_customer(101)['f_name'], TEST_LIST[0][1])
# Test searching for a non-existing customer
self.assertEqual(basic_operations.search_customer(3), {})
def test_search_customer_null():
add_customer(**ok_customer)
customer_dict = search_customer("12345")
assert customer_dict == {}
customer_dict = search_customer(7)
assert customer_dict == {}
customer_dict = search_customer()
assert customer_dict == {}
clean_up(ok_customer["customer_id"])
def test_delete_customer():
add_customer(**ok_customer)
second_customer = add_second_customer()
delete_customer(second_customer["customer_id"])
customer_dict = search_customer(second_customer["customer_id"])
assert customer_dict == {}
ok_customer["credit_limit"] = float(ok_customer["credit_limit"])
customer_dict = search_customer(ok_customer["customer_id"])
assert customer_dict == ok_customer
clean_up(ok_customer['customer_id'])
def test_delete_customers(self):
'''Tests delete_customers function.'''
reset_db()
basic_operations.add_customers(TEST_LIST)
# Testing the delete_customers function
basic_operations.delete_customers([101, 53])
self.assertEqual(basic_operations.search_customer(101), {})
self.assertEqual(basic_operations.search_customer(53), {})
self.assertEqual(
basic_operations.search_customer(123)['f_name'], TEST_LIST[1][1])
def test_integration(self):
'''Integrated test set'''
cust_list = [(101, 'Bugs', 'Bunny', '123 NE 160th Ave, Kirkland, WA 98034', '425-123-4567',
'*****@*****.**', 'Active', 100.00),
(123, 'Donald', 'Duck', '456 SE 45th St, Bellevue, WA 98004', '425-234-5678',
'*****@*****.**', 'Active', 500.00),
(53, 'Elmer', 'Fudd', '789 W 52nd Pl, Bothell, WA 98077', '425-345-6789',
'*****@*****.**', 'Inactive', 12000.00)]
test_list = [{'f_name': 'Elmer', 'l_name': 'Fudd', 'email': '*****@*****.**',
'phone': '425-345-6789'},
{'f_name': 'Bugs', 'l_name': 'Bunny', 'email': '*****@*****.**',
'phone': '425-123-4567'}]
# Test adding customers
basic_operations.add_customers(cust_list)
# Verify customers were added
self.assertEqual(Customer.get(Customer.cust_id == 101).f_name, cust_list[0][1])
self.assertEqual(Customer.get(Customer.cust_id == 123).f_name, cust_list[1][1])
self.assertEqual(Customer.get(Customer.cust_id == 53).f_name, cust_list[2][1])
# Verify duplicate customers are not added
with self.assertRaises(ValueError):
basic_operations.add_customer(*cust_list[2])
# Verify able to search for customers
customers = basic_operations.search_customers([53, 101, 33])
self.assertEqual(customers[0], test_list[0])
self.assertEqual(customers[1], test_list[1])
# Verify searching for a non-existant customer is empty
self.assertEqual(customers[2], {})
# Verify able to update customer credit limit
basic_operations.update_customer_credit(123, 100000)
cust_1 = Customer.get(Customer.cust_id == 123)
self.assertEqual(cust_1.credit, 100000)
# Verify customer credit limit cannot be updated for non-customer
with self.assertRaises(ValueError):
basic_operations.update_customer_credit(42, 1000)
# Verify active customers are counted
self.assertEqual(basic_operations.list_active_customers(), 2)
# Verify a customer can be deleted
basic_operations.delete_customers([53, 123])
self.assertEqual(Customer.get(Customer.cust_id == 101).f_name, cust_list[0][1])
self.assertEqual(basic_operations.search_customer(123), {})
self.assertEqual(basic_operations.search_customer(53), {})
# Verify handling of deleting non-customers
with self.assertRaises(ValueError):
basic_operations.delete_customer(53)
def test_search_customer(self):
# Get Bob
res = bo.search_customer(1)
for key, val in res.items():
self.assertEqual(self.definitions['Bob'][key], val)
self.assertListEqual(list(res.keys()),
['name', 'last_name', 'email', 'phone'])
# Get non-existent ID
res = bo.search_customer(6)
self.assertEqual({}, res)
def test_search_customer(self):
"""Test to check that customer search outputs properly"""
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), {})
def test_search_customer(self, mock_database):
"""Testing searching a customer to the database via search_customer function."""
basic_operations.DATABASE_NAME = TEST_DATABASE
exp_dict = {
'name': 'Wilson',
'lastname': 'Volleyball',
'email_address': '*****@*****.**',
'phone_number': '0000000000'
}
self.assertDictEqual(search_customer(5), exp_dict)
self.assertDictEqual(search_customer(3), {})
def test_delete_customer(self):
""" tests delete customer"""
TEST_DB.bind(MODELS, bind_refs=False, bind_backrefs=False)
TEST_DB.create_tables(MODELS)
add_customer(*CUSTOMERS[0])
add_customer(*CUSTOMERS[1])
delete_customer('00001')
search_customer('00001')
self.assertRaises(Exception)
delete_customer('00009')
self.assertRaises(Exception)
def test_search_customer(_add_customers):
"""Tests customer search function"""
create_empty_db()
for customer in _add_customers:
bo.add_customer(*customer)
result = bo.search_customer(_add_customers[0])
assert result == {}
result = bo.search_customer(customer[0])
assert result["name"] == customer[1]
assert result["lastname"] == customer[2]
assert result["email"] == customer[5]
assert result["phone_number"] == customer[4]
def test_search_customer(self):
# Get first customer
res = bo.search_customer(1)
correct_labels = ['name', 'last_name', 'email', 'phone']
for key in correct_labels:
self.assertEqual(self.first_cust[key], res[key])
self.assertListEqual(correct_labels, list(res.keys()))
# Get non-existent ID
res = bo.search_customer(-1)
self.assertEqual({}, res)
def test_search_customer(self):
""" test search_customer function """
logger.info('Test search_customer')
customer_info = op.search_customer('5')
self.assertEqual(customer_info['name'], 'Jane Goodall')
self.assertEqual(customer_info['last name'], 'Goodall')
self.assertEqual(customer_info['email address'],
'*****@*****.**')
self.assertEqual(customer_info['phone number'], '970-555-0171')
# test exception
customer_info = op.search_customer('50')
def test_search_customer(self):
""" test search_customer function """
customer_info = op.search_customer('5')
self.assertEqual(customer_info['name'], 'Jane Goodall')
self.assertEqual(customer_info['last name'], 'Goodall')
self.assertEqual(customer_info['email address'],
'*****@*****.**')
self.assertEqual(customer_info['phone number'], '970-555-0171')
# test exception
customer_info = op.search_customer('50')
self.assertRaises(peewee.DoesNotExist)
def test_2_update_record(self):
"""Test that a record is updated when the credit_limit is <=7 digits."""
# This will fail
self.assertEqual(basic_operations.update_customer_credit(3, 1000.00),
False)
self.assertEqual(
basic_operations.search_customer(2)['credit_limit'], 9999999.00)
self.assertEqual(basic_operations.update_customer_credit(2, 1000.00),
True)
self.assertEqual(
basic_operations.search_customer(2)['credit_limit'], 1000.00)
def test_search_customer(self):
""" Tests function to search customer """
setup_db()
expected0 = {}
expected1 = {
"name": "Leo",
"lastname": "Messi",
"email_address": "*****@*****.**",
"phone_number": 1234567890
}
self.assertEqual(search_customer(0), expected0)
self.assertEqual(search_customer(1), expected1)
