def test_post__success_empty_db(self):
data_user = User.get()
data_address = {
'user_id': data_user.uuid,
'nation': 'Italia',
'city': 'Prato',
'postal_code': '59100',
'local_address': 'Via Roncioni 10',
'phone': '0574100100',
}
resp = self.app.post('/addresses/', data=data_address)
query = Address.select()
address_from_db = Address.get()
expected_data = {
'user_id': address_from_db.user.uuid,
'nation': address_from_db.nation,
'city': address_from_db.city,
'postal_code': address_from_db.postal_code,
'local_address': address_from_db.local_address,
'phone': address_from_db.phone,
}
assert expected_data == data_address
assert resp.status_code == CREATED
assert len(query) == 1
assert query.get().json() == json.loads(resp.data.decode())
def test_post__success(self):
data_user = User.get()
address_id_created = uuid.uuid4()
Address.create(
uuid=address_id_created,
user=data_user,
nation='Italia',
city='Prato',
postal_code='59100',
local_address='Via Roncioni 10',
phone='0574100100',
)
data_address = {
'user_id': data_user.uuid,
'nation': 'Italia',
'city': 'Prato',
'postal_code': '59100',
'local_address': 'Via Roncioni 10',
'phone': '0574100100',
}
resp = self.app.post('/addresses/', data=data_address)
query = Address.select().where(Address.uuid != address_id_created)
assert resp.status_code == CREATED
assert query.get().json() == json.loads(resp.data.decode())
def test_delete__success(self):
data_user = User.get()
data_address1 = Address.create(
uuid=uuid.uuid4(),
user=data_user,
nation='Italia',
city='Prato',
postal_code='59100',
local_address='Via Roncioni 10',
phone='0574100100',
)
data_address2 = Address.create(
uuid=uuid.uuid4(),
user=data_user,
nation='Italia',
city='Firenze',
postal_code='59000',
local_address='Via Baracca 10',
phone='0558778666',
)
resp = self.app.delete('/addresses/{}'.format(data_address1.uuid))
all_addresses = Address.select()
address_from_db = all_addresses.get()
assert resp.status_code == NO_CONTENT
assert len(all_addresses) == 1
assert address_from_db.uuid == data_address2.uuid
def put(self, address_id):
json = request.get_json()
try:
address = (Address.select().where(
Address.uuid == address_id).where(
Address.user == g.current_user).get())
except Address.DoesNotExist:
return None, NOT_FOUND
try:
Address.verify_json(json)
except ValidationError as err:
return {"message": err.message}, BAD_REQUEST
if address.user.uuid == g.current_user.uuid:
address.nation = json['nation']
address.city = json['city']
address.postal_code = json['postal_code']
address.local_address = json['local_address']
address.phone = json['phone']
address.save()
return address.json(), CREATED
else:
return '', BAD_REQUEST
def address_create():
address_form = AddressForm(request.form)
user = auth.get_logged_in_user()
if request.method == "POST":
address = Address(
user = user,
street=address_form.street.data,
zipcode=address_form.zipcode.data,
state=address_form.state.data,
country=address_form.country.data
)
address.save()
flash("Address successfully saved")
return redirect(url_for("dashboard"))
elif request.method == "GET":
try:
exist = Address.select().where(Address.user == user).get()
return redirect(url_for("address"))
except Address.DoesNotExist:
if request.method == "POST":
address = Address(
user = user,
street=address_form.street.data,
zipcode=address_form.zipcode.data,
state=address_form.state.data,
country=address_form.country.data
)
address.save()
flash("Address successfully saved")
return redirect(url_for("dashboard"))
else:
return render_template("address_create.html", address_form=address_form)
def test_post__success_empty_db(self):
data_address = {
'nation': 'Italia',
'city': 'Prato',
'postal_code': '59100',
'local_address': 'Via Roncioni 10',
'phone': '0574100100',
}
resp = self.open_with_auth('/addresses/',
'post',
self.user.email,
'p4ssw0rd',
data=data_address)
address_from_db = Address.get()
expected_data = {
'nation': address_from_db.nation,
'city': address_from_db.city,
'postal_code': address_from_db.postal_code,
'local_address': address_from_db.local_address,
'phone': address_from_db.phone,
}
assert expected_data == data_address
assert resp.status_code == CREATED
assert len(Address.select()) == 1
assert address_from_db.json() == json.loads(resp.data.decode())
def test_delete__empty_db_address_id_not_exists(self):
resp = self.open_with_auth('/addresses/{}'.format(uuid.uuid4()),
'delete',
self.user.email,
'p4ssw0rd',
data='')
assert resp.status_code == NOT_FOUND
assert len(Address.select()) == 0
def test_get_addresses_list__success(self):
add_address(
self.user, id='4373d5d7-cae5-42bc-b218-d6fc6d18626f')
addr_list = [a for a in Address.select()]
data = AddressSchema.jsonapi_list(addr_list)
expected_result = EXPECTED_ADDRESSES['get_addresses_list__success']
assert_valid_response(data, expected_result)
def get(self, address_id):
try:
address = (Address.select().where(
Address.uuid == address_id).where(
Address.user == g.current_user).get())
except Address.DoesNotExist:
return None, NOT_FOUND
return address.json(), OK
def order_creator(num_order):
for i in range(num_order):
order_id = fake.uuid4()
Order.create(uuid=order_id,
user=User.select().order_by(fn.Random()).get(),
total_price=0,
delivery_address=Address.select().order_by(
fn.Random()).get(),
items=[])
def test_create_address__not_json_failure(self):
user = add_user('*****@*****.**', '123')
addr = new_addr(user)
resp = open_with_auth(self.app, '/addresses/', 'POST', user.email,
TEST_USER_PSW, 'application/json',
wrong_dump(addr))
assert resp.status_code == BAD_REQUEST
assert len(Address.select()) == 0
def delete(self, address_id):
try:
address = (Address.select().where(
Address.uuid == address_id).where(
Address.user == g.current_user).get())
except Address.DoesNotExist:
return None, NOT_FOUND
address.delete_instance()
return None, NO_CONTENT
def test_delete_address__success(self):
user = add_user('*****@*****.**', '123')
addr = add_address(user,
city="Firenze",
post_code='50132',
address="Via Rossi 10")
resp = open_with_auth(self.app, '/addresses/{}'.format(addr.uuid),
'DELETE', user.email, TEST_USER_PSW, None, None)
assert resp.status_code == NO_CONTENT
assert not Address.select().exists()
def run_mailing(subject_field: Entry, text_field: Text, addresses_field: Text):
save_email_addresses(addresses_field)
subject = subject_field.get()
text = text_field.get(1.0, END)
save_email(subject_field.get(), text_field.get(1.0, END))
addresses = Address.select()
for address in addresses:
logger.info(f'Sending: {address.email}')
send_email(email=address.email, subject=subject, text=text)
time.sleep(1)
def test_delete__success(self):
data_address1 = self.create_address(self.user)
# TODO: Is ok to have a duplicated address for a single user?
data_address2 = self.create_address(self.user)
resp = self.app.delete('/addresses/{}'.format(data_address1.uuid))
all_addresses = Address.select()
address_from_db = all_addresses.get()
assert resp.status_code == NO_CONTENT
assert len(all_addresses) == 1
assert address_from_db.uuid == data_address2.uuid
def test_post__field_not_exists(self):
data_address = {
'user_id': self.user.uuid,
'city': 'Prato',
'postal_code': '59100',
'local_address': 'Via Roncioni 10',
'phone': '0574100100',
}
resp = self.app.post('/addresses/', data=data_address)
assert resp.status_code == BAD_REQUEST
assert len(Address.select()) == 0
def test_put__address_id_not_exists(self):
data = {
'user_id': self.user.uuid,
'nation': 'Italia',
'city': 'Prato',
'postal_code': '59100',
'local_address': 'Via Roncioni 10',
'phone': '0574100100',
}
resp = self.app.put('/addresses/{}'.format(uuid.uuid4()), data=data)
assert resp.status_code == NOT_FOUND
assert len(Address.select()) == 0
def test_delete__address_id_not_exists(self):
data_user = User.get()
Address.create(
uuid=uuid.uuid4(),
user=data_user,
nation='Italia',
city='Prato',
postal_code='59100',
local_address='Via Roncioni 10',
phone='0574100100',
)
resp = self.app.delete('/addresses/{}'.format(uuid.uuid4()))
assert resp.status_code == NOT_FOUND
assert len(Address.select()) == 1
def test_create_address__success(self):
user = add_user('*****@*****.**',
'123',
id='1777e816-3051-4faf-bbba-0c8a87baf08f')
addr = format_jsonapi_request('address', new_addr(user))
resp = open_with_auth(self.app, '/addresses/', 'POST', user.email,
TEST_USER_PSW, 'application/json',
json.dumps(addr))
assert resp.status_code == CREATED
assert len(Address.select()) == 1
expected_result = EXPECTED_RESULTS['create_address__success']
assert_valid_response(resp.data, expected_result)
def test_create_address__failure_missing_field(self):
user = add_user('*****@*****.**', '123')
addr = new_addr(user)
del addr['country']
addr = format_jsonapi_request('address', addr)
resp = open_with_auth(self.app, '/addresses/', 'POST', user.email,
TEST_USER_PSW, 'application/json',
json.dumps(addr))
assert resp.status_code == BAD_REQUEST
assert len(Address.select()) == 0
expected_result = EXPECTED_RESULTS[
'create_address__failure_missing_field']
assert_valid_response(resp.data, expected_result)
def test_post__field_not_exists(self):
data_address = {
'city': 'Prato',
'postal_code': '59100',
'local_address': 'Via Roncioni 10',
'phone': '0574100100',
}
resp = self.open_with_auth('/addresses/',
'post',
self.user.email,
'p4ssw0rd',
data=data_address)
assert resp.status_code == BAD_REQUEST
assert len(Address.select()) == 0
def test_delete__success(self):
data_address1 = self.create_address(self.user)
# TODO: Is ok to have a duplicated address for a single user?
data_address2 = self.create_address(self.user)
resp = self.open_with_auth('/addresses/{}'.format(data_address1.uuid),
'delete',
self.user.email,
'p4ssw0rd',
data='')
all_addresses = Address.select()
address_from_db = all_addresses.get()
assert resp.status_code == NO_CONTENT
assert len(all_addresses) == 1
assert address_from_db.uuid == data_address2.uuid
def test_delete_user__cascade(self):
Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=1,
category='scarpe',
)
Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=1,
category='accessori',
)
email = '*****@*****.**'
user = add_user(email, TEST_USER_PSW)
user1 = add_user('*****@*****.**', TEST_USER_PSW)
addr = add_address(user=user)
addr1 = add_address(user=user1)
Order.create(delivery_address=addr, user=user)
order1 = Order.create(delivery_address=addr1, user=user1)
user_path = 'users/'
resp = open_with_auth(self.app, API_ENDPOINT.format(user_path), 'DELETE',
email, TEST_USER_PSW, None, None)
assert resp.status_code == NO_CONTENT
assert Address.select().count() == 1
assert Order.select().count() == 1
assert User.select().count() == 1
addr2 = Address.get()
assert addr2 == addr1
order2 = Order.get()
assert order2 == order1
user2 = User.get()
assert user2 == user1
def put(self, address_id):
try:
address = (Address.select().where(
Address.uuid == address_id).where(
Address.user == g.current_user).get())
except Address.DoesNotExist:
return None, NOT_FOUND
parser = reqparse.RequestParser()
parser.add_argument('nation', type=utils.non_empty_str, required=True)
parser.add_argument('city', type=utils.non_empty_str, required=True)
parser.add_argument('postal_code',
type=utils.non_empty_str,
required=True)
parser.add_argument('local_address',
type=utils.non_empty_str,
required=True)
parser.add_argument('phone', type=utils.non_empty_str, required=True)
args = parser.parse_args(strict=True)
for parm in [
'nation', 'city', 'postal_code', 'local_address', 'phone'
]:
if len(args[parm]) < 3:
return '', BAD_REQUEST
if address.user.uuid == g.current_user.uuid:
address.nation = args['nation']
address.city = args['city']
address.postal_code = args['postal_code']
address.local_address = args['local_address']
address.phone = args['phone']
address.save()
return address.json(), CREATED
else:
return '', BAD_REQUEST
def load_addresses_to_field(field: Text):
field.delete(1.0, END)
field_text = '\n'.join(
[f"{address.email}" for address in Address.select()])
field.insert(INSERT, field_text)
def get_distance_between_two_addresses(self, first_address,
second_address):
# check address in db
query_first = Address.select().where(Address.name == first_address)
query_second = Address.select().where(Address.name == second_address)
if query_first.exists() and query_second.exists():
query_distance = DistanceBetweenAddress.select().where(
DistanceBetweenAddress.address_id == query_first.get().id,
DistanceBetweenAddress.next_address_id ==
query_second.get().id)
if query_distance.exists():
return query_distance.get().distance
router = Router(self.calculate_method)
# Initialise it
coord_s_t = time.time()
first_lat, first_lng = (query_first.get().lat, query_first.get().lng) if query_first.exists() else \
self.get_coordinates_from_yandex(first_address)
second_lat, second_lng = (query_second.get().lat, query_second.get().lng) if query_second.exists() else \
self.get_coordinates_from_yandex(second_address)
coord_e_t = time.time()
start = router.findNode(first_lng,
first_lat) # Find start and end nodes
end = router.findNode(second_lng, second_lat)
rout_s_t = time.time()
status, route = router.doRoute(
start, end) # Find the route - a list of OSM nodes
route_e_t = time.time()
if status == 'success':
routeLatLons = list(map(router.nodeLatLon,
route)) # Get actual route coordinates
total_distance = 0
# calculate total distance from route coordinates
for index in range(1, len(routeLatLons)):
total_distance += geopy.distance.vincenty(
routeLatLons[index - 1], routeLatLons[index]).km
else:
total_distance = 0
# это случается, когда 2 точки с одинаковым адресом, надо перепроверить
print(f'{route}')
first = query_first.get().id if query_first.exists(
) else Address.create(name=first_address, lat=first_lat, lng=first_lng)
second = query_second.get().id if query_second.exists(
) else Address.create(
name=second_address, lat=second_lat, lng=second_lng)
DistanceBetweenAddress.bulk_create([
DistanceBetweenAddress(address_id=first,
next_address_id=second,
distance=total_distance),
DistanceBetweenAddress(address_id=second,
next_address_id=first,
distance=total_distance)
])
print(f'COORDINATES TIME = {coord_e_t - coord_s_t} sec')
print(f'ROUTE TIME = {route_e_t - rout_s_t} sec')
print(total_distance, 'Total distance ==============================')
return total_distance
def test_delete__address_id_not_exists(self):
self.create_address(self.user)
resp = self.app.delete('/addresses/{}'.format(uuid.uuid4()))
assert resp.status_code == NOT_FOUND
assert len(Address.select()) == 1
def get_user_address_records(uid):
records = Address.select().where(Address.owner == uid)
return [record.get_display_data() for record in records]
def addresses(self):
addresses = []
for address in Address.select():
addresses.append(address.dict())
return addresses
def get(self):
user_addrs = list(Address.select().where(
Address.user == auth.current_user))
return generate_response(Address.json_list(user_addrs), OK)