def test_first_save_registers_publication():
for account in Account.get_many():
account.delete()
for article in Article.get_many():
article.delete()
user_id = 'user_id'
score = random.randint(0, 100)
account_id = Account({
'user_id': user_id,
'email': fake.email(),
'name': fake.sentence(),
'score': score
}).save()
article_id = Article({
'name': fake.word(),
'description': fake.sentence(),
'available_units': fake.pyint(),
'price': 20.0,
'latitude': 0.0,
'longitude': 0.0,
'user': user_id,
}).save()
assert Account.get_one(account_id).score() == score + 1
Article.get_one(article_id).save()
assert Account.get_one(account_id).score() == score + 1
def test_first_save_registers_purchase():
for account in Account.get_many():
account.delete()
for article in Article.get_many():
article.delete()
for purchase in Purchase.get_many():
purchase.delete()
score = random.randint(0, 100)
purchaser_id = Account({
'user_id': user_id,
'email': fake.email(),
'name': fake.sentence(),
'score': score
}).save()
article_id = Article({
'name': fake.word(),
'description': fake.sentence(),
'available_units': fake.pyint(),
'price': 20.0,
'latitude': 0.0,
'longitude': 0.0,
'user': '******',
}).save()
purchase_id = Purchase({
'user_id': purchaser_id,
'article_id': article_id,
'units': 1
}).save()
assert Account.get_one(purchaser_id).score() == score + 5
Purchase.get_one(purchase_id).save()
assert Account.get_one(purchaser_id).score() == score + 5
def run_query(self):
query = Article.make_mongo_query(self.args)
new_queries = []
if self.price_max:
new_queries.append({"price": {"$lte": self.price_max}})
if self.price_min:
new_queries.append({"price": {"$gte": self.price_min}})
if self.name:
new_queries.append({"name": {'$regex': self.name}})
if new_queries:
query["$and"] = query.get("$and", []) + new_queries
return Article.run_query(query)
def generate_article():
instance = Article({
"name": fake.pystr(),
"description": fake.text(),
"available_units": fake.pyint(),
"price": fake.pyfloat(),
"latitude": fake.pyfloat(),
"longitude": fake.pyfloat(),
"user": fake.pystr(),
})
instance.save()
return instance
def create_question(_id):
try:
article = Article.get_one(_id)
except ValueError as e:
return response(message=str(e), ok=False), 400
if not article:
return response(message=f"Article {_id} not found", ok=False), 400
account = Account.current()
resp, status_code = create(Question,
additional_fields={
'created_at': datetime.utcnow(),
'article_id': _id,
'user_id': account.get_id()
})
if status_code == 200:
question = Question.get_one(resp.json['_id'])
FirebaseMessage(
{
'title': f'Nueva pregunta de {account["name"]}',
'message': f'{question["question"]}',
'question': question.get_id(),
'type': 'new_question'
},
to=article.account()).send()
return resp, status_code
def expand(cls, purchases):
result = []
for purchase in purchases:
purchase = purchase.to_json()
purchase['article'] = Article.get_one( # N database calls, i know
str(purchase.pop('article_id'))).to_json()
result.append(purchase)
return result
def append_article_to_questions(self, queryset):
result = []
for question in queryset:
question = question.to_json()
question['article'] = \
Article.get_one(question.pop('article_id')).to_json()
result.append(question)
return result
def get_article(body):
article_id = body.get('article_id')
try:
article = Article.get_one(article_id)
if article is None:
return None, response("article was not found", ok=False), 400
except ValueError:
return None, response(f"article_id not specified", ok=False), 400
return article, None
def get_by_seller(cls, seller: Account):
article_ids = [
a.get_id() for a in Article.get_many(user=seller['user_id'])
]
if not article_ids:
return []
purchases = cls.get_many(article_id=article_ids)
return cls.expand(purchases)
def get_by_owner(self):
account = Account.get_one(self.owner)
article_ids = [a.get_id()
for a in Article.get_many(user=account['user_id'])]
questions = []
for article_id in article_ids:
questions.extend(
Question.get_many(article_id=article_id)
)
return self.append_article_to_questions(questions)
def setup_function():
fake = Faker()
teardown_function()
Article({
'name': fake.word(),
'description': fake.sentence(),
'available_units': fake.pyint(),
'price': 20.0,
'latitude': 0.0,
'longitude': 0.0,
'user': fake.word(),
}).save()
Article({
'name': fake.word(),
'description': fake.sentence(),
'available_units': fake.pyint(),
'price': 300.0,
'latitude': 1.0,
'longitude': 1.0,
'user': fake.word(),
}).save()
def test_shipment_cost_no_coordinates(client):
article_id = Article({
'name': fake.word(),
'description': fake.sentence(),
'available_units': fake.pyint(),
'price': 20.0,
'latitude': 0.0,
'longitude': 0.0,
'user': fake.word(),
}).save()
response = client.get(f'/article/{article_id}/shipment_cost/?'
f'payment_method=cash')
assert response.status_code == 400
assert not response.json['ok']
def questions(_id):
try:
article = Article.get_one(_id)
except ValueError as e:
return response(message=str(e), ok=False), 400
if not article:
return response(message=f"Article {_id} not found", ok=False), 400
return jsonify({
'data': [q.to_json() for q in Question.get_many(article_id=_id)],
'ok':
True
})
def patch_question():
resp, status_code = patch(Question)
if status_code == 200:
question = Question.get_one(resp.json['data']['_id'])
article = Article.get_one(question['article_id'])
FirebaseMessage(
{
'title': f'Nueva respuesta sobre {article["name"]}',
'message': f'{question["answer"]}',
'article_id': question['article_id'],
'type': 'new_answer'
},
to=Account.get_one(question['user_id'])).send()
return resp, status_code
def test_shipment_cost(client):
shared_server_response = {
"success": True,
"cost": {
'cost': 12.0,
'status': 'enabled'
}
}
shared_server_response_json_data =\
json.dumps(shared_server_response['cost'], sort_keys=True)
article_id = Article({
'name': fake.word(),
'description': fake.sentence(),
'available_units': fake.pyint(),
'price': 20.0,
'latitude': 0.0,
'longitude': 0.0,
'user': fake.word(),
}).save()
with requests_mock.Mocker() as _mock:
_mock.post(f'{shared_server_url}shipment-cost',
json=shared_server_response)
response = client.get(f'/article/{article_id}/shipment_cost/?'
f'payment_method=cash&'
f'my_lat=0&my_lon=0')
my_response_json_data = json.dumps(response.json['data'],
sort_keys=True)
assert response.json['ok']
assert my_response_json_data == json.dumps(
{
"cash": {
"cost": 12.0,
"status": "enabled"
},
"credit": {
"cost": 12.0,
"status": "enabled"
},
"debit": {
"cost": 12.0,
"status": "enabled"
}
},
sort_keys=True)
def delete_article(_id):
try:
article = Article.get_one(_id)
except ValueError as e:
return response(message=str(e), ok=False), 400
if not article:
return response(message=f"Article {_id} not found", ok=False), 400
if article['user'] != user_id():
return response(message=f"User {user_id()} is not the "
f"owner of article {_id}",
ok=False), 401
deleted = article.delete()
if not deleted.deleted_count:
return response(message=f"Error deleting article", ok=False), 500
return response(message=f"Successfully deleted article {_id}",
ok=True), 200
def answer_question(article_id, question_id):
try:
article = Article.get_one(article_id)
except ValueError as e:
return response(message=str(e), ok=False), 400
if not article:
return response(message=f"Article {article_id} not found",
ok=False), 400
try:
question = Question.get_one(question_id)
except ValueError as e:
return response(message=str(e), ok=False), 400
body = request.get_json(silent=True)
if not body:
return response("Invalid or empty request body", ok=False), 400
answer = body.get('answer')
if not answer:
return response("No answer specified", ok=False), 400
answered_at = datetime.utcnow()
question.update(**{'answer': answer, 'answered_at': answered_at})
account = Account.current()
FirebaseMessage(
{
'title': f'Nueva respuesta de {account["name"]}',
'message': f'{question["answer"]}',
'article_id': article_id,
'type': 'new_answer'
},
to=Account.get_one(question['user_id'])).send()
return jsonify({"ok": True, "data": question.to_json()}), 200
def test_post_purchase(client, article):
with mock.patch('server.shared_server.shared_server.request'):
with mock.patch('server.libs.firebase.FirebaseMessage.send'):
resp = client.post('/purchase/',
data=json.dumps({
"article_id":
article.get_id(),
"units":
article['available_units'],
"price":
1000,
"payment_method":
"cash"
}),
content_type='application/json')
assert resp.status_code == 200
resp_article = Article.get_one(article.get_id()).to_json()
article = article.to_json()
for key in article:
if key == 'available_units':
assert resp_article[key] == 0 # all units were bought
else:
assert resp_article[key] == article[key]
def shipment_cost(_id):
args = request.args
lat = args.get('my_lat')
lon = args.get('my_lon')
if not (lat and lon):
return response(message=f"latitude and longitude missing",
ok=False), 400
try:
lat = float(lat)
lon = float(lon)
except ValueError:
return response(message="latitude and longitude must be numbers",
ok=False), 400
try:
article = Article.get_one(_id)
except ValueError as e:
return response(message=str(e), ok=False), 400
if not article:
return response(message=f"Article {_id} not found", ok=False), 400
cash_response = shared_server.shipment_cost(article, lat, lon, 'cash')
credit_response = shared_server.shipment_cost(article, lat, lon, 'credit')
debit_response = shared_server.shipment_cost(article, lat, lon, 'debit')
cash_data = cash_response.json()
credit_data = credit_response.json()
debit_data = debit_response.json()
success = cash_data["success"]
success = success and credit_data["success"]
success = success and debit_data["success"]
return jsonify({
'ok': success,
'data': {
'cash': cash_data["cost"],
'credit': credit_data["cost"],
'debit': debit_data["cost"]
}
}), 200 if success else 500
def get_single_article(_id):
try:
return jsonify(Article.get_one(_id).to_json())
except ValueError:
return response(f"invalid id {_id}", ok=False), 400
def teardown_function():
for a in Article.get_many():
a.delete()
def article(self) -> Optional[Article]:
return Article.get_one(self['article_id'])
