def test_01_addOffer(self):
offer = Offer(**self.offer_dict_1)
second_offer = Offer(**self.offer_dict_2)
third_offer = Offer(**self.offer_dict_3)
self.assertTrue(DB.addOffer(offer))
self.assertTrue(DB.addOffer(second_offer))
self.assertTrue(DB.addOffer(third_offer))
def test_booking_completed_url_gets_normalized():
# Given
product = Product()
product.url = 'javascript:alert("plop")'
offer = Offer()
offer.id = 1
offer.product = product
stock = Stock()
user = User()
user.email = '*****@*****.**'
booking = Booking()
booking.token = 'ABCDEF'
booking.stock = stock
booking.stock.offer = offer
booking.user = user
# When
completedUrl = booking.completedUrl
# Then
assert completedUrl == 'http://javascript:alert("plop")'
def test_offer_is_digital_if_it_has_an_url():
# given
offer = Offer()
offer.url = 'http://url.com'
# when / then
assert offer.isDigital
def retrieve_new_offers() -> None:
"""Extract and store offers from the Offers MS for each product.
First creates OffersBatch record to which all created offers are tied.
Ignores offers not matching the schema or empty responses
:return:
"""
oms = OffersMsClient()
ob = OffersBatch()
db.session.add(ob)
for p in Product.query.all():
for offer_data_raw in oms.extract_offers(p):
try:
offer_data = offers_schema_external.load(offer_data_raw)
offer_data['id_external'] = offer_data.pop('id')
except (ValidationError, KeyError) as e:
current_app.logger.warning(
f'offer validation failed with {getattr(e, "messages", str(e))} {offer_data_raw=}'
)
continue
o = Offer(product_id=p.id, offers_batch_id=ob.id, **offer_data)
db.session.add(o)
db.session.commit()
def test_create_payment_for_booking_with_common_information(app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
booking = create_booking(user, stock=stock, quantity=1)
booking.stock.offer = Offer()
booking.stock.offer.venue = Venue()
offerer = create_offerer()
offerer_bank_information = create_bank_information(bic='QSDFGH8Z555',
iban='CF13QSDFGH456789',
offerer=offerer)
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.booking == booking
assert payment.amount == Decimal(10)
assert payment.reimbursementRule == ReimbursementRules.PHYSICAL_OFFERS.value.description
assert payment.reimbursementRate == ReimbursementRules.PHYSICAL_OFFERS.value.rate
assert payment.comment is None
assert payment.author == 'batch'
assert payment.transactionLabel == 'pass Culture Pro - remboursement 2nde quinzaine 10-2018'
def test_returns_none_if_no_mediations_exist_on_offer(self):
# given
offer = Offer()
offer.mediations = []
# then
assert offer.activeMediation is None
def create_offer_with_event_product(venue=None, product=None, event_name='Test event', duration_minutes=60,
date_created=datetime.utcnow(),
booking_email='*****@*****.**', thumb_count=0, dominant_color=None,
event_type=EventType.SPECTACLE_VIVANT, is_national=False, is_active=True,
idx=None, last_provider_id=None, id_at_providers=None, description=None) -> Offer:
offer = Offer()
if product is None:
product = create_product_with_event_type(event_name=event_name, event_type=event_type,
duration_minutes=duration_minutes,
thumb_count=thumb_count, dominant_color=dominant_color,
is_national=is_national)
offer.product = product
offer.venue = venue
offer.name = product.name
offer.type = product.type
offer.description = description
offer.isNational = product.isNational
offer.durationMinutes = product.durationMinutes
offer.dateCreated = date_created
offer.bookingEmail = booking_email
offer.isActive = is_active
offer.id = idx
offer.lastProviderId = last_provider_id
offer.idAtProviders = id_at_providers
return offer
def test_create_payment_for_booking_when_no_iban_on_venue_should_take_payment_info_from_offerer(
app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
offerer = create_offerer(name='Test Offerer')
venue = create_venue(offerer, name='Test Venue')
offerer_bank_information = create_bank_information(bic='QsdFGH8Z555',
iban='cf13QSDFGH456789',
offerer=offerer)
venue_bank_information = create_bank_information(bic=None,
iban=None,
venue=venue)
booking = create_booking(user, stock=stock, quantity=1)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == 'CF13QSDFGH456789'
assert payment.bic == 'QSDFGH8Z555'
def test_create_payment_for_booking_when_iban_is_on_venue_should_take_payment_info_from_venue(
app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
offerer = create_offerer(name='Test Offerer')
venue = create_venue(
offerer,
name='Test Venue',
)
booking = create_booking(user, stock=stock, quantity=1)
offerer_bank_information = create_bank_information(bic='Lajr93',
iban='B135TGGEG532TG',
offerer=offerer)
venue_bank_information = create_bank_information(bic='LokiJU76',
iban='KD98765RFGHZ788',
venue=venue)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == 'KD98765RFGHZ788'
assert payment.bic == 'LOKIJU76'
def create_offer(payload):
body = request.get_json()
if not body:
abort(400, 'Request body is missing.')
if body.get('title') is None:
abort(400, '"title" is required in the request body.')
# Create a new record
o = Offer(
title=body.get('title'),
contents=body.get('contents', ''),
event_time=body.get('event_time'), # Null if not found
finalized=body.get('finalized', False),
topics=[get_topic(name=t) for t in body.get('topics', [])],
panelists=[
get_panelist(name=p) for p in body.get('panelists', [])
]
)
try:
o.insert()
offer_id = o.id
except Exception:
abort(422, 'Database error: Insertion failed.')
return jsonify({
'success': True,
'message': 'Offer record has been created successfully.',
'id': offer_id
}), 201
def test_returns_false_if_offer_is_coming_from_provider(self, app):
# given
offer = Offer()
offer.lastProviderId = 21
# then
assert offer.isEditable == False
def create_dummy_objects():
s = LandingSite()
s.page1_template = 'acai1.html'
s.page1_name = 'acai version 1'
s.page1_desc = "Ben's site"
s.category = 'diet'
s.total_offers = 2
s.active = True
s.redirect_on_exit = True
s.save()
o = Offer()
o.network_name = 'eadv'
o.offer_name = 'Lean Spa US'
o.offer_url = 'http://www.leanspa.com?s='
o.display_name = 'Lean Spa'
o.offer_id = 10107
o.active = True
o.payout = 50.00
o.save()
o2 = Offer()
o2.network_name = 'eadv'
o2.offer_name = 'ColoThin'
o2.offer_url = 'http://www.colothin.com?s='
o2.display_name = 'ColoThin'
o2.offer_id = 2345
o2.active = True
o2.price_old = '3.99'
o2.price_new = '1.99'
o2.coupon = 'COLOSAVE'
o2.payout = 50.00
o2.save()
os = OfferSet()
os.offer1_id = 1
os.offer2_id = 2
os.total_offers = 2
os.category = 'diet'
os.active = True
os.save()
sof = SiteOfferSet()
sof.site = s
sof.offer_set = os
sof.save()
def test_date_range_is_empty_if_event_has_no_stocks():
# given
offer = Offer()
offer.product = create_product_with_event_type()
offer.stocks = []
# then
assert offer.dateRange == DateTimes()
def test_date_range_is_empty_if_offer_is_on_a_thing():
# given
offer = Offer()
offer.product = create_product_with_thing_type()
offer.stocks = []
# then
assert offer.dateRange == DateTimes()
def test_does_not_raise_error_when_offer_type_is_editable(self):
# given
offer = Offer()
# when
try:
check_offer_is_editable(offer)
except:
assert False
def createOffer():
if request.method == "POST":
data = request.get_json(force=True)
createdTime = (
datetime.datetime.now() +
datetime.timedelta(hours=8)).strftime("%Y-%m-%d %H:%M:%S")
updateTime = (
datetime.datetime.now() +
datetime.timedelta(hours=8)).strftime("%Y-%m-%d %H:%M:%S")
email_time = "2016-12-19 " + data["email_time"] + ":00"
emailTime = float(
time.mktime(time.strptime(email_time, '%Y-%m-%d %H:%M:%S')))
offer = Offer(
int(data["user_id"]), int(data["customer_id"]), data["status"],
data["contract_type"], data["contract_num"],
float(data["contract_scale"]), data["os"], data["package_name"],
data["app_name"], data["app_type"].encode('utf-8'),
data["preview_link"], data["track_link"], data["material"],
data["startTime"], data["endTime"], str(data["platform"]),
str(data["country"]), float(data["price"]),
float(data["daily_budget"]), data["daily_type"],
float(data["total_budget"]), data["total_type"],
data["distribution"], data["authorized"], data["named_rule"],
data["KPI"].encode('utf-8'), data["settlement"].encode('utf-8'),
data["period"].encode('utf-8'), data["remark"].encode('utf-8'),
emailTime, str(data["email_users"]), int(data["email_tempalte"]),
createdTime, updateTime)
try:
db.session.add(offer)
db.session.commit()
db.create_all()
for i in data['country_detail']:
history = History(offer.id,
int(data["user_id"]),
"default",
createdTime,
status=data["status"],
country=i["country"],
country_price=i["price"],
price=data["price"],
daily_budget=float(data["daily_budget"]),
daily_type=data["daily_type"],
total_budget=float(data["total_budget"]),
total_type=data["total_type"],
KPI=data["KPI"],
contract_type=data["contract_type"],
contract_scale=float(data["contract_scale"]))
db.session.add(history)
db.session.commit()
db.create_all()
return json.dumps({"code": 200, "message": "success"})
except Exception as e:
print e
return json.dumps({"code": 500, "message": "fail"})
def test_returns_false_if_all_stocks_have_no_booking_limit_datetime(self):
# given
offer = Offer()
stock1 = create_stock(booking_limit_datetime=None)
stock2 = create_stock(booking_limit_datetime=None)
stock3 = create_stock(booking_limit_datetime=None)
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFinished is False
def test_returns_none_if_all_mediations_are_deactivated(self):
# given
offer = Offer()
offer.mediations = [
create_mediation(offer, is_active=False),
create_mediation(offer, is_active=False)
]
# then
assert offer.activeMediation is None
def test_returns_true_if_all_stocks_have_past_booking_limit_datetime(self):
# given
now = datetime.utcnow()
offer = Offer()
stock1 = create_stock(booking_limit_datetime=now - timedelta(weeks=3))
stock2 = create_stock(booking_limit_datetime=now - timedelta(weeks=2))
stock3 = create_stock(booking_limit_datetime=now - timedelta(weeks=1))
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFinished is True
def add_offer():
date = request.json['date']
username = request.json['username']
book_id = request.json['book_id']
new_offer = Offer(date, username, book_id)
db.session.add(new_offer)
db.session.commit()
return jsonify(new_offer)
def add_offer():
form = OfferForm()
if form.validate_on_submit():
offer = Offer.query.filter_by(name=form.name.data).first()
if not offer:
db_session.add(
Offer(form.name.data, form.cost.data, form.description.data,
form.capacity.data))
db_session.commit()
return redirect('/all_abonements')
return render_template('add_offer.html', form=form)
def test_booking_on_thing_is_cancellable(self):
# Given
booking = Booking()
booking.stock = Stock()
booking.stock.offer = Offer()
booking.stock.offer.product = create_product_with_thing_type()
# When
is_cancellable = booking.isUserCancellable
# Then
assert is_cancellable == True
def fill_offer_with_new_data(product_dict: str, user: User) -> Offer:
product = Product()
url = product_dict.get('url')
if url:
is_url_safe(url)
product_dict['isNational'] = True
product.populate_from_dict(product_dict)
check_user_can_create_activation_event(user, product)
offer = Offer()
offer.populate_from_dict(product_dict)
offer.product = product
return offer
def test_date_range_matches_the_occurrence_if_only_one_occurrence():
# given
offer = Offer()
offer.product = create_product_with_event_type()
offer.stocks = [
create_stock(offer=offer,
beginning_datetime=two_days_ago,
end_datetime=five_days_from_now)
]
# then
assert offer.dateRange == DateTimes(two_days_ago, five_days_from_now)
def test_returns_false_if_stocks_have_none_available_quantity(self):
# given
offer = Offer()
user = create_user()
stock1 = create_stock(available=None)
stock2 = create_stock(available=None)
create_booking(user, stock=stock1, quantity=1)
create_booking(user, stock=stock2, quantity=1)
offer.stocks = [stock1, stock2]
# then
assert offer.isFullyBooked is False
def test_returns_false_if_any_stock_has_future_booking_limit_datetime(
self):
# given
now = datetime.utcnow()
offer = Offer()
stock1 = create_stock(booking_limit_datetime=now - timedelta(weeks=3))
stock2 = create_stock(booking_limit_datetime=None)
stock3 = create_stock(booking_limit_datetime=now + timedelta(weeks=1))
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFinished is False
def test_raises_error_when_offer_is_not_editable(self):
# given
offer = Offer()
offer.lastProviderId = "42"
# when
with pytest.raises(ApiErrors) as error:
check_offer_is_editable(offer)
# then
assert error.value.errors['global'] == [
"Les offres importées ne sont pas modifiables"
]
def test_does_not_raise_api_error_when_offerer_cancellation_not_used_and_thing(self):
# Given
booking = Booking()
booking.isUsed = False
booking.stock = Stock()
booking.stock.offer = Offer()
booking.stock.offer.product = create_product_with_thing_type()
# When
check_output = check_booking_is_cancellable(booking, is_user_cancellation=False)
# Then
assert check_output is None
def test_stocks_with_past_booking_limit_datetimes_are_ignored(self):
# given
offer = Offer()
user = create_user()
stock1 = create_stock(available=2,
booking_limit_datetime=datetime.utcnow() -
timedelta(weeks=3))
stock2 = create_stock(available=1)
stock3 = create_stock(available=1)
create_booking(user, stock=stock2, quantity=1)
create_booking(user, stock=stock3, quantity=1)
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFullyBooked is True
def test_on_datetime_list_returns_string_with_date_in_ISO_8601_list(self):
# Given
offer = Offer()
offer.stocks = [
create_stock(offer=offer,
beginning_datetime=now,
end_datetime=now + timedelta(hours=3))
]
# When
serialized_list = serialize(offer.dateRange)
# Then
for datetime in serialized_list:
self._assert_is_in_ISO_8601_format(datetime)
