def test_modify_offer_saves_an_update_activity(self, app):
# Given
offer_dict = {'name': 'bar', 'type': 'foo'}
offer = Offer(**offer_dict)
ApiHandler.save(offer)
modify_dict = {'name': 'bor'}
offer.modify(modify_dict)
# When
ApiHandler.save(offer)
# Then
all_activities = Activity.query.all()
offer_activities = offer.__activities__
update_offer_activity = offer_activities[1]
assert len(all_activities) == 2
assert len(offer_activities) == 2
assert update_offer_activity.entityIdentifier == offer.activityIdentifier
assert update_offer_activity.verb == 'update'
assert {
**offer_dict,
**modify_dict
}.items() <= update_offer_activity.datum.items()
assert modify_dict.items() == update_offer_activity.patch.items()
assert offer_dict.items() <= update_offer_activity.oldDatum.items()
def test_for_valid_relationship_dicts_with_nested_modifications(self, app):
# Given
offer_dict = {'name': 'foo', 'type': 'bar'}
offer = Offer(**offer_dict)
ApiHandler.save(offer)
stock_dict1 = {'offerId': humanize(offer.id), 'price': 1}
stock1 = Stock(**stock_dict1)
ApiHandler.save(stock1)
stock_dict1['id'] = humanize(stock1.id)
stock_dict2 = {'offerId': humanize(offer.id), 'price': 2}
stock2 = Stock(**stock_dict2)
ApiHandler.save(stock2)
stock_dict2['id'] = humanize(stock2.id)
stock_dict2['price'] = 3
offer_dict['stocks'] = [stock_dict1, stock_dict2]
offer.modify(offer_dict)
# When
ApiHandler.save(offer)
# Then
assert offer.name == offer_dict['name']
offer_stock1 = [s for s in offer.stocks if s.id == stock1.id][0]
offer_stock2 = [s for s in offer.stocks if s.id == stock2.id][0]
assert offer_stock1.id == stock1.id
assert offer_stock1.price == stock_dict1['price']
assert offer_stock2.id == stock2.id
assert offer_stock2.price == stock_dict2['price']
def test_404_with_wrong_base_id(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
offer1.id = 6
ApiHandler.save(offer1)
# When
with pytest.raises(NotFound):
load_or_404(Offer, 'AZ')
def test_find_or_create_returns_existing_offer(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
ApiHandler.save(offer1)
# When
offer2 = Offer.find_or_create({'__SEARCH_BY__': 'name', 'name': 'foo'})
# Then
assert offer2.id == offer1.id
assert offer2.name == offer1.name == 'foo'
assert offer2.type == offer1.type == 'bar'
def test_create_or_modify_with_primary_filter(self, app):
# Given
datum = {'name': 'foo', 'type': 'bar'}
offer1 = Offer(**datum)
ApiHandler.save(offer1)
# When
offer2 = Offer.create_or_modify({'id': offer1.humanizedId, **datum})
# Then
assert offer2.id == offer1.id
assert offer2.name == datum['name']
def create_offer_api(shop_id):
try:
offer_hash = get_offer_json_attr_from_hash(request.json)
if Offer.is_valid_hash_for_create(offer_hash):
offer_hash['shop'] = Shop.find_by_id(shop_id)
offer = Offer.create_offer(offer_hash)
return dumps(offer.as_json()), 200
except ValueError as e:
return dumps(e.message), 400
except Exception as e:
print(e.message)
print(traceback.print_exc())
return dumps(e.message), 400
def test_dictify_with_relationships_includes(self, app):
# given
offer = Offer()
stock = Stock()
offer.stocks = [stock]
# when
stock_dict = as_dict(stock)
offer_dict = as_dict(offer, includes=["stocks"])
# then
assert 'stocks' in offer_dict
assert len(offer_dict['stocks']) == 1
assert offer_dict['stocks'][0]['id'] == stock_dict['id']
def test_find_returns_none(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
ApiHandler.save(offer1)
# When
offer2 = Offer.find({
'__SEARCH_BY__': 'name',
'name': 'fee',
'type': 'bric'
})
# Then
assert offer2 is None
def test_on_datetime_list_returns_string_with_date_in_ISO_8601_list(self):
# Given
offer = Offer()
stock = Stock()
stock.offer = offer
stock.beginningDatetime = now
stock.endDatetime = now + timedelta(hours=3)
offer.stocks = [stock]
# When
serialized_list = serialize(offer.dateRange)
# Then
for date in serialized_list:
self._assert_is_in_ISO_8601_format(date)
def test_modify_a_property_with_no_fset(self, app):
# When
stock = Stock()
offer = Offer(name="foo", notDeletedStocks=[stock], type="bar")
# Then
assert offer.notDeletedStocks == []
def test_create_or_modify_with_relationship_search(self, app):
# Given
offer = Offer.create_or_modify(
{
'__SEARCH_BY__': 'name',
'name': 'foo',
'type': 'bar'
},
with_add=True,
with_flush=True)
stock1 = Stock.create_or_modify({
'__SEARCH_BY__': ['offer', 'price'],
'offer': offer,
'price': 2
})
# When
stock2 = Stock.create_or_modify({
'__SEARCH_BY__': ['offer', 'price'],
'offer': offer,
'price': 3
})
#Then
assert offer.id != None
assert offer.name == 'foo'
assert offer.type == 'bar'
assert stock1.offer.id == offer.id
assert stock2.offer.id == offer.id
assert stock1.id == None
assert stock2.id == None
def test_create_delete_activity_with_previous_updated_activities(
self, app):
# Given
offer = Offer(name='bar', type='foo')
ApiHandler.save(offer)
update_activity = Activity(dateCreated=datetime.utcnow(),
entityIdentifier=offer.activityIdentifier,
modelName='Offer',
patch={'name': 'bor'})
delete_activity = Activity(dateCreated=datetime.utcnow(),
entityIdentifier=offer.activityIdentifier,
modelName='Offer',
verb='delete')
# When
ApiHandler.activate(update_activity, delete_activity)
# Then
query_filter = (Activity.data['id'].astext.cast(Integer) == offer.id) & \
(Activity.verb == 'delete')
activity = Activity.query.filter(query_filter).one()
offers = Offer.query.all()
assert len(offers) == 0
assert activity.entityIdentifier == offer.activityIdentifier
def test_create_or_modify_returns_modified_offer(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
ApiHandler.save(offer1)
# When
offer2 = Offer.create_or_modify({
'__SEARCH_BY__': 'name',
'name': 'foo',
'type': 'bric'
})
# Then
assert offer2.id == offer1.id
assert offer2.name == offer1.name == 'foo'
assert offer2.type == 'bric'
def test_create_or_modify_with_relationships_search(self, app):
# Given
offer = Offer.create_or_modify(
{
'__SEARCH_BY__': 'name',
'name': 'foo',
'type': 'bar'
},
with_add=True,
with_flush=True)
tag = Tag.create_or_modify({
'__SEARCH_BY__': 'label',
'label': 'car'
},
with_add=True,
with_flush=True)
# When
offer_tag = OfferTag.create_or_modify({
'__SEARCH_BY__': ['offer', 'tag'],
'offer': offer,
'tag': tag
})
#Then
assert offer.id != None
assert offer.name == 'foo'
assert offer.type == 'bar'
assert tag.id != None
assert tag.label == 'car'
assert offer_tag.id == None
def test_create_offer_saves_an_insert_activity(self, app):
# Given
offer_dict = {'name': 'bar', 'type': 'foo'}
offer = Offer(**offer_dict)
# When
ApiHandler.save(offer)
# Then
all_activities = Activity.query.all()
offer_activities = offer.__activities__
insert_offer_activity = offer_activities[0]
insert_offer_activity_from_query = Activity.query \
.filter_by(entityIdentifier=offer.activityIdentifier) \
.one()
assert len(all_activities) == 1
assert len(offer_activities) == 1
assert insert_offer_activity_from_query == insert_offer_activity
assert offer.activityIdentifier == insert_offer_activity.entityIdentifier
assert insert_offer_activity.entityInsertedAt == offer.dateCreated
assert insert_offer_activity.oldDatum == None
assert insert_offer_activity.transaction == None
assert insert_offer_activity.verb == 'insert'
assert offer_dict.items() <= insert_offer_activity.patch.items()
assert offer_dict.items() <= insert_offer_activity.datum.items()
assert insert_offer_activity.datum['id'] == humanize(offer.id)
assert insert_offer_activity.patch['id'] == humanize(offer.id)
def test_find_and_modify_raises_ressource_not_found_error(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
ApiHandler.save(offer1)
# When
with pytest.raises(ResourceNotFoundError) as e:
Offer.find_and_modify({
'__SEARCH_BY__': 'name',
'name': 'fee',
'type': 'bric'
})
# Then
assert e.value.errors['find_and_modify'] == [
'No ressource found with {"name": "fee"} '
]
def test_should_return_soft_deleted_entities_when_option_is_given(self):
# given
offer = Offer(name='foo', type='bar')
stock1 = Stock(price=10, isSoftDeleted=True)
stock2 = Stock(price=5, isSoftDeleted=False)
offer.stocks = [stock1, stock2]
includes = [{
'key': 'stocks',
'includes': ['price'],
'with_soft_deleted_entities': True
}]
# when
offer_dict = as_dict(offer, includes=includes)
# then
assert len(offer_dict['stocks']) == 2
def test_find_raise_empty_filter_error(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
ApiHandler.save(offer1)
# When
with pytest.raises(EmptyFilterError) as errors:
Offer.find({
'__SEARCH_BY__': 'position',
'name': 'fee',
'type': 'bric'
})
# Then
assert errors.value.errors['_filter_from'] == [
"None of filters found among: position"
]
def test_404_with_not_existing_id(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
ApiHandler.save(offer1)
# When
with pytest.raises(NotFound):
load_or_404(Offer, humanize(offer1.id + 1))
def test_for_valid_relationship_dicts(self):
# Given
test_object = Offer()
stock_dict1 = {'price': 1}
stock_dict2 = {'price': 1}
offer_dict = {
'name': 'foo',
'stocks': [stock_dict1, stock_dict2],
'type': 'bar'
}
# When
test_object.modify(offer_dict)
# Then
assert test_object.name == offer_dict['name']
assert test_object.stocks[0].price == stock_dict1['price']
assert test_object.stocks[1].price == stock_dict2['price']
def test_get_with_an_index_path_at_entity(self, app):
# Given
offer = Offer(name='foo', type='bar')
stock1 = Stock(offer=offer, price=1)
# When
stock2 = stock1.get('offer.stocks.0')
# Then
assert stock1.id == stock2.id
def test_for_valid_one_to_many_relationship(self, app):
# Given
offer = Offer(name='foo', type='bar')
stock = Stock(offer=offer, price=1)
# When
ApiHandler.save(stock)
# Then
assert stock.offerId == offer.id
def test_load_entity(self, app):
# Given
offer1 = Offer(name='foo', type='bar')
ApiHandler.save(offer1)
# When
offer2 = load_or_404(Offer, humanize(offer1.id))
# Then
assert offer1.id == offer2.id
def test_get_with_a_string_path(self, app):
# Given
offer = Offer(name='foo', type='bar')
stock = Stock(offer=offer, price=1)
# When
offer_name = stock.get('offer.name')
# Then
assert offer_name == offer.name
def test_get_with_an_index_path_at_value(self, app):
# Given
offer = Offer(name='foo', type='bar')
stock = Stock(offer=offer, price=1)
# When
stock_price = stock.get('offer.stocks.0.price')
# Then
assert stock_price == stock.price
def list_offer_api(shop_id):
try:
shop = Shop.find_by_id(shop_id=shop_id)
offers = Offer.find_by_shop(shop)
return dumps([offer.as_json() for offer in offers]), 200
except ValueError as e:
return dumps(e.message), 400
except Exception as e:
print(e.message)
print(traceback.print_exc())
return dumps(e.message), 400
def get_offer(offer_id):
try:
offer = Offer.find_by_id(offer_id)
if offer:
return dumps(offer.as_json()), 200
else:
return dumps({"Error": "Offer Not found"}), 400
except Exception as e:
print(e.message)
print(traceback.print_exc())
return dumps(e.message), 400
def update_offer(offer_id):
try:
offer_hash = get_offer_json_attr_from_hash(request.json)
offer = Offer.find_by_id(offer_id)
if offer:
offer = offer.update_offer_details(offer_hash)
return dumps(offer.as_json()), 200
else:
return dumps({"Error": "Offer Not found"}), 400
except Exception as e:
print(e.message)
print(traceback.print_exc())
return dumps(e.message), 400
def create_offer(offer_hash=None, fk_shop_id=None, fk_category_id=None):
if offer_hash is None:
offer_hash = {
'title': 'some Titile',
'discount': 50.5,
'address': "some address",
'description': "wow it came now!!!",
'offer_profile_banner_url': "some_url_location",
'starting_time': datetime.datetime.now(),
'end_time': datetime.datetime.now(),
'fk_shop_id': create_shop().shop_id if not fk_shop_id else fk_shop_id,
'fk_category_id': create_category().category_id if not fk_category_id else fk_category_id,
'geo_location': 'somelocation'
}
return Offer.create_offer(offer_hash)
def test_for_valid_relationship(self, app):
# Given
offer_dict = {'name': 'foo', 'type': 'bar'}
offer = Offer(**offer_dict)
ApiHandler.save(offer)
stock_dict = {'offer': offer, 'price': 1}
stock = Stock(**stock_dict)
# When
ApiHandler.save(stock)
# Then
assert stock.price == stock_dict['price']
assert stock.offer.id == offer.id
assert stock.offer.name == offer_dict['name']