def test_queries(self):
""" Find active/inactive customers with filter """
cust = Customer(first_name="Peter",
last_name="Parker",
user_id="pparker",
password="******",
active=True)
cust.save()
addr = Address(apartment="1R",
city="Chicago",
state="Illinois",
street="6721 5th Ave",
zip_code="10030",
customer_id=cust.customer_id)
addr.save()
cust.address_id = addr.id
cust.save()
""" Find by first name """
cust_fname = Customer.find_by_first_name(cust.first_name)
self.assertEqual(cust_fname[0].customer_id, cust.customer_id)
""" Find by last name """
cust_lname = Customer.find_by_last_name(cust.last_name)
self.assertEqual(cust_lname[0].customer_id, cust.customer_id)
""" Find by status """
cust_active = Customer.find_by_status(False)
self.assertEqual(len(cust_active), 0)
""" Find by city """
cust_city = Address.find_by_city(cust.city)
self.assertEqual(cust_city[0].customer_id, cust.customer_id)
""" Find by state """
cust_state = Address.find_by_state(cust.state)
self.assertEqual(cust_state[0].customer_id, cust.customer_id)
""" Find by zip code """
cust_zip = Address.find_zip(cust.zip_code)
self.assertEqual(cust_zip[0].customer_id, cust.customer_id)
def test_create_customer_with_http_error(self, bad_mock):
""" Create a customer with http error """
bad_mock.side_effect = HTTPError()
customer = Customer("Arturo", "Frank", "USA", "*****@*****.**", "IAmUser",
"password", "1231231234", True, 1)
customer.save()
time.sleep(WAIT_SECONDS)
def test_remove_all_addresses(self):
""" Remove all addresses """
custs = Customer.all()
self.assertEqual(custs, [])
cust = Customer(first_name="Marry",
last_name="Wang",
user_id="marrywang",
password="******",
active=True)
self.assertTrue(cust != None)
self.assertEqual(cust.customer_id, None)
self.assertEqual(cust.address_id, None)
cust.save()
addr = Address(
street="100 W 100th St.",
apartment="100",
city="New York",
state="New York",
zip_code="10035",
)
addr.customer_id = cust.customer_id
addr.save()
all_addresses = Address.all()
self.assertEquals(len(all_addresses), 1)
addr.remove_all()
all_addresses = Address.all()
self.assertEquals(len(all_addresses), 0)
def get(self):
""" Returns all of the Customers """
app.logger.info('Request for customers list...')
customers = []
args = customer_args.parse_args()
if args['fname']:
app.logger.info('Filtering by first name: %s', args['fname'])
customers = Customer.find_by_first_name(args['fname'])
elif args['lname']:
app.logger.info('Filtering by last name: %s', args['lname'])
customers = Customer.find_by_last_name(args['lname'])
elif args['city']:
app.logger.info('Filtering by city: %s', args['city'])
customers = Address.find_by_city(args['city'])
elif args['state']:
app.logger.info('Filtering by state: %s', args['state'])
customers = Address.find_by_state(args['state'])
elif args['zip_code']:
app.logger.info('Filtering by zip code: %s', args['zip_code'])
customers = Address.find_by_zip(args['zip_code'])
else:
app.logger.info('Getting all customers')
customers = Customer.all()
results = [cust.serialize() for cust in customers]
return results, status.HTTP_200_OK
def test_find_by_subscribed(self):
""" Find Customers by subscribed """
Customer(firstname="John",
lastname="Doe",
email="*****@*****.**",
subscribed=False,
address1="123 Main St",
address2="1B",
city="New York",
country="USA",
province="NY",
zip="12310").save()
Customer(firstname="Sarah",
lastname="Sally",
email="*****@*****.**",
subscribed=True,
address1="124 Main St",
address2="1E",
city="New York",
country="USA",
province="NY",
zip="12310").save()
customers = Customer.find_by_subscribed(False)
self.assertEqual(customers[0].email, "*****@*****.**")
self.assertEqual(customers[0].firstname, "John")
self.assertEqual(customers[0].lastname, "Doe")
self.assertEqual(customers[0].subscribed, False)
self.assertEqual(customers[0].address1, "123 Main St")
self.assertEqual(customers[0].address2, "1B")
self.assertEqual(customers[0].city, "New York")
self.assertEqual(customers[0].province, "NY")
self.assertEqual(customers[0].country, "USA")
self.assertEqual(customers[0].zip, "12310")
def test_deserialize_a_customer(self):
""" Test deserialization of a Customer """
data = {
"id": 1,
"firstname": "John",
"lastname": "Doe",
"email": "*****@*****.**",
"subscribed": False,
"address": {
"address1": "123 Main St",
"address2": "1B",
"city": "New York",
"province": "NY",
"country": "USA",
"zip": "12310"
}
}
customer = Customer()
customer.deserialize(data)
self.assertNotEqual(customer, None)
self.assertEqual(customer.id, None)
self.assertEqual(customer.firstname, "John")
self.assertEqual(customer.lastname, "Doe")
self.assertEqual(customer.email, "*****@*****.**")
self.assertEqual(customer.subscribed, False)
self.assertEqual(customer.address1, "123 Main St")
self.assertEqual(customer.address2, "1B")
self.assertEqual(customer.city, "New York")
self.assertEqual(customer.province, "NY")
self.assertEqual(customer.country, "USA")
self.assertEqual(customer.zip, "12310")
def test_serialize_a_customer(self):
""" Test serialization of a Customer """
customer = Customer(firstname="John",
lastname="Doe",
email="*****@*****.**",
subscribed=False,
address1="123 Main St",
address2="1B",
city="New York",
country="USA",
province="NY",
zip="12310")
data = customer.serialize()
self.assertNotEqual(data, None)
self.assertNotIn('_id', data)
self.assertIn('firstname', data)
self.assertEqual(data['firstname'], "John")
self.assertIn('lastname', data)
self.assertEqual(data['lastname'], "Doe")
self.assertIn('email', data)
self.assertEqual(data['email'], "*****@*****.**")
self.assertIn('subscribed', data)
self.assertEqual(data['subscribed'], False)
self.assertIn('address1', data["address"])
self.assertEqual(data['address']['address1'], "123 Main St")
self.assertIn('address2', data["address"])
self.assertEqual(data['address']['address2'], "1B")
self.assertIn('city', data["address"])
self.assertEqual(data['address']['city'], "New York")
self.assertIn('province', data["address"])
self.assertEqual(data['address']['province'], "NY")
self.assertIn('country', data["address"])
self.assertEqual(data['address']['country'], "USA")
self.assertIn('zip', data["address"])
self.assertEqual(data['address']['zip'], "12310")
def test_find_by_query(self):
""" Find Customers by Category """
Customer("Arturo", "Frank").save()
Customer("Hey", "Jude").save()
time.sleep(WAIT_SECONDS)
customers = Customer.find_by_query(last_name="Frank")
self.assertNotEqual(len(customers), 0)
self.assertEqual(customers[0].last_name, "Frank")
def test_find_customer(self):
""" Find a Customer by ID """
customer = Customer("Hey", "Jude")
customer.save()
time.sleep(WAIT_SECONDS)
saved_customer = Customer.find(customer._id)
self.assertIsNot(customer, None)
self.assertEqual(customer._id, saved_customer._id)
self.assertEqual(customer.first_name, "Hey")
def test_not_vcap_services(self):
""" Test if no VCAP_SERVICES works """
Customer.init_db()
self.assertIsNotNone(Customer.client)
Customer("fido", "dog", True).save()
time.sleep(WAIT_SECONDS)
customer = Customer.find_by_query(first_name="fido")
self.assertNotEqual(len(customer), 0)
self.assertEqual(customer[0].first_name, "fido")
def test_find_by_address(self):
""" Find Customers by Address """
customer = Customer("Arturo", "Frank", "USA", "*****@*****.**", "IAmUser",
"password", "1231231234", True, 1)
customer.save()
time.sleep(WAIT_SECONDS)
customers = Customer.find_by_query(address="USA")
self.assertNotEqual(len(customers), 0)
self.assertEqual(customers[0].address, "USA")
def test_binding_services(self):
""" Test if BINDING_CLOUDANT works """
Customer.init_db()
self.assertIsNotNone(Customer.client)
Customer("fido", "dog", True).save()
time.sleep(WAIT_SECONDS)
customer = Customer.find_by_query(first_name="fido")
self.assertNotEqual(len(customer), 0)
self.assertEqual(customer[0].first_name, "fido")
def test_update_cust_email_and_name(self):
""" Update a Customer email and name"""
customer = Customer(firstname="John",
lastname="Doe",
email="*****@*****.**",
subscribed=False,
address1="123 Main St",
address2="1B",
city="New York",
country="USA",
province="NY",
zip="12310")
customer.save()
self.assertNotEqual(customer.id, None)
# Change it an save it
customer.email = "*****@*****.**"
customer.firstname = "Isabel"
customer.save()
self.assertNotEqual(customer.id, None)
# Fetch it back and make sure the id hasn't changed
# but the data did change
customers = customer.all()
self.assertEqual(len(customers), 1)
self.assertEqual(customers[0].email, "*****@*****.**")
self.assertEqual(customers[0].firstname, "Isabel")
def test_repr(self):
""" Test representation of Data"""
customer = Customer()
self.assertEqual(repr(customer), "<Customer> None None id = [None]>")
customer2 = Customer(
first_name="John",
last_name="Smith",
email="*****@*****.**",
address="123 Brooklyn Ave",
active=True,
)
self.assertEqual(repr(customer2), "<Customer> 'John' 'Smith' id = [None]>")
def test_disconnect(self):
""" Test Disconnet """
Customer.disconnect()
customer = Customer(firstname="John",
lastname="Doe",
email="*****@*****.**",
subscribed=False,
address1="123 Main St",
address2="1B",
city="New York",
country="USA",
province="NY",
zip="12310")
self.assertRaises(AttributeError, customer.save)
def test_rename_customer_invalid_content_type(self):
""" Test renaming a customer with invalid content type """
customer = Customer(first_name="Marry",
last_name="Wang",
user_id="newname",
password="******",
active=True,
address_id=100)
customer.save()
resp = self.app.put('/customers/%s' % customer.user_id,
json={'user_id': 'newname'},
headers={'content-type': 'text/plain'})
self.assertEqual(resp.status_code,
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE)
def test_serialize_a_customer(self):
""" Test serialization of a customer """
cust = Customer(
first_name="Marry",
last_name="Wang",
user_id="marrywang",
password="******",
active=True,
)
cust.save()
addr = Address(
street="48 John St",
apartment="1B",
city="New York",
state="New York",
zip_code="22890",
customer_id=cust.customer_id,
)
addr.save()
cust.address_id = addr.id
cust.save()
data = cust.serialize()
self.assertNotEqual(data, None)
self.assertIn('first_name', data)
self.assertEqual(data['first_name'], "Marry")
self.assertIn('last_name', data)
self.assertEqual(data['last_name'], "Wang")
self.assertIn('user_id', data)
self.assertEqual(data['user_id'], "marrywang")
def test_add_a_customer(self):
""" Create a address and add it to the database, then
create a customer with the address.id and add it to the database
"""
custs = Customer.all()
self.assertEqual(custs, [])
cust = Customer(first_name="Marry",
last_name="Wang",
user_id="marrywang",
password="******",
active=True)
self.assertTrue(cust != None)
self.assertEqual(cust.customer_id, None)
self.assertEqual(cust.address_id, None)
cust.save()
addr = Address(
street="100 W 100th St.",
apartment="100",
city="New York",
state="New York",
zip_code="10035",
)
addr.customer_id = cust.customer_id
addr.save()
cust.address_id = addr.id
# Asert that it was assigned an id and shows up in the database
self.assertEqual(addr.id, 1)
custs = Customer.all()
self.assertEqual(len(custs), 1)
self.assertEqual(cust.customer_id, 1)
custs = Customer.all()
self.assertEqual(len(custs), 1)
def test_deserialize_bad_data(self):
""" Test deserialization of bad data """
data = "this is not a dictionary"
customer = Customer()
self.assertRaises(DataValidationError, customer.deserialize, data)
customer2 = Customer()
data2 = {
"id": 1,
"first_name": "John",
"last_name": "Smith",
"address": "123 Brooklyn Ave",
"active": True,
}
self.assertRaises(DataValidationError, customer2.deserialize, data2)
def test_http_error(self, bad_mock):
""" Test a Bad Create with HTTP error """
bad_mock.side_effect = HTTPError()
customer = Customer(firstname="John",
lastname="Doe",
email="*****@*****.**",
subscribed=False,
address1="123 Main St",
address2="1B",
city="New York",
country="USA",
province="NY",
zip="12310")
customer.create()
self.assertIsNone(customer.id)
def test_document_not_exist(self, bad_mock):
""" Test a Bad Document Exists """
bad_mock.return_value = False
customer = Customer(firstname="John",
lastname="Doe",
email="*****@*****.**",
subscribed=False,
address1="123 Main St",
address2="1B",
city="New York",
country="USA",
province="NY",
zip="12310")
customer.create()
self.assertIsNone(customer.id)
def put(self, customer_id):
"""
Update a single Customer
"""
app.logger.info('Updating a Customer with id [{}]'.format(customer_id))
content_type = request.headers.get('content_type')
if not content_type or content_type != 'application/json':
abort(status.HTTP_400_BAD_REQUEST, "No Content-Type set")
customer = Customer.find(customer_id)
if not customer:
abort(status.HTTP_404_NOT_FOUND,
"Customer with id '{}' was not found.".format(customer_id))
customer_info = request.get_json()
customer_info.pop("_id", None)
try:
customer.deserialize(customer_info)
except DataValidationError as error:
raise BadRequest(str(error))
customer._id = customer_id
customer.save()
message = customer.serialize()
return_code = status.HTTP_200_OK
return message, return_code
def test_deserialize_a_customer(self):
""" Test deserialization of a customer """
data = {
"first_name": "Marry",
"last_name": "Wang",
"user_id": "marrywang",
"password": "******"
}
cust = Customer()
cust.deserialize(data)
self.assertNotEqual(cust, None)
self.assertEqual(cust.customer_id, None)
self.assertEqual(cust.first_name, "Marry")
self.assertEqual(cust.last_name, "Wang")
self.assertEqual(cust.user_id, "marrywang")
self.assertEqual(cust.password, "password")
def get(self):
"""query and get the intersection of the queries.
if there is no given query return all the list
Args:
**par: parameter of query
empty equry
return:
1. the intersection of the parameters
2. empty equry will return all the data
"""
app.logger.info('Query a Customer with query')
app.logger.info('Queries are: {}'.format(
request.args.items().__str__()))
username = request.args.get('username')
address = request.args.get('address')
if username:
# Query customers by name
app.logger.info('Filtering by username:%s', username)
results = Customer.find_by_name(username)
message = [customer.serialize() for customer in results]
return_code = status.HTTP_200_OK
elif address:
# Query customers by name
app.logger.info('Filtering by username:%s', username)
results = Customer.find_by_address(address)
message = [customer.serialize() for customer in results]
return_code = status.HTTP_200_OK
elif request.args:
# Query customers by query
#key = request.args.keys()
app.logger.info('Filtering by query:%s', request.args.keys())
results = Customer.find_by(kwargs=request.args)
#results = Customer.find_by_query({key:request.args.get(key)})
message = [customer.serialize() for customer in results]
return_code = status.HTTP_200_OK
else:
# List all customers.
results = Customer.all()
message = [customer.serialize() for customer in results]
return_code = status.HTTP_200_OK
return message, return_code
def setUp(self):
""" Runs before each test """
self.app = app.test_client()
Customer.init_db("tests")
Customer.remove_all()
Customer(first_name='fido',
last_name='dog',
address='ny',
email='*****@*****.**',
username='******',
password='******',
phone_number='932',
active=True,
id = 1
).save()
time.sleep(WAIT_SECONDS)
Customer(first_name='afido',
last_name='cat',
address='ny',
email='*****@*****.**',
username='******',
password='******',
phone_number='9321',
active=True,
id = 2
).save()
time.sleep(WAIT_SECONDS)
Customer(first_name='redo',
last_name='cat',
address='ny',
email='*****@*****.**',
username='******',
password='******',
phone_number='233',
active=False,
id = 3
).save()
time.sleep(WAIT_SECONDS)
Customer(first_name='tedo',
last_name='dog',
address='nj',
email='*****@*****.**',
username='******',
password='******',
phone_number='423',
active=False,
id = 4
).save()
self.app = app.test_client()
def test_delete_a_customer(self):
""" Delete a Customer"""
customer = Customer("Arturo", "Frank", "USA", "*****@*****.**", "IAmUser",
"password", "1231231234", True, 1)
customer.save()
time.sleep(WAIT_SECONDS)
self.assertEqual(len(Customer.all()), 1)
# delete the customer and make sure it isn't in the database
customer.delete()
self.assertEqual(len(Customer.all()), 0)
def test_add_a_customer(self):
""" Create a customer and add it to the database """
customers = Customer.all()
self.assertEqual(customers, [])
customer = Customer(firstname="John",
lastname="Doe",
email="*****@*****.**",
subscribed=False,
address1="123 Main St",
address2="1B",
city="New York",
country="USA",
province="NY",
zip="12310")
self.assertTrue(customer != None)
self.assertEqual(customer.id, None)
customer.save()
# Asert that it was assigned an id and shows up in the database
self.assertNotEqual(customer.id, None)
customers = Customer.all()
self.assertEqual(len(customers), 1)
self.assertNotEqual(customer.id, None)
customers = Customer.all()
self.assertEqual(len(customers), 1)
self.assertEqual(customers[0].firstname, "John")
self.assertEqual(customers[0].lastname, "Doe")
self.assertEqual(customers[0].email, "*****@*****.**")
self.assertEqual(customers[0].subscribed, False)
self.assertEqual(customers[0].address1, "123 Main St")
self.assertEqual(customers[0].address2, "1B")
self.assertEqual(customers[0].city, "New York")
self.assertEqual(customers[0].province, "NY")
self.assertEqual(customers[0].country, "USA")
self.assertEqual(customers[0].zip, "12310")
def test_bad_update(self):
customer = Customer(
first_name="John",
last_name="Smith",
email="*****@*****.**",
address="123 Brooklyn Ave",
active=True,
)
self.assertRaises(DataValidationError, customer.update)
def delete(self, customer_id):
"""
Delete a Customer
"""
app.logger.info('Deleting a Customer with id [{}]'.format(customer_id))
customer = Customer.find(customer_id)
if customer:
customer.delete()
return '', status.HTTP_204_NO_CONTENT
def put(self, customer_id):
""" Unsubscribe a Customer """
customer = Customer.find(customer_id)
if not customer:
abort(status.HTTP_404_NOT_FOUND,
"Customer with id '{}' was not found.".format(customer_id))
customer.subscribed = False
customer.save()
return customer.serialize(), status.HTTP_200_OK
