def should_connect_venue_when_synchronization_is_allowed(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) provider = activate_provider("PraxielStocks") repository.save(venue) self.find_by_id.return_value = venue stock_repository = MagicMock() stock_repository.can_be_synchronized.return_value = True provider_type = PraxielStocks venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } # When connect_venue_to_provider(provider_type, stock_repository, venue_provider_payload, self.find_by_id) # Then praxiel_venue_provider = VenueProvider.query.one() assert praxiel_venue_provider.venue == venue
def test_allocine_venue_provider_is_successfully_updated(self, app): # Given user_offerer = offer_factories.UserOffererFactory() user = user_offerer.user offerer = user_offerer.offerer venue = offer_factories.VenueFactory(managingOfferer=offerer) provider = offerers_factories.AllocineProviderFactory() venue_provider = offerers_factories.AllocineVenueProviderFactory( venue=venue, provider=provider, isDuo=False, quantity=42, ) offerers_factories.AllocineVenueProviderPriceRuleFactory(allocineVenueProvider=venue_provider, price=10) updated_venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "isDuo": True, "quantity": 77, "price": 64, } auth_request = TestClient(app.test_client()).with_session_auth(email=user.email) # When response = auth_request.put("/venueProviders", json=updated_venue_provider_data) # Then assert response.status_code == 200 assert response.json["provider"]["id"] == humanize(provider.id) assert response.json["venueId"] == humanize(venue.id) assert response.json["quantity"] == updated_venue_provider_data["quantity"] assert response.json["price"] == updated_venue_provider_data["price"] assert response.json["isDuo"] == updated_venue_provider_data["isDuo"]
def get_expected_base_email_data(booking, mediation, **overrides): email_data = { "FromEmail": "*****@*****.**", "MJ-TemplateID": 1163067, "MJ-TemplateLanguage": True, "To": "*****@*****.**", "Vars": { "user_first_name": "Joe", "booking_date": "3 octobre", "booking_hour": "15h24", "offer_name": "Super événement", "offerer_name": "Théâtre du coin", "event_date": "6 novembre", "event_hour": "15h59", "offer_price": "23.99", "offer_token": "ABC123", "venue_name": "Lieu de l'offreur", "venue_address": "25 avenue du lieu", "venue_postal_code": "75010", "venue_city": "Paris", "all_but_not_virtual_thing": 1, "all_things_not_virtual_thing": 0, "is_event": 1, "is_single_event": 1, "is_duo_event": 0, "can_expire": 0, "offer_id": humanize(booking.stock.offer.id), "mediation_id": humanize(mediation.id), "env": "", }, } email_data["Vars"].update(overrides) return email_data
def test_should_humanize_ids(self): # Given user = create_user(email="*****@*****.**", public_name="John Doe") offerer = create_offerer() venue = create_venue(offerer, name="Venue name", address="Venue address") offer = create_offer_with_event_product(venue=venue, event_name="Event Name", event_type=EventType.CINEMA, idx=999) event_occurrence = create_event_occurrence( offer, beginning_datetime=datetime.utcnow()) stock = create_stock_from_event_occurrence(event_occurrence, price=12) booking = create_booking(user=user, quantity=3, stock=stock, venue=venue) # When response = serialize_booking(booking) # Then assert response["bookingId"] == humanize(booking.id) assert response["offerId"] == offer.id assert response["publicOfferId"] == humanize(offer.id)
def when_mediation_is_edited(self, app): # given mediation = offers_factories.MediationFactory() offerer = mediation.offer.venue.managingOfferer offers_factories.UserOffererFactory( user__email="*****@*****.**", offerer=offerer, ) # when client = TestClient(app.test_client()).with_auth(email="*****@*****.**") data = {"isActive": False} response = client.patch(f"/mediations/{humanize(mediation.id)}", json=data) # then mediation = Mediation.query.one() assert not mediation.isActive assert response.status_code == 200 assert response.json["id"] == humanize(mediation.id) assert response.json["thumbUrl"] == mediation.thumbUrl assert response.json == { "authorId": None, "credit": None, "dateCreated": format_into_utc_date(mediation.dateCreated), "dateModifiedAtLastProvider": format_into_utc_date(mediation.dateModifiedAtLastProvider), "fieldsUpdated": [], "id": humanize(mediation.id), "idAtProviders": None, "isActive": data["isActive"], "lastProviderId": None, "offerId": humanize(mediation.offer.id), "thumbCount": 0, "thumbUrl": None, }
def test_erase_former_mediations(self): # Given user = users_factories.UserFactory() offer = factories.ThingOfferFactory() image_as_bytes = (IMAGES_DIR / "mouette_full_size.jpg").read_bytes() existing_number_of_files = len(os.listdir(self.THUMBS_DIR)) mediation_1 = api.create_mediation_v2(user, offer, "©Photographe", image_as_bytes) mediation_2 = api.create_mediation_v2(user, offer, "©Alice", image_as_bytes) thumb_1_id = humanize(mediation_1.id) thumb_2_id = humanize(mediation_2.id) # When api.create_mediation_v2(user, offer, "©moi", image_as_bytes) # Then mediation_3 = models.Mediation.query.one() assert mediation_3.credit == "©moi" thumb_3_id = humanize(mediation_3.id) assert not (self.THUMBS_DIR / thumb_1_id).exists() assert not (self.THUMBS_DIR / (thumb_1_id + ".type")).exists() assert not (self.THUMBS_DIR / thumb_2_id).exists() assert not (self.THUMBS_DIR / (thumb_2_id + ".type")).exists() assert len(os.listdir(self.THUMBS_DIR)) == existing_number_of_files + 2 assert (self.THUMBS_DIR / thumb_3_id).exists() assert (self.THUMBS_DIR / (thumb_3_id + ".type")).exists()
def when_listing_all_venues_with_a_valid_venue_id(self, app): # given offerer = create_offerer(siren="775671464") venue = create_venue(offerer, name="Librairie Titelive", siret="77567146400110") titelive_things_provider = get_provider_by_local_class( "TiteLiveThings") venue_provider = create_venue_provider( venue=venue, provider=titelive_things_provider) repository.save(venue_provider) user = create_user() repository.save(user) auth_request = TestClient( app.test_client()).with_auth(email=user.email) # when response = auth_request.get("/venueProviders?venueId=" + humanize(venue.id)) # then assert response.status_code == 200 assert response.json[0].get("id") == humanize(venue_provider.id) assert response.json[0].get("venueId") == humanize(venue.id)
def test_response_serialization(app): user_offerer = offers_factories.UserOffererFactory( user__email="*****@*****.**", ) venue = offers_factories.VenueFactory(managingOfferer=user_offerer.offerer) # when response = TestClient(app.test_client()).with_session_auth(user_offerer.user.email).get("/venues") # then assert response.status_code == 200 assert "venues" in response.json assert len(response.json["venues"]) == 1 assert response.json["venues"][0] == { "id": humanize(venue.id), "managingOffererId": humanize(venue.managingOffererId), "name": venue.name, "offererName": user_offerer.offerer.name, "publicName": venue.publicName, "isVirtual": venue.isVirtual, "bookingEmail": venue.bookingEmail, "withdrawalDetails": venue.withdrawalDetails, "audioDisabilityCompliant": venue.audioDisabilityCompliant, "mentalDisabilityCompliant": venue.mentalDisabilityCompliant, "motorDisabilityCompliant": venue.motorDisabilityCompliant, "visualDisabilityCompliant": venue.visualDisabilityCompliant, }
def when_add_allocine_stocks_provider_with_price_but_no_isDuo_config( self, stubbed_get_theaterid_for_venue, stubbed_find_by_id, app ): # Given offerer = create_offerer(siren="775671464") venue = create_venue(offerer) user = create_user(is_admin=True, is_beneficiary=False) allocine_pivot = create_allocine_pivot(siret=venue.siret) repository.save(venue, user, allocine_pivot) stubbed_find_by_id.return_value = venue stubbed_get_theaterid_for_venue.return_value = allocine_pivot.theaterId provider = activate_provider("AllocineStocks") venue_provider_data = {"providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99"} auth_request = TestClient(app.test_client()).with_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201 json = response.json assert "_sa_polymorphic_on" not in json venue_provider = VenueProvider.query.one() assert json["venueId"] == humanize(venue_provider.venueId)
def should_connect_venue_to_allocine_provider(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) provider = activate_provider("AllocineStocks") allocine_pivot = create_allocine_pivot(siret=venue.siret) repository.save(venue, allocine_pivot) self.find_by_id.return_value = venue self.get_theaterid_for_venue.return_value = allocine_pivot.theaterId venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99", "isDuo": True, "quantity": 50, } # When connect_venue_to_allocine(venue_provider_payload, self.find_by_id, self.get_theaterid_for_venue) # Then allocine_venue_provider = AllocineVenueProvider.query.one() venue_provider_price_rule = AllocineVenueProviderPriceRule.query.one() assert allocine_venue_provider.venue == venue assert allocine_venue_provider.isDuo assert allocine_venue_provider.quantity == 50 assert venue_provider_price_rule.price == Decimal("9.99")
def when_offer_is_added_as_favorite_for_current_user(self, app): # Given user = create_user(email="*****@*****.**") offerer = create_offerer() venue = create_venue(offerer, postal_code="29100", siret="12345678912341") offer = create_offer_with_thing_product(venue, thumb_count=0) mediation = create_mediation(offer, is_active=True) repository.save(user, mediation) json = { "offerId": humanize(offer.id), "mediationId": humanize(mediation.id), } # When response = TestClient(app.test_client()).with_auth( user.email).post("/favorites", json=json) # Then assert response.status_code == 201 favorite = FavoriteSQLEntity.query.one() assert favorite.offerId == offer.id assert favorite.mediationId == mediation.id assert favorite.userId == user.id
def should_not_connect_venue_when_venue_has_no_siret(self, app): # Given offerer = create_offerer() venue = create_venue(offerer, siret=None, is_virtual=True) provider = activate_provider("LibrairesStocks") repository.save(venue) self.find_by_id.return_value = venue stock_repository = MagicMock() provider_type = LibrairesStocks venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } # when with pytest.raises(ApiErrors) as error: connect_venue_to_provider(provider_type, stock_repository, venue_provider_payload, self.find_by_id) # then assert error.value.errors["provider"] == [ "L’importation d’offres avec LesLibraires n’est pas disponible sans SIRET associé au lieu. Ajoutez un SIRET pour pouvoir importer les offres." ]
def should_not_connect_venue_when_synchronization_is_not_allowed( self, app): # Given offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") provider = activate_provider("LibrairesStocks") repository.save(venue) self.find_by_id.return_value = venue stock_repository = MagicMock() stock_repository.can_be_synchronized.return_value = False provider_class = LibrairesStocks venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } # when with pytest.raises(ApiErrors) as error: print( connect_venue_to_provider(provider_class, stock_repository, venue_provider_payload, self.find_by_id)) # then assert error.value.errors["provider"] == [ "L’importation d’offres avec LesLibraires n’est pas disponible pour le SIRET 12345678912345" ]
def should_raise_an_error(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) provider = create_provider(local_class="TestLocalProvider") repository.save(venue, provider) self.find_by_id.return_value = venue stock_repository = MagicMock() provider_type = TestLocalProvider venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } # When with pytest.raises(ApiErrors) as error: connect_venue_to_provider(provider_type, stock_repository, venue_provider_payload, self.find_by_id) # Then assert error.value.errors["provider"] == [ "Provider non pris en charge" ]
def when_mediation_is_created_with_bad_thumb_url(self, app): # given offer = offers_factories.ThingOfferFactory() offerer = offer.venue.managingOfferer offers_factories.UserOffererFactory( user__email="*****@*****.**", offerer=offerer, ) # when client = TestClient( app.test_client()).with_auth(email="*****@*****.**") data = { "offerId": humanize(offer.id), "offererId": humanize(offerer.id), "thumbUrl": "https://example.com/image.jpg", } with requests_mock.Mocker() as mock: mock.get("https://example.com/image.jpg", status_code=404) response = client.post("/mediations", form=data) # then assert response.status_code == 400 assert response.json == { "thumbUrl": ["L'adresse saisie n'est pas valide"] }
def when_add_allocine_stocks_provider_with_default_settings_at_import(self, stubbed_find_by_id, app): # Given offerer = create_offerer(siren="775671464") venue = create_venue(offerer) user = create_user(is_admin=True, is_beneficiary=False) repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99", "available": 50, "isDuo": True, } auth_request = TestClient(app.test_client()).with_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201
def get_expected_base_email_data(booking, **overrides): offer_id = humanize(booking.stock.offer.id) venue_id = humanize(booking.stock.offer.venue.id) offerer_id = humanize(booking.stock.offer.venue.managingOfferer.id) email_data = { "MJ-TemplateID": 2418750, "MJ-TemplateLanguage": True, "Headers": { "Reply-To": "*****@*****.**", }, "Vars": { "nom_offre": "Super événement", "nom_lieu": "Lieu de l'offreur", "prix": "Gratuit", "date": "06-Nov-2019", "heure": "15h59", "quantity": 1, "user_firstName": "John", "user_lastName": "Doe", "user_email": "*****@*****.**", "user_phoneNumber": "", "is_event": 1, "can_expire": 0, "contremarque": "ABC123", "ISBN": "", "lien_offre_pcpro": f"http://localhost:3001/offres/{offer_id}?lieu={venue_id}&structure={offerer_id}", "offer_type": "EventType.SPECTACLE_VIVANT", "departement": "75", }, } email_data["Vars"].update(overrides) return email_data
def when_add_allocine_stocks_provider_with_wrong_format_price(self, stubbed_find_by_id, app): # Given offerer = create_offerer(siren="775671464") venue = create_venue(offerer) user = create_user(is_admin=True, is_beneficiary=False) repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "wrong_price", } auth_request = TestClient(app.test_client()).with_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 400 assert response.json["global"] == ["Le prix doit être un nombre décimal"] assert VenueProvider.query.count() == 0
def test_create_offer_from_existing_product( self, mocked_offer_creation_notification_to_admin): product = factories.ProductFactory( name="An excellent offer", type=str(offer_type.EventType.CINEMA), ) venue = factories.VenueFactory() offerer = venue.managingOfferer user_offerer = factories.UserOffererFactory(offerer=offerer) user = user_offerer.user data = offers_serialize.PostOfferBodyModel( venueId=humanize(venue.id), productId=humanize(product.id), externalTicketOfficeUrl="http://example.net", audioDisabilityCompliant=True, mentalDisabilityCompliant=True, motorDisabilityCompliant=True, visualDisabilityCompliant=True, ) offer = api.create_offer(data, user) assert offer.name == "An excellent offer" assert offer.type == str(offer_type.EventType.CINEMA) assert offer.product == product assert offer.externalTicketOfficeUrl == "http://example.net" assert offer.audioDisabilityCompliant assert offer.mentalDisabilityCompliant assert offer.motorDisabilityCompliant assert offer.visualDisabilityCompliant assert Offer.query.count() == 1 mocked_offer_creation_notification_to_admin.assert_called_once_with( offer, user)
def when_provider_api_not_available(self, stubbed_find_by_id, stubbed_check, app): # Given user = create_user(is_admin=True, is_beneficiary=False) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("LibrairesStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient(app.test_client()).with_auth(email=user.email) errors = ApiErrors() errors.status_code = 422 errors.add_error( "provider", "L’importation d’offres avec LesLibraires n’est pas disponible " "pour le SIRET 12345678912345", ) stubbed_check.side_effect = [errors] # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 422 assert response.json["provider"] == [ "L’importation d’offres avec LesLibraires n’est pas disponible pour le SIRET 12345678912345" ] assert VenueProvider.query.count() == 0
def test_should_return_booking_with_expected_information(self): # Given booking = BookingFactory( amount=1, quantity=1, token="GQTQR9", stock__price=10, ) # When serialized = serialize_booking_minimal(booking) # Then assert serialized == { "amount": 1.0, "isCancelled": booking.isCancelled, "id": humanize(booking.id), "stockId": humanize(booking.stockId), "quantity": 1, "stock": { "price": 10, }, "token": "GQTQR9", "completedUrl": None, }
def should_inject_the_appropriate_repository_to_the_usecase( self, mocked_connect_venue_to_provider, stubbed_find_by_id, stubbed_check, app ): # Given user = create_user(is_admin=True, is_beneficiary=False) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("LibrairesStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient(app.test_client()).with_auth(email=user.email) stubbed_check.return_value = True # When auth_request.post("/venueProviders", json=venue_provider_data) # Then mocked_connect_venue_to_provider.assert_called_once_with( LibrairesStocks, api_libraires_stocks, {"providerId": humanize(provider.id), "venueId": humanize(venue.id)}, stubbed_find_by_id, )
def test_booking_creation_with_activation_code(self, app): # Given user = users_factories.BeneficiaryGrant18Factory() stock = offers_factories.StockWithActivationCodesFactory( activationCodes=["code-vgya451afvyux"], offer__url="https://new.example.com?token={token}") # When data = {"stockId": humanize(stock.id), "quantity": 1} client = TestClient(app.test_client()).with_session_auth(user.email) response = client.post("/bookings", json=data) # Then assert response.status_code == 201 booking = bookings_models.Booking.query.one() assert response.json == { "amount": 10.0, "completedUrl": "https://new.example.com?token=code-vgya451afvyux", "id": humanize(booking.id), "isCancelled": False, "quantity": 1, "stock": { "price": 10.0 }, "stockId": humanize(stock.id), "token": booking.token, "activationCode": { "code": "code-vgya451afvyux", "expirationDate": None }, "qrCode": booking.qrCode, }
def when_venue_provider_is_successfully_created( self, stubbed_find_by_id, stubbed_check, mock_synchronize_venue_provider, app ): # Given user = create_user(is_admin=True, is_beneficiary=False) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("LibrairesStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient(app.test_client()).with_auth(email=user.email) stubbed_check.return_value = True # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201 venue_provider = VenueProvider.query.one() assert venue_provider.venueId == venue.id assert venue_provider.providerId == provider.id assert venue_provider.venueIdAtOfferProvider == "12345678912345" assert "id" in response.json venue_provider_id = response.json["id"] mock_synchronize_venue_provider.assert_called_once_with(dehumanize(venue_provider_id))
def expect_the_booking_to_be_cancelled_by_current_user(self, app): # Given in_four_days = datetime.utcnow() + timedelta(days=4) stock = offers_factories.EventStockFactory( beginningDatetime=in_four_days) booking = bookings_factories.BookingFactory(stock=stock) # When client = TestClient(app.test_client()).with_auth(booking.user.email) response = client.put(f"/bookings/{humanize(booking.id)}/cancel") # Then assert response.status_code == 200 assert Booking.query.get(booking.id).isCancelled assert response.json == { "amount": 10.0, "completedUrl": None, "id": humanize(booking.id), "isCancelled": True, "quantity": booking.quantity, "stock": { "price": 10.0 }, "stockId": humanize(stock.id), "token": booking.token, }
def when_mediation_is_created_with_thumb_url(self, app): # given offer = offers_factories.ThingOfferFactory() offerer = offer.venue.managingOfferer offers_factories.UserOffererFactory( user__email="*****@*****.**", offerer=offerer, ) # when client = TestClient( app.test_client()).with_auth(email="*****@*****.**") image_as_bytes = (IMAGES_DIR / "mouette_full_size.jpg").read_bytes() data = { "offerId": humanize(offer.id), "offererId": humanize(offerer.id), "thumbUrl": "https://example.com/image.jpg", } with requests_mock.Mocker() as mock: mock.get( "https://example.com/image.jpg", content=image_as_bytes, headers={"Content-Type": "image/jpeg"}, ) response = client.post("/mediations", form=data) # then assert response.status_code == 201 mediation = Mediation.query.one() assert mediation.thumbCount == 1 assert response.json == { "id": humanize(mediation.id), }
def test_user_has_right_on_venue(self, app): # Given user = user_factories.ProFactory() owner_offerer = offer_factories.UserOffererFactory() offerer = owner_offerer.offerer venue = offer_factories.VenueFactory(managingOfferer=offerer) provider = offerers_factories.AllocineProviderFactory() venue_provider = offerers_factories.AllocineVenueProviderFactory( venue=venue, provider=provider, isDuo=False, quantity=42, ) offerers_factories.AllocineVenueProviderPriceRuleFactory(allocineVenueProvider=venue_provider, price=10) updated_venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "isDuo": True, "quantity": 77, "price": 64, } auth_request = TestClient(app.test_client()).with_session_auth(email=user.email) # When response = auth_request.put("/venueProviders", json=updated_venue_provider_data) # Then assert response.status_code == 403
def when_mediation_is_created_with_thumb_file(self, app): # given offer = offers_factories.ThingOfferFactory() offerer = offer.venue.managingOfferer offers_factories.UserOffererFactory( user__email="*****@*****.**", offerer=offerer, ) # when client = TestClient( app.test_client()).with_auth(email="*****@*****.**") thumb = (IMAGES_DIR / "mouette_full_size.jpg").read_bytes() files = { "offerId": humanize(offer.id), "offererId": humanize(offerer.id), "thumb": (BytesIO(thumb), "image.png"), } response = client.post("/mediations", files=files) # then assert response.status_code == 201 mediation = Mediation.query.one() assert mediation.thumbCount == 1 assert response.status_code == 201
def test_should_consider_the_venue_to_be_permanent(self, app): # given offerer = create_offerer(siren="302559178") user = create_user() user_offerer = create_user_offerer(user, offerer) venue_type = create_venue_type(label="Musée") venue_label = create_venue_label( label="CAC - Centre d'art contemporain d'intérêt national") repository.save(user_offerer, venue_type, venue_label) auth_request = TestClient( app.test_client()).with_auth(email=user.email) venue_data = { "name": "Ma venue", "siret": "30255917810045", "address": "75 Rue Charles Fourier, 75013 Paris", "postalCode": "75200", "bookingEmail": "*****@*****.**", "city": "Paris", "managingOffererId": humanize(offerer.id), "latitude": 48.82387, "longitude": 2.35284, "publicName": "Ma venue publique", "venueTypeId": humanize(venue_type.id), "venueLabelId": humanize(venue_label.id), } # when auth_request.post("/venues", json=venue_data) # then venue = Venue.query.one() assert venue.isPermanent == True
def when_offer_is_added_as_favorite_for_current_user(self, app): # Given user = users_factories.BeneficiaryGrant18Factory( email="*****@*****.**") offerer = create_offerer() venue = create_venue(offerer, postal_code="29100", siret="12345678912341") offer = create_offer_with_thing_product(venue, thumb_count=0) mediation = create_mediation(offer, is_active=True) repository.save(mediation) json = { "offerId": humanize(offer.id), "mediationId": humanize(mediation.id), } # When response = TestClient(app.test_client()).with_session_auth( user.email).post("/favorites", json=json) # Then assert response.status_code == 201 favorite = Favorite.query.one() assert favorite.offerId == offer.id assert favorite.mediationId == mediation.id assert favorite.userId == user.id # One call should be sent to batch, and one to sendinblue assert len(push_testing.requests) == 1 assert len(users_testing.sendinblue_requests) == 1 sendinblue_data = users_testing.sendinblue_requests[0] assert sendinblue_data["attributes"][ "LAST_FAVORITE_CREATION_DATE"] is not None