def delete_customer(customer_id):
"""
delete a customer by id
"""
try:
# open database
DATABASE.connect()
DATABASE.execute_sql('PRAGMA foreign_keys=ON;')
LOGGER.info("connected to database")
# remove customer by id
Customer.get_by_id(customer_id).delete_instance()
LOGGER.info("id %s customer deleted", customer_id)
except OperationalError as err:
LOGGER.info("conection to database failed")
LOGGER.info(err)
except IntegrityError as err:
LOGGER.info("customer with id %s not found", customer_id)
LOGGER.info(err)
finally:
# close database
DATABASE.close()
LOGGER.info("database closed")
def test_delete_customer(self, mock_database):
"""Testing deleting a customer to the database via delete_customer function."""
basic_operations.DATABASE_NAME = TEST_DATABASE
self.assertTrue(delete_customer(1))
with self.assertRaises(peewee.DoesNotExist):
Customer.get_by_id(1)
self.assertFalse(delete_customer(3))
def test_delete_customer(self):
""" Tests that a customer can be deleted """
set_up_db()
add_customer(*self.test_customer)
delete_customer(1)
try:
Customer.get_by_id(1)
except DoesNotExist:
LOGGER.info("Customer was deleted.")
def delete_customer(customer_id):
'''Deletes a specific customer from the database.'''
try:
LOGGER.info('Searching for customer ID %s to delete from the database', customer_id)
Customer.get_by_id(customer_id)
Customer.delete_by_id(customer_id)
LOGGER.info('Customer %s is deleted from the database', customer_id)
except peewee.DoesNotExist:
LOGGER.info('Customer ID: %s is not available to delete from the database', customer_id)
raise ValueError
def test_add_customers(self):
""" Test adding a valid customer records to the DB """
set_up_db()
add_customers(self.test_customers)
test_customer = Customer.get_by_id(1)
self.assertEqual(self.test_customers[0][1], test_customer.name)
test_customer = Customer.get_by_id(2)
self.assertEqual(self.test_customers[1][1], test_customer.name)
test_customer = Customer.get_by_id(3)
self.assertEqual(self.test_customers[2][1], test_customer.name)
def test_add_customer(self):
""" Test add_customer() """
logging.info("test_add_customer()")
# Initial database set up
set_up()
# Populate customers data into the database
for person in CLIENTS:
add_customer(**person)
logging.info(Customer.get_by_id(person['customer_id']).phone_number)
self.assertEqual(person['phone_number'], Customer.get_by_id(person['customer_id']).phone_number)
# Remove data and exit database
tear_down()
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_update_customer_credit(self, mock_database):
"""Testing updating customer credit via update_customer_credit function."""
basic_operations.DATABASE_NAME = TEST_DATABASE
self.assertTrue(update_customer_credit(5, 5000))
self.assertEqual(Customer.get_by_id(5).credit_limit, 5000)
with self.assertRaises(ValueError):
update_customer_credit(4, 80000)
def update_status(customer_id, new_status):
"""
update customer status
"""
try:
# open database
DATABASE.connect()
DATABASE.execute_sql('PRAGMA foreign_keys=ON;')
LOGGER.info("connected to database")
# search customer by id
searched_customer = Customer.get_by_id(customer_id)
# check searched customer's status and update it if active or inactive
if new_status in ("active", "inactive"):
searched_customer.status = new_status
LOGGER.info("status updated for customer id %s", customer_id)
# save updated customer
searched_customer.save()
else:
LOGGER.info("status neither active or inactive")
LOGGER.info("status wasn't updated")
except DoesNotExist as err:
LOGGER.info("customer id %s not found", customer_id)
LOGGER.info(err)
finally:
# close database
DATABASE.close()
LOGGER.info("database closed")
def update_credit(customer_id, credit_limit):
"""
search customer by id and update credit limit
"""
try:
# open database
DATABASE.connect()
DATABASE.execute_sql('PRAGMA foreign_keys=ON;')
LOGGER.info("connected to database")
# retrive customer by id
searched_customer = Customer.get_by_id(customer_id)
# update customer's credit limit
searched_customer.credit_limit = credit_limit
LOGGER.info("credit limit updated for customer id %s", customer_id)
# save updated customer
searched_customer.save()
except DoesNotExist as err:
LOGGER.info("customer id %s not found", customer_id)
LOGGER.info("credit limit of %s for customer id %s not updated",
credit_limit, customer_id)
LOGGER.info(err)
finally:
# close database
DATABASE.close()
LOGGER.info("database closed")
def delete_customer(customer_id):
""" deletes customer from database"""
print('Deleting customer with ID {}...'.format(customer_id))
try:
customer_delete = Customer.get_by_id(customer_id)
customer_delete.delete_instance()
LOGGER.info('Customer with Customer ID %s has been deleted',
customer_id)
except Customer.DoesNotExist:
print('No record of customer with Customer ID {}'.format(customer_id))
print('No customer deleted')
def update_customer_credit(customer_id, new_credit_limit):
"""update credit limit"""
print('Updating customer with ID {}...'.format(customer_id))
try:
customer_credit_update = Customer.get_by_id(customer_id)
customer_credit_update.credit_limit = new_credit_limit
customer_credit_update.save()
LOGGER.info('Customer with ID %s has been updated', customer_id)
except Customer.DoesNotExist:
print('No record of customer with Customer ID {}'.format(customer_id))
print('No customer updated')
def test_add_customer(self):
""" Test add_customer() """
logging.info("test_add_customer()")
# Initial database set up
set_up()
# Populate customers data into the database
for person in CLIENTS:
add_customer(**person)
self.assertEqual(person['phone_number'], Customer.get_by_id(person['customer_id']).phone_number)
logging.critical(f"Add new customer to database: {person['name']} {person['lastname']} (id={person['customer_id']})")
# Remove data and exit database
tear_down()
def test_add_customer(self):
""" Test adding a valid customer record to the DB """
set_up_db()
add_customer(*self.test_customer)
test_customer = Customer.get_by_id(1)
self.assertEqual("Bruce", test_customer.name)
self.assertEqual("Wayne", test_customer.last_name)
self.assertEqual("1007 Mountain Drive, Gotham",
test_customer.home_address)
self.assertEqual("228-626-7699", test_customer.phone_number)
self.assertEqual("*****@*****.**", test_customer.email)
self.assertEqual(True, test_customer.status)
self.assertEqual(200000.00, test_customer.credit_limit)
def test_update_customer_credit(self):
""" Test update_customer_credit() """
logging.info("test_update_customer_credit()")
# Initial database set up
set_up()
# Populate customers data into the database
for person in CLIENTS:
add_customer(**person)
# Update credit limit of customer id = 2
update_customer_credit(2, 15000)
self.assertEqual(15000, Customer.get_by_id(2).credit_limit)
# Remove data and exit database
tear_down()
def update_customer_credit(customer_id, credit_limit):
""" Update an existing customer's credit limit in the database """
logging.info("update_customer_credit()")
try:
with database.atomic():
person = Customer.get_by_id(customer_id)
person.credit_limit = credit_limit
Customer.bulk_update([person], fields=[Customer.credit_limit])
except DoesNotExist:
logging.error(
f"Can't find customer data with id = {customer_id} in the database."
)
raise ValueError
def update_customer_credit(customer_id, credit_limit):
"""Updates a customer's credit limit in the database."""
init_database()
try:
customer = Customer.get_by_id(customer_id)
customer.credit_limit = credit_limit
customer.save()
return True
except peewee.DoesNotExist:
logging.error("Customer ID %s doesn't exist in database.", customer_id)
raise ValueError('Customer ID does not exist in database.')
finally:
database.close()
def delete_customer(customer_id):
"""
delete a customer by id
"""
try:
# open database
DATABASE.connect()
DATABASE.execute_sql('PRAGMA foreign_keys=ON;')
LOGGER.info("connected to database")
# remove customer by id
Customer.get_by_id(customer_id).delete_instance()
LOGGER.info("id %s customer deleted", customer_id)
except DoesNotExist as err:
LOGGER.info("customer with id %s not deleted", customer_id)
LOGGER.info(err)
finally:
# close database
DATABASE.close()
LOGGER.info("database closed")
def test_update_customer_credit(self):
""" Test update_customer_credit() """
logging.info("test_update_customer_credit()")
# Initial database set up
set_up()
# Populate customers data into the database
for person in CLIENTS:
add_customer(**person)
# Update credit limit of customer id = 2
update_customer_credit(2, 15000)
self.assertEqual(15000, Customer.get_by_id(2).credit_limit)
logging.critical(f"Update credit limit of customer {CLIENTS[1]['name']} {CLIENTS[1]['lastname']} (id={CLIENTS[1]['customer_id']}) from ${CLIENTS[1]['credit_limit']} to $15000")
# Remove data and exit database
tear_down()
def add_customer(customer_id, first_name, last_name, home_address,
phone_number, email_address, status, credit_limit):
""" adds customer to database"""
print('Adding new customer, Customer ID {}...'.format(customer_id))
try:
Customer.get_by_id(customer_id)
print('Customer ID {} is already in use'.format(customer_id))
except Exception as ex:
if "instance matching query does not exist" in str(ex):
try:
new_customer = Customer.create(customer_ID=customer_id,
first_name=first_name,
last_name=last_name,
home_address=home_address,
phone_number=phone_number,
email_address=email_address,
status=status,
credit_limit=credit_limit)
new_customer.save()
LOGGER.info('Added new customer, Customer ID %s', customer_id)
except IntegrityError:
print('Incorrect format, customer {} not saved'
.format(customer_id))
def test_add_customer(self, mock_database):
"""Testing adding a customer to the database via add_customer function."""
basic_operations.DATABASE_NAME = TEST_DATABASE
add_customer(17, 'Bob', 'Testy', '111 Test St', 1234567890, '*****@*****.**', True, 70000)
test_customer = Customer.get_by_id(17)
self.assertEqual(test_customer.name, 'Bob')
self.assertEqual(test_customer.lastname, 'Testy')
self.assertEqual(test_customer.home_address, '111 Test St')
self.assertEqual(test_customer.phone_number, '1234567890')
self.assertEqual(test_customer.email_address, '*****@*****.**')
self.assertEqual(test_customer.active_status, True)
self.assertEqual(test_customer.credit_limit, 70000)
self.assertFalse(add_customer(17, 'Bob', 'Testy', '111 Test St', 1234567890,
'*****@*****.**', True, 70000))
def delete_customer(customer_id):
"""Deletes a customer from the database."""
init_database()
try:
with database.transaction():
customer = Customer.get_by_id(customer_id)
customer.delete_instance()
logging.info('Customer with ID %s successfully deleted.',
customer_id)
return True
except peewee.DoesNotExist:
logging.error('Customer delete with ID %s failed, not in database..',
customer_id)
return False
finally:
database.close()
def test_add_customer_invalid_phone(self):
""" Test add_customer() with an invalid phone number """
CLIENTS_INVALID_PHONE = [
{'customer_id': 1, 'name': 'Andrew', 'lastname': 'York', 'home_address': "This is Andrew's home address", 'phone_number': '425-111-1111-dummy', 'email_address': '*****@*****.**', 'status': True, 'credit_limit': 10000},
{'customer_id': 2, 'name': 'Peter', 'lastname': 'Young', 'home_address': "This is Peter's home address", 'phone_number': '425-222-2222-extra', 'email_address': '*****@*****.**', 'status': False, 'credit_limit': 5000},
]
logging.info("test_add_customer_invalid_phone()")
# Initial database set up
set_up()
# Populate customers data into the database
for person in CLIENTS_INVALID_PHONE:
with self.assertRaises(IntegrityError):
add_customer(**person)
logging.info(Customer.get_by_id(person['customer_id']).phone_number)
# Remove data and exit database
tear_down()
def test_main_integration(self, mock_database):
"""Full integration testing of basic_operations.py functions."""
basic_operations.DATABASE_NAME = TEST_DATABASE
self.assertEqual(list_active_customers(), 2)
add_customer(17, 'Bob1', 'Testy', '111 Test St', 1234567890,
'*****@*****.**', True, 70000)
add_customer(18, 'Bob2', 'Testo', '112 Test St', 2234567890,
'*****@*****.**', True, 71000)
add_customer(19, 'Bob3', 'Testi', '113 Test St', 3234567890,
'*****@*****.**', False, 72000)
exp_dict = {
'name': 'Bob2',
'lastname': 'Testo',
'email_address': '*****@*****.**',
'phone_number': '2234567890'
}
self.assertDictEqual(search_customer(18), exp_dict)
update_customer_credit(19, 50000)
self.assertEqual(Customer.get_by_id(19).credit_limit, 50000)
delete_customer(18)
self.assertEqual(list_active_customers(), 3)
ending_db = [(1, 'Bob', 'Bobbo', '12 Green St', '1112223344',
'*****@*****.**', False, 85000),
(2, 'Jane', 'Janeo', '1550 Red Rd', '1118675309',
'*****@*****.**', True, 150000),
(5, 'Wilson', 'Volleyball', '1 Castaway Island',
'0000000000', '*****@*****.**', True, 0),
(17, 'Bob1', 'Testy', '111 Test St', 1234567890,
'*****@*****.**', True, 70000),
(19, 'Bob3', 'Testi', '113 Test St', 3234567890,
'*****@*****.**', False, 50000)]
table_columns = ('customer_id', 'name', 'lastname', 'home_address',
'phone_number', 'email_address', 'active_status',
'credit_limit')
expected_print = ' | '.join(
('{:^20}'.format(column) for column in table_columns))
for row in ending_db:
expected_print += '\n' + ' | '.join(
('{:^20}'.format(str(x)) for x in row))
with patch('sys.stdout', new=StringIO()) as captured_output:
report_all_customers()
self.assertEqual(captured_output.getvalue().rstrip('\n'),
expected_print)
def search_customer(customer_id):
"""Searches for a customer in the database, returning a dictionary of contact info if found."""
init_database()
try:
customer = Customer.get_by_id(customer_id)
customer_dict = {
'name': customer.name,
'lastname': customer.lastname,
'email_address': customer.email_address,
'phone_number': customer.phone_number
}
return customer_dict
except peewee.DoesNotExist:
logging.warning("Customer ID %s doesn't exist in database.",
customer_id)
return {}
finally:
database.close()
def test_add_customer(self):
""" tests add_customer"""
TEST_DB.bind(MODELS, bind_refs=False, bind_backrefs=False)
TEST_DB.create_tables(MODELS)
add_customer(*CUSTOMERS[0])
test_c1 = Customer.get_by_id('00001')
self.assertEqual(test_c1.customer_ID, '00001')
self.assertEqual(test_c1.first_name, 'Dorothy')
self.assertEqual(test_c1.last_name, 'Zbornak')
self.assertEqual(test_c1.home_address, 'Miami')
self.assertEqual(test_c1.phone_number, '5551234567')
self.assertEqual(test_c1.email_address, '*****@*****.**')
self.assertEqual(test_c1.status, True)
self.assertEqual(test_c1.credit_limit, 1000)
add_customer(*CUSTOMERS[0])
self.assertRaises(Exception)
add_customer(*CUSTOMERS[4])
self.assertRaises(Exception)
def search_customer(customer_id):
""" Search for a customer in the database using customer_id """
logging.info("search_customer()")
result = {}
try:
with database.transaction():
person = Customer.get_by_id(customer_id)
result = {
'name': person.name,
'lastname': person.lastname,
'email_address': person.email_address,
'phone_number': person.phone_number
}
except DoesNotExist:
logging.error(
f"Can't find customer data with id = {customer_id} in the database."
)
finally:
return result
def search_customer(customer_id):
"""
search a customer by id
"""
try:
# open database
DATABASE.connect()
DATABASE.execute_sql('PRAGMA foreign_keys=ON;')
LOGGER.info("connected to database")
# search a customer by id
searched_customer = Customer.get_by_id(customer_id)
LOGGER.info("customer %s found", customer_id)
# retrive full info for searched customer from database
return {
"customer_id": searched_customer.customer_id,
"first_name": searched_customer.first_name,
"last_name": searched_customer.last_name,
"home_address": searched_customer.home_address,
"email_address": searched_customer.email_address,
"phone_number": searched_customer.phone_number,
"status": searched_customer.status,
"credit_limit": searched_customer.credit_limit,
#-------------------------
"join_date": searched_customer.join_date,
"insertion_date": searched_customer.insertion_date,
"time_stamp": searched_customer.time_stamp,
"hobby": searched_customer.hobby
}
except OperationalError as err:
LOGGER.info("conection to database failed")
LOGGER.info(err)
except IntegrityError as err:
LOGGER.info("customer not found")
finally:
# close database
DATABASE.close()
LOGGER.info("database closed")
def search_customer(customer_id):
""" returns customer information from database"""
print('Searching for customer, Customer ID {}...'.format(customer_id))
try:
customer_search = Customer.get_by_id(customer_id)
if customer_search.status is True:
status = 'Active'
else:
status = 'Inactive'
customer_dict = {'Customer ID': customer_id,
'First Name': customer_search.first_name,
'Last Name': customer_search.last_name,
'Home Address': customer_search.home_address,
'Phone Number': customer_search.phone_number,
'Email Address': customer_search.email_address,
'Status': status,
'Credit Limit': customer_search.credit_limit}
print('Info for Customer ID {}'.format(customer_id))
return customer_dict
except Customer.DoesNotExist:
print('No record of customer with Customer ID {}'.format(customer_id))
def search_customer(customer_id):
"""
Look up for a customer
:param customer_id: Integer representing the customer ID
:return: A dictionary object with name, last name, email address and phone number of a customer
or an empty dictionary object if no customer was found.
"""
LOGGER.info("Looking up customer ID %s:", customer_id)
try:
result_customer = Customer.get_by_id(customer_id)
LOGGER.info("Found customer ID %s, %s %s", customer_id,
result_customer.name, result_customer.last_name)
return {
"name": result_customer.name,
"last_name": result_customer.last_name,
"email": result_customer.email,
"phone_number": result_customer.phone_number
}
except DoesNotExist:
LOGGER.info("Customer ID %s was not found.", customer_id)
return {}
