def test_returns_a_tuple_of_pending_and_not_processable_payments( self, app): # Given offerer1 = create_offerer(siren='123456789') offerer2 = create_offerer(siren='987654321') PcObject.save(offerer1) bank_information = create_bank_information( bic='BDFEFR2LCCB', iban='FR7630006000011234567890189', id_at_providers='123456789', offerer=offerer1) venue1 = create_venue(offerer1, siret='12345678912345') venue2 = create_venue(offerer2, siret='98765432154321') offer1 = create_offer_with_thing_product(venue1) offer2 = create_offer_with_thing_product(venue2) paying_stock1 = create_stock_from_offer(offer1) paying_stock2 = create_stock_from_offer(offer2) free_stock1 = create_stock_from_offer(offer1, price=0) user = create_user() deposit = create_deposit(user, amount=500) booking1 = create_booking(user, paying_stock1, venue1, is_used=True) booking2 = create_booking(user, paying_stock1, venue1, is_used=True) booking3 = create_booking(user, paying_stock2, venue2, is_used=True) booking4 = create_booking(user, free_stock1, venue1, is_used=True) PcObject.save(deposit, booking1, booking2, booking3, booking4, bank_information) # When pending, not_processable = generate_new_payments() # Then assert len(pending) == 2 assert len(not_processable) == 1
def when_read_recommendations_are_given(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_event_product(venue) user = create_user(email='*****@*****.**') event_occurrence1 = create_event_occurrence(offer) event_occurrence2 = create_event_occurrence(offer) stock1 = create_stock_from_event_occurrence(event_occurrence1, soft_deleted=True) stock2 = create_stock_from_event_occurrence(event_occurrence2, soft_deleted=False) thing_offer1 = create_offer_with_thing_product(venue) thing_offer2 = create_offer_with_thing_product(venue) stock3 = create_stock_from_offer(thing_offer1, soft_deleted=True) stock4 = create_stock_from_offer(thing_offer2, soft_deleted=False) recommendation1 = create_recommendation(offer, user) recommendation2 = create_recommendation(thing_offer1, user) recommendation3 = create_recommendation(thing_offer2, user) PcObject.save( stock1, stock2, stock3, stock4, recommendation1, recommendation2, recommendation3 ) read_recommendation_data = [ { "dateRead": "2018-12-17T15:59:11.689000Z", "id": humanize(recommendation1.id) }, { "dateRead": "2018-12-17T15:59:14.689000Z", "id": humanize(recommendation2.id) } ] # When response = TestClient(app.test_client()).with_auth('*****@*****.**') \ .put('{}/read'.format(RECOMMENDATION_URL), json=read_recommendation_data) # Then read_recommendation_date_reads = [r['dateRead'] for r in response.json] assert len(read_recommendation_date_reads) == 2 assert {"2018-12-17T15:59:11.689000Z", "2018-12-17T15:59:14.689000Z"} == set(read_recommendation_date_reads)
def save_sandbox(): offerer = create_offerer() venue = create_venue(offerer, is_virtual=True, siret=None) offer = create_offer_with_thing_product(venue, thing_type=ThingType.ACTIVATION) stock = create_stock_with_thing_offer(offerer, venue, offer=offer, price=0, available=10000) PcObject.save(stock)
def test_returns_has_physical_venues_and_has_offers(self, app): # given user = create_user(email='*****@*****.**') offerer = create_offerer() offerer2 = create_offerer(siren='123456788') user_offerer = create_user_offerer(user, offerer) user_offerer2 = create_user_offerer(user, offerer2) offerer_virtual_venue = create_venue(offerer, is_virtual=True, siret=None) offerer2_physical_venue = create_venue(offerer2, siret='12345678856734') offerer2_virtual_venue = create_venue(offerer, is_virtual=True, siret=None) offer = create_offer_with_thing_product(offerer_virtual_venue, thing_type=ThingType.JEUX_VIDEO_ABO, url='http://fake.url') offer2 = create_offer_with_thing_product(offerer2_physical_venue) PcObject.save(offer, offer2, offerer2_virtual_venue, user_offerer, user_offerer2) # when response = TestClient(app.test_client()).with_auth('*****@*****.**').get('/users/current') # Then assert response.json['hasPhysicalVenues'] is True assert response.json['hasOffers'] is True
def test_thing_offer_offerType_returns_None_if_type_does_not_match_ThingType_enum( ): # given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue, thing_type='') # when offer_type = offer.offerType # then assert offer_type == None
def test_stock_can_have_an_available_stock_equal_to_zero(app): # given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue) stock = create_stock_from_offer(offer, available=0) # when PcObject.save(stock) # then assert stock.available == 0
def test_should_return_zero_bookings_if_they_are_on_activation_offers(self, app): # Given offerer = create_offerer(name='Offerer dans le 93') venue = create_venue(offerer, departement_code='93') offer1 = create_offer_with_thing_product(venue, thing_type=ThingType.ACTIVATION) offer2 = create_offer_with_thing_product(venue, thing_type=EventType.ACTIVATION) stock1 = create_stock(offer=offer1, price=10) stock2 = create_stock(offer=offer2, price=10) user_in_93 = create_user(departement_code='93') create_deposit(user_in_93, amount=500) booking1 = create_booking(user_in_93, stock1, quantity=1) booking2 = create_booking(user_in_93, stock2, quantity=1) PcObject.save(booking1, booking2) # When bookings_by_departement = _query_get_non_cancelled_bookings_by_user_departement() # Then print(bookings_by_departement) assert len(bookings_by_departement) == 0
def test_offer_is_neither_event_nor_thing(self): # Given event_product = Product() offerer = create_offerer() digital_venue = create_venue(offerer, is_virtual=False, siret=None) # When offer = create_offer_with_thing_product(digital_venue, event_product) # Then assert offer.isEvent == False assert offer.isThing == False
def _create_and_save_stock_for_offererer_in_departements( offerer: Offerer, departement_codes: List[str]) -> Stock: stock_list = [] for i, departement_code in enumerate(departement_codes): siret = f'{offerer.siren}{99999 - i}' venue = create_venue(offerer, postal_code="{:<5}".format(departement_code), siret=siret) offer = create_offer_with_thing_product(venue) stock = create_stock(offer=offer, available=10) stock_list.append(stock) return stock_list
def _create_departement_booking_for_users(departement_code, user_email, booking_count, siren): user_having_booked = create_user(departement_code=departement_code, email=user_email) offerer = create_offerer(siren=siren) venue = create_venue(offerer, siret=siren + '12345') offer = create_offer_with_thing_product(venue) stock = create_stock(offer=offer, price=0) for i in range(booking_count): create_booking(user_having_booked, stock, is_cancelled=False) PcObject.save(stock)
def test_titelive_stock_provider_create_2_stock_and_2_offer_even_if_existing_offer_on_same_product(get_data, app): # given get_data.return_value = { 'total': 'null', 'limit': 5000, 'stocks': [ { "ref": "0002730757438", "available": 10, "price": 4500, "validUntil": "2019-10-31T15:10:27Z" }, { "ref": "0002736409898", "available": 2, "price": 100, "validUntil": "2019-10-31T15:10:27Z" } ] } offerer = create_offerer(siren='987654321') venue = create_venue(offerer, name='Librairie Titelive', siret='77567146400110') PcObject.save(venue) tite_live_things_provider = get_provider_by_local_class('TiteLiveThings') venue_provider = VenueProvider() venue_provider.venue = venue venue_provider.provider = tite_live_things_provider venue_provider.isActive = True venue_provider.venueIdAtOfferProvider = '77567146400110' PcObject.save(venue_provider) thing_1 = create_product_with_thing_type(id_at_providers='0002730757438') thing_2 = create_product_with_thing_type(id_at_providers='0002736409898') offer = create_offer_with_thing_product(venue=venue, product=thing_1, id_at_providers="not_titelive") PcObject.save(thing_1, offer, thing_2) # When / Then provider_test(app, TiteLiveStocks, venue_provider, checkedObjects=4, createdObjects=4, updatedObjects=0, erroredObjects=0, checkedThumbs=0, createdThumbs=0, updatedThumbs=0, erroredThumbs=0, Stock=2, Offer=2 )
def save_non_reimbursable_thing_offer(venue: Venue): paid_non_reimbursable_offer = create_offer_with_thing_product( venue, thing_name='Concert en ligne', thing_type=ThingType.JEUX_VIDEO, url='http://my.game.fr') non_reimbursable_stock = create_stock(price=30, offer=paid_non_reimbursable_offer) PcObject.save(non_reimbursable_stock) logger.info( 'created 1 non reimbursable thing offer with 1 paid stock of 30 €') return non_reimbursable_stock
def _create_bookings_with_quantities(quantities: List[int]): siren = 111111111 bookings = [] for i, quantity in enumerate(quantities): offerer = create_offerer(siren=str(siren), name=f'Offerer {i}') venue = create_venue(offerer, siret=offerer.siren + '12345') offer = create_offer_with_thing_product(venue, thing_name=f'{i}') stock = create_stock(offer=offer, price=0, available=1000) user = create_user(email=f'{i}@mail.com') bookings.append(create_booking(user, stock, quantity=quantity)) siren += 1 return bookings
def test_remaining_quantity_for_stock_is_2_when_there_is_no_booking(app): # Given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue) stock = create_stock_from_offer(offer, available=2, price=0) # When PcObject.save(stock) # Then assert Stock.query.get(stock.id).remainingQuantity == 2
def test_file_has_hexadecimal_uuids_as_end_to_end_ids_in_transaction_info( self, mocked_uuid, app): # Given user = create_user() offerer1 = create_offerer(name='first offerer') offerer2 = create_offerer(name='second offerer') venue1 = create_venue(offerer1) venue2 = create_venue(offerer2) stock1 = create_stock_from_offer( create_offer_with_thing_product(venue1)) stock2 = create_stock_from_offer( create_offer_with_thing_product(venue2)) booking1 = create_booking(user, stock1) booking2 = create_booking(user, stock2) uuid1 = UUID(hex='abcd1234abcd1234abcd1234abcd1234', version=4) uuid2 = UUID(hex='cdef5678cdef5678cdef5678cdef5678', version=4) mocked_uuid.side_effect = [uuid1, uuid2] payments = [ create_payment(booking1, offerer1, Decimal(10), iban='CF13QSDFGH456789', bic='QSDFGH8Z555'), create_payment(booking2, offerer1, Decimal(20), iban='FR14WXCVBN123456', bic='WXCVBN7B444'), ] # When xml = generate_message_file(payments, 'BD12AZERTY123456', 'AZERTY9Q666', MESSAGE_ID, '0000') # Then nodes_id = find_all_nodes( '//ns:PmtInf/ns:CdtTrfTxInf/ns:PmtId/ns:EndToEndId', xml) assert nodes_id[0] == uuid1.hex assert nodes_id[1] == uuid2.hex
def when_a_recommendation_is_requested(self, app): # given user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) offer1 = create_offer_with_thing_product(venue, thumb_count=1) offer2 = create_offer_with_event_product(venue, thumb_count=1) offer3 = create_offer_with_thing_product(venue, thumb_count=1) offer4 = create_offer_with_thing_product(venue, thumb_count=1) now = datetime.utcnow() event_occurrence = create_event_occurrence(offer2, beginning_datetime=now + timedelta(hours=72), end_datetime=now + timedelta(hours=74)) mediation = create_mediation(offer2) stock1 = create_stock_from_offer(offer1, price=0) stock2 = create_stock_from_event_occurrence(event_occurrence, price=0, available=10, soft_deleted=False, booking_limit_date=now + timedelta(days=3)) stock3 = create_stock_from_offer(offer3, price=0) stock4 = create_stock_from_offer(offer4, price=0) PcObject.save(user, stock1, stock2, stock3, stock4, mediation) offer1_id = offer1.id offer2_id = offer2.id offer3_id = offer3.id offer4_id = offer4.id auth_request = TestClient(app.test_client()).with_auth(user.email) # when response = auth_request.put(RECOMMENDATION_URL + '?offerId=%s' % humanize(offer1.id), json={'seenRecommendationIds': []}) # then assert response.status_code == 200 response_json = response.json assert len(response_json) == 4 offer_ids = set(map(lambda x: x['offer']['id'], response_json)) assert response_json[0]['offer']['id'] == humanize(offer1_id) assert humanize(offer1_id) in offer_ids assert humanize(offer2_id) in offer_ids assert humanize(offer3_id) in offer_ids assert humanize(offer4_id) in offer_ids
def test_nOffers_with_two_venue_providers_from_different_providers(app): # given provider1 = Provider() provider1.name = 'Open Agenda' provider1.localClass = 'OpenAgenda' provider1.isActive = True provider1.enabledForPro = True provider2 = Provider() provider2.name = 'TiteLive' provider2.localClass = 'TiteLive' provider2.isActive = True provider2.enabledForPro = True PcObject.save(provider1, provider2) offerer = create_offerer() venue = create_venue(offerer) venue_provider1 = create_venue_provider(venue, provider1) venue_provider2 = create_venue_provider(venue, provider2) offer_1 = create_offer_with_thing_product(venue, last_provider_id=provider1.id, id_at_providers='offer1') offer_2 = create_offer_with_event_product(venue, last_provider_id=provider2.id, id_at_providers='offer2') offer_3 = create_offer_with_event_product(venue, last_provider_id=provider1.id, id_at_providers='offer3') offer_4 = create_offer_with_thing_product(venue, last_provider_id=provider1.id, id_at_providers='offer4') PcObject.save(offer_1, offer_2, offer_3, offer_4, venue_provider1, venue_provider2) # when n_offers_for_venue_provider1 = venue_provider1.nOffers n_offers_for_venue_provider2 = venue_provider2.nOffers # then assert n_offers_for_venue_provider1 == 3 assert n_offers_for_venue_provider2 == 1
def test_model_should_have_thumbUrl_using_productId(get_storage_base_url): # given product = create_product_with_thing_type() product.id = 2 offerer = create_offerer() venue = create_venue(offerer=offerer) offer = create_offer_with_thing_product(product=product, venue=venue) # when recommendation = create_recommendation(offer) # then assert recommendation.thumbUrl == "http://localhost/storage/thumbs/products/A9"
def test_does_not_call_save_thumb(self, save_thumb_mock, app): # Given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue) mediation = create_mediation(offer, tuto_index=0) PcObject.save(mediation) # When _upsert_tuto_mediation(0) # Then save_thumb_mock.assert_not_called()
def test_raises_error_with_end_datetime_only(self): # Given offer = create_offer_with_thing_product(Venue()) data = {'endDatetime': serialize(datetime(2019, 2, 14))} # When with pytest.raises(ApiErrors) as e: check_dates_are_allowed_on_existing_stock(data, offer) # Then assert e.value.errors['global'] == [ 'Impossible de mettre des dates de début et fin si l\'offre ne porte pas sur un évenement' ]
def test_full_reimburses_book_product_when_bookings_are_below_20000_euros( self, app): # Given offerer1 = create_offerer(siren='123456789') PcObject.save(offerer1) bank_information = create_bank_information( bic='BDFEFR2LCCB', iban='FR7630006000011234567890189', id_at_providers='123456789', offerer=offerer1) venue1 = create_venue(offerer1, siret='12345678912345') venue2 = create_venue(offerer1, siret='98765432154321') offer1 = create_offer_with_thing_product( venue1, thing_type=ThingType.LIVRE_EDITION, url=None) offer2 = create_offer_with_thing_product( venue2, thing_type=ThingType.LIVRE_EDITION, url=None) paying_stock1 = create_stock_from_offer(offer1, price=10000) paying_stock2 = create_stock_from_offer(offer2, price=19990) user = create_user() deposit = create_deposit(user, amount=50000) booking1 = create_booking(user, paying_stock1, venue1, quantity=1, is_used=True) booking2 = create_booking(user, paying_stock2, venue2, quantity=1, is_used=True) PcObject.save(deposit, booking1, booking2, bank_information) # When pending, not_processable = generate_new_payments() # Then assert len(pending) == 2 assert len(not_processable) == 0 assert sum(p.amount for p in pending) == 29990
def create_n_mixed_offers_with_same_venue(venue, n=10): offers = [] for i in range(n // 2, 0, -1): date_created = datetime.utcnow() - timedelta(days=i) offers.append( create_offer_with_thing_product(venue, date_created=date_created, thing_name='Thing Offer %s' % i)) offers.append( create_offer_with_event_product(venue, event_name='Event Offer %s' % i, date_created=date_created)) return offers
def test_offer_is_marked_as_isevent_property(self): # Given physical_thing = create_product_with_thing_type( thing_type=ThingType.JEUX_VIDEO, url=None) offerer = create_offerer() digital_venue = create_venue(offerer, is_virtual=True, siret=None) # When offer = create_offer_with_thing_product(digital_venue, physical_thing) # Then assert offer.isEvent == False assert offer.isThing == True
def test_offer_is_marked_as_isthing_property(self): # Given event_product = create_product_with_event_type( event_type=EventType.CINEMA) offerer = create_offerer() digital_venue = create_venue(offerer, is_virtual=False, siret=None) # When offer = create_offer_with_thing_product(digital_venue, event_product) # Then assert offer.isEvent == True assert offer.isThing == False
def when_updating_read_recommendations(self, app): # given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_event_product(venue) user = create_user() event_occurrence1 = create_event_occurrence(offer) event_occurrence2 = create_event_occurrence(offer) stock1 = create_stock_from_event_occurrence(event_occurrence1) stock2 = create_stock_from_event_occurrence(event_occurrence2) thing_offer1 = create_offer_with_thing_product(venue) thing_offer2 = create_offer_with_thing_product(venue) stock3 = create_stock_from_offer(thing_offer1) stock4 = create_stock_from_offer(thing_offer2) recommendation1 = create_recommendation(offer, user) recommendation2 = create_recommendation(thing_offer1, user) recommendation3 = create_recommendation(thing_offer2, user) PcObject.save(stock1, stock2, stock3, stock4, recommendation1, recommendation2, recommendation3) auth_request = TestClient(app.test_client()).with_auth(user.email) reads = [ {"id": humanize(recommendation1.id), "dateRead": "2018-12-17T15:59:11.689000Z"}, {"id": humanize(recommendation2.id), "dateRead": "2018-12-17T15:59:15.689000Z"}, {"id": humanize(recommendation3.id), "dateRead": "2018-12-17T15:59:21.689000Z"}, ] data = {'readRecommendations': reads} # when response = auth_request.put(RECOMMENDATION_URL, json=data) # then assert response.status_code == 200 assert recommendation1.dateRead is None assert recommendation2.dateRead is None assert recommendation3.dateRead is None unread_recos = Recommendation.query.filter(Recommendation.dateRead != None).all() assert len(unread_recos) == 3
def test_stock_cannot_have_a_negative_available_stock(app): # given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue) stock = create_stock_from_offer(offer, available=-4) # when with pytest.raises(ApiErrors) as e: PcObject.save(stock) # then assert e.value.errors['available'] == ["Le stock doit être positif"]
def test_stock_cannot_have_a_negative_price(app): # given offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue) stock = create_stock_from_offer(offer, price=-10) # when with pytest.raises(ApiErrors) as e: PcObject.save(stock) # then assert e.value.errors['global'] is not None
def test_file_has_control_sum_in_payment_info(self, app): # Given user = create_user() offerer1 = create_offerer() offerer2 = create_offerer() venue1 = create_venue(offerer1) venue2 = create_venue(offerer2) stock1 = create_stock_from_offer( create_offer_with_thing_product(venue1)) stock2 = create_stock_from_offer( create_offer_with_thing_product(venue2)) booking1 = create_booking(user, stock1) booking2 = create_booking(user, stock2) payments = [ create_payment(booking1, offerer1, Decimal(10), iban='CF13QSDFGH456789', bic='QSDFGH8Z555'), create_payment(booking1, offerer1, Decimal(20), iban='CF13QSDFGH456789', bic='QSDFGH8Z555'), create_payment(booking2, offerer2, Decimal(30), iban=None, bic=None) ] # When xml = generate_message_file(payments, 'BD12AZERTY123456', 'AZERTY9Q666', MESSAGE_ID, '0000') # Then assert find_node('//ns:PmtInf/ns:CtrlSum', xml) == '30', \ 'The control sum should match the total amount of money to pay'
def when_searching_by_date_and_date_range_and_type(self, app): # Given user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_event_product( venue, event_name='The new film', event_type=EventType.CINEMA) offer2 = create_offer_with_event_product( venue, event_name='Spectacle', event_type=EventType.SPECTACLE_VIVANT) thing_product = create_product_with_thing_type( thing_name='Lire un livre', is_national=True) thing_offer = create_offer_with_thing_product(venue, thing_product) event_occurrence = create_event_occurrence( offer, beginning_datetime=self.three_days_from_now, end_datetime=self.three_days_and_one_hour_from_now) recommendation = create_recommendation(offer, user) recommendation2 = create_recommendation(thing_offer, user) recommendation3 = create_recommendation(offer2, user) stock = create_stock_from_event_occurrence(event_occurrence) stock1 = create_stock_from_offer(offer2) thing_stock = create_stock(price=12, available=5, offer=thing_offer) PcObject.save(stock, recommendation, recommendation2, recommendation3, thing_stock, stock1) # When response = TestClient(app.test_client()).with_auth( user.email).get(RECOMMENDATION_URL + '?categories=Lire%2CRegarder' + '&date=%s&days=1-5' % strftime(self.now)) # Then assert response.status_code == 200 recommendations = response.json assert len(recommendations) == 2 recommendation_names = [ recommendation['offer']['product']['name'] for recommendation in recommendations ] assert 'The new film' in recommendation_names assert 'Lire un livre' in recommendation_names assert 'Spectacle' not in recommendation_names
def test_filter_out_recommendation_with_not_bookable_stocks_returns_recos_with_valid_booking_date( app): # Given one_day_ago = datetime.utcnow() - timedelta(days=1) tomorrow = datetime.utcnow() + timedelta(days=1) offerer = create_offerer() venue = create_venue(offerer) user = create_user() invalid_booking_date_offer = create_offer_with_thing_product(venue) valid_booking_date_offer = create_offer_with_thing_product(venue) invalid_booking_date_stock = create_stock_from_offer( invalid_booking_date_offer, booking_limit_datetime=one_day_ago) valid_booking_date_stock_valid = create_stock_from_offer( valid_booking_date_offer, booking_limit_datetime=tomorrow) valid_booking_date_stock_invalid = create_stock_from_offer( valid_booking_date_offer, booking_limit_datetime=one_day_ago) recommendation_on_invalid_booking_date_stock = create_recommendation( invalid_booking_date_offer, user) recommendation_on_valid_booking_date_stock = create_recommendation( valid_booking_date_offer, user) PcObject.save(invalid_booking_date_stock, recommendation_on_invalid_booking_date_stock, recommendation_on_valid_booking_date_stock, valid_booking_date_stock_valid, valid_booking_date_stock_invalid) # When result = keep_only_bookable_stocks().all() # Then recommendation_ids = [r.id for r in result] assert len(recommendation_ids) == 1 assert recommendation_on_valid_booking_date_stock.id in recommendation_ids