def test_get_user_canteens(self): """ Users can have access to the full representation of their canteens (even if they are not published). This endpoint is paginated """ user_canteens = [ ManagerInvitationFactory.create().canteen, ManagerInvitationFactory.create().canteen, ] other_canteens = [ CanteenFactory.create(), CanteenFactory.create(), ] user = authenticate.user for canteen in user_canteens: canteen.managers.add(user) response = self.client.get(reverse("user_canteens")) self.assertEqual(response.status_code, status.HTTP_200_OK) body = response.json().get("results") for user_canteen in user_canteens: self.assertTrue(any(x["id"] == user_canteen.id for x in body)) for recieved_canteen in body: self.assertEqual(recieved_canteen["managers"][0]["email"], user.email) self.assertTrue( "email" in recieved_canteen["managerInvitations"][0]) for other_canteen in other_canteens: self.assertFalse(any(x["id"] == other_canteen.id for x in body))
def test_plastic_badge_earned(self): """ Test that the right canteens are identifies in plastic badge qs """ # --- canteens which don't earn no_cooking = CanteenFactory.create() DiagnosticFactory.create(canteen=no_cooking, cooking_plastic_substituted=False) no_serving = CanteenFactory.create() DiagnosticFactory.create(canteen=no_serving, serving_plastic_substituted=False) no_bottles = CanteenFactory.create() DiagnosticFactory.create(canteen=no_bottles, plastic_bottles_substituted=False) no_tableware = CanteenFactory.create() DiagnosticFactory.create(canteen=no_tableware, plastic_tableware_substituted=False) # --- canteens which earn plastic badge: earned = CanteenFactory.create() DiagnosticFactory.create( canteen=earned, cooking_plastic_substituted=True, serving_plastic_substituted=True, plastic_bottles_substituted=True, plastic_tableware_substituted=True, ) badges = badges_for_queryset(Diagnostic.objects.all()) plastic_badge_qs = badges["plastic"] self.assertEqual(plastic_badge_qs.count(), 1) self.assertTrue(plastic_badge_qs.filter(canteen=earned).exists())
def test_get_published_canteens(self): """ Only published canteens with public data should be returned from this call """ published_canteens = [ CanteenFactory.create(publication_status=Canteen.PublicationStatus.PUBLISHED.value), CanteenFactory.create(publication_status=Canteen.PublicationStatus.PUBLISHED.value), ] private_canteens = [ CanteenFactory.create(), CanteenFactory.create(publication_status=Canteen.PublicationStatus.PENDING.value), ] response = self.client.get(reverse("published_canteens")) self.assertEqual(response.status_code, status.HTTP_200_OK) body = response.json() self.assertEqual(body.get("count"), 2) results = body.get("results", []) for published_canteen in published_canteens: self.assertTrue(any(x["id"] == published_canteen.id for x in results)) for private_canteen in private_canteens: self.assertFalse(any(x["id"] == private_canteen.id for x in results)) for recieved_canteen in results: self.assertFalse("managers" in recieved_canteen) self.assertFalse("managerInvitations" in recieved_canteen)
def test_available_filter_options(self): """ Test that filter options with data are included in purchases list response """ first_canteen = CanteenFactory.create() first_canteen.managers.add(authenticate.user) second_canteen = CanteenFactory.create() second_canteen.managers.add(authenticate.user) PurchaseFactory.create( description="avoine", canteen=first_canteen, category=Purchase.Category.PRODUITS_DE_LA_MER, characteristics=[Purchase.Characteristic.BIO], ) PurchaseFactory.create( description="tomates", canteen=first_canteen, category=Purchase.Category.FRUITS_ET_LEGUMES, characteristics=[], ) PurchaseFactory.create( description="pommes", canteen=second_canteen, category=Purchase.Category.PRODUITS_LAITIERS, characteristics=[Purchase.Characteristic.LABEL_ROUGE], ) not_my_canteen = CanteenFactory.create() PurchaseFactory.create( description="secret", canteen=not_my_canteen, category=Purchase.Category.ALIMENTS_INFANTILES, characteristics=[Purchase.Characteristic.COMMERCE_EQUITABLE], ) response = self.client.get(f"{reverse('purchase_list_create')}") self.assertEqual(response.status_code, status.HTTP_200_OK) body = response.json() categories = body.get("categories", []) self.assertEqual(len(categories), 3) self.assertIn(Purchase.Category.PRODUITS_DE_LA_MER, categories) self.assertNotIn(Purchase.Category.ALIMENTS_INFANTILES, categories) self.assertEqual(len(body.get("characteristics", [])), 2) canteens = body.get("canteens", []) self.assertEqual(len(canteens), 2) self.assertNotIn(not_my_canteen.id, canteens) response = self.client.get( f"{reverse('purchase_list_create')}?characteristics={Purchase.Characteristic.BIO}" ) body = response.json() self.assertEqual(len(body["categories"]), 1) response = self.client.get( f"{reverse('purchase_list_create')}?category={Purchase.Category.PRODUITS_LAITIERS}" ) body = response.json() self.assertEqual(len(body["characteristics"]), 1)
def test_pagination_management_types(self): CanteenFactory.create(publication_status="published", management_type="conceded", name="Shiso") CanteenFactory.create(publication_status="published", management_type=None, name="Wasabi") url = f"{reverse('published_canteens')}" response = self.client.get(url) body = response.json() self.assertEqual(len(body.get("managementTypes")), 1) self.assertIn("conceded", body.get("managementTypes"))
def test_search_accented_result(self): CanteenFactory.create(publication_status="published", name="Wakamé") CanteenFactory.create(publication_status="published", name="Shiitaké") search_term = "wakame" response = self.client.get(f"{reverse('published_canteens')}?search={search_term}") self.assertEqual(response.status_code, status.HTTP_200_OK) results = response.json().get("results", []) self.assertEqual(len(results), 1) self.assertEqual(results[0].get("name"), "Wakamé")
def test_cannot_update_canteen_for_reservation_expe(self): """ Check that cannot update canteen on a reservation expe """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) reservation_expe = ReservationExpeFactory.create(canteen=canteen) payload = {"canteen": CanteenFactory.create().id} response = self.client.patch(reverse("canteen_reservation_expe", kwargs={"canteen_pk": canteen.id}), payload) self.assertEqual(response.status_code, status.HTTP_200_OK) reservation_expe.refresh_from_db() self.assertEqual(reservation_expe.canteen, canteen)
def test_sectors_filter(self): school = SectorFactory.create(name="School") enterprise = SectorFactory.create(name="Enterprise") social = SectorFactory.create(name="Social") CanteenFactory.create(publication_status="published", sectors=[school], name="Shiso") CanteenFactory.create(publication_status="published", sectors=[enterprise], name="Wasabi") CanteenFactory.create(publication_status="published", sectors=[social], name="Mochi") CanteenFactory.create(publication_status="published", sectors=[school, social], name="Umami") url = f"{reverse('published_canteens')}?sectors={school.id}" response = self.client.get(url) results = response.json().get("results", []) self.assertEqual(len(results), 2) result_names = list(map(lambda x: x.get("name"), results)) self.assertIn("Shiso", result_names) self.assertIn("Umami", result_names) url = f"{reverse('published_canteens')}?sectors={enterprise.id}" response = self.client.get(url) results = response.json().get("results", []) self.assertEqual(len(results), 1) self.assertEqual(results[0].get("name"), "Wasabi") url = f"{reverse('published_canteens')}?sectors={enterprise.id}§ors={social.id}" response = self.client.get(url) results = response.json().get("results", []) self.assertEqual(len(results), 3) result_names = list(map(lambda x: x.get("name"), results)) self.assertIn("Wasabi", result_names) self.assertIn("Mochi", result_names) self.assertIn("Umami", result_names)
def test_pagination_sectors(self): """ The pagination endpoint should return all sectors that are used by canteens, even when the data is filtered by another sector """ school = SectorFactory.create(name="School") enterprise = SectorFactory.create(name="Enterprise") administration = SectorFactory.create(name="Administration") # unused sectors shouldn't show up as an option SectorFactory.create(name="Unused") CanteenFactory.create(publication_status="published", sectors=[school, enterprise], name="Shiso") CanteenFactory.create(publication_status="published", sectors=[school], name="Wasabi") CanteenFactory.create(publication_status="published", sectors=[school], name="Mochi") CanteenFactory.create(publication_status="published", sectors=[administration], name="Umami") url = f"{reverse('published_canteens')}" response = self.client.get(url) body = response.json() self.assertEqual(len(body.get("sectors")), 3) self.assertIn(school.id, body.get("sectors")) self.assertIn(enterprise.id, body.get("sectors")) self.assertIn(administration.id, body.get("sectors")) url = f"{reverse('published_canteens')}?sectors={enterprise.id}" response = self.client.get(url) body = response.json() self.assertEqual(len(body.get("sectors")), 3) self.assertIn(school.id, body.get("sectors")) self.assertIn(enterprise.id, body.get("sectors")) self.assertIn(administration.id, body.get("sectors"))
def test_canteen_stats_by_department(self): department = "01" year = 2020 CanteenFactory.create( department=department, publication_status=Canteen.PublicationStatus.PUBLISHED.value) response = self.client.get(reverse("canteen_statistics"), { "department": department, "year": year }) self.assertEqual(response.status_code, status.HTTP_200_OK) body = response.json() self.assertEqual(body["canteenCount"], 1)
def test_get_purchase_options(self): """ A manager should be able to retrieve a list of products and providers that they've already entered on their own purchases """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) PurchaseFactory.create(description="avoine", canteen=canteen, provider="provider1") PurchaseFactory.create(description="pommes", canteen=canteen, provider="provider2") PurchaseFactory.create(description="pommes", canteen=canteen, provider="provider1") PurchaseFactory.create(description=None, canteen=canteen, provider=None) PurchaseFactory.create(description="secret product", provider="secret provider") response = self.client.get(f"{reverse('purchase_options')}") self.assertEqual(response.status_code, status.HTTP_200_OK) body = response.json() self.assertEqual(len(body["products"]), 2) self.assertEqual(len(body["providers"]), 2) self.assertIn("avoine", body["products"]) self.assertIn("provider2", body["providers"]) self.assertNotIn("secret product", body["products"]) self.assertNotIn("secret provider", body["providers"])
def test_modify_canteen(self): """ Users can modify the canteens they manage """ canteen = CanteenFactory.create(city="Paris") canteen.managers.add(authenticate.user) payload = { "city": "Lyon", "siret": "21340172201787", "managementType": "direct", "reservationExpeParticipant": True, "satelliteCanteensCount": 130, "productionType": "central", } response = self.client.patch( reverse("single_canteen", kwargs={"pk": canteen.id}), payload) self.assertEqual(response.status_code, status.HTTP_200_OK) created_canteen = Canteen.objects.get(pk=canteen.id) self.assertEqual(created_canteen.city, "Lyon") self.assertEqual(created_canteen.siret, "21340172201787") self.assertEqual(created_canteen.management_type, "direct") self.assertEqual(created_canteen.satellite_canteens_count, 130) self.assertEqual(created_canteen.production_type, "central") self.assertEqual(created_canteen.reservation_expe_participant, True)
def test_filter_by_date(self): canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) PurchaseFactory.create(description="avoine", canteen=canteen, date="2020-01-01") PurchaseFactory.create(description="tomates", canteen=canteen, date="2020-01-02") PurchaseFactory.create(description="pommes", canteen=canteen, date="2020-02-01") response = self.client.get( f"{reverse('purchase_list_create')}?date_after=2020-01-02") self.assertEqual(response.status_code, status.HTTP_200_OK) results = response.json().get("results", []) self.assertEqual(len(results), 2) response = self.client.get( f"{reverse('purchase_list_create')}?date_before=2020-01-01") self.assertEqual(response.status_code, status.HTTP_200_OK) results = response.json().get("results", []) self.assertEqual(len(results), 1) response = self.client.get( f"{reverse('purchase_list_create')}?date_after=2020-01-02&date_before=2020-02-01" ) self.assertEqual(response.status_code, status.HTTP_200_OK) results = response.json().get("results", []) self.assertEqual(len(results), 2)
def test_updates_bad_data(self): """ Check that updates with bad data are rejected """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) vegetarian_expe = VegetarianExpeFactory.create( canteen=canteen, satisfaction_guests_t0=3, waste_vegetarian_not_served_t0=70) response = self.client.patch( reverse("canteen_vegetarian_expe", kwargs={"canteen_pk": canteen.id}), {"satisfactionGuestsT0": 6}, ) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) vegetarian_expe.refresh_from_db() self.assertEqual(vegetarian_expe.satisfaction_guests_t0, 3) response = self.client.patch( reverse("canteen_vegetarian_expe", kwargs={"canteen_pk": canteen.id}), {"wasteVegetarianNotServedT0": -90}, ) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) vegetarian_expe.refresh_from_db() self.assertEqual(vegetarian_expe.waste_vegetarian_not_served_t0, 70)
def test_authenticated_add_manager_existing_user(self): """ If the email matches an existing user, add the user to the canteen managers without going through invitations table. No email sent for now """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) other_user = UserFactory.create(email="*****@*****.**") payload = {"canteenId": canteen.id, "email": other_user.email} response = self.client.post(reverse("add_manager"), payload) body = response.json() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(canteen.managers.all().get(id=other_user.id).id, other_user.id) with self.assertRaises(ManagerInvitation.DoesNotExist): ManagerInvitation.objects.get(email=other_user.email) self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].to[0], "*****@*****.**") self.assertEqual(mail.outbox[0].from_email, "*****@*****.**") self.assertIn("Accèder à la cantine", mail.outbox[0].body) self.assertEqual(len(body["managers"]), canteen.managers.all().count()) self.assertEqual(len(body["managerInvitations"]), canteen.managerinvitation_set.all().count())
def test_info_badge_earned(self): """ Test that the right canteens are identified in info badge qs """ no_communicated = CanteenFactory.create() DiagnosticFactory.create(canteen=no_communicated, communicates_on_food_quality=False) earned = CanteenFactory.create() DiagnosticFactory.create(canteen=earned, communicates_on_food_quality=True) badges = badges_for_queryset(Diagnostic.objects.all()) info_badge_qs = badges["info"] self.assertEqual(info_badge_qs.count(), 1) self.assertTrue(info_badge_qs.filter(canteen=earned).exists())
def test_create_vegetarian_expe(self): """ Test that we can create a new vegetarian experiment for a canteen """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) payload = { "vegetarianMenuPercentageT0": 0.32, "satisfactionGuestsT0": 5, } response = self.client.post( reverse("canteen_vegetarian_expe", kwargs={"canteen_pk": canteen.id}), payload) self.assertEqual(response.status_code, status.HTTP_201_CREATED) body = response.json() self.assertEqual(body["vegetarianMenuPercentageT0"], 0.32) self.assertEqual(body["satisfactionGuestsT0"], 5) self.assertEqual( float( VegetarianExpe.objects.get( canteen=canteen).vegetarian_menu_percentage_t0), 0.32) self.assertEqual( VegetarianExpe.objects.get(canteen=canteen).satisfaction_guests_t0, 5)
def test_filter_by_characteristic(self): canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) PurchaseFactory.create(description="avoine", canteen=canteen, characteristics=[Purchase.Characteristic.BIO]) PurchaseFactory.create( description="tomates", canteen=canteen, characteristics=[ Purchase.Characteristic.BIO, Purchase.Characteristic.PECHE_DURABLE ], ) PurchaseFactory.create( description="pommes", canteen=canteen, characteristics=[Purchase.Characteristic.PECHE_DURABLE]) response = self.client.get( f"{reverse('purchase_list_create')}?characteristics={Purchase.Characteristic.BIO}" ) self.assertEqual(response.status_code, status.HTTP_200_OK) results = response.json().get("results", []) self.assertEqual(len(results), 2) response = self.client.get( f"{reverse('purchase_list_create')}?characteristics={Purchase.Characteristic.BIO}&characteristics={Purchase.Characteristic.PECHE_DURABLE}" ) self.assertEqual(response.status_code, status.HTTP_200_OK) results = response.json().get("results", []) self.assertEqual(len(results), 3)
def test_purchase_missing_year(self): canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) response = self.client.get( reverse("canteen_purchases_summary", kwargs={"canteen_pk": canteen.id}), ) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_canteen_image_serialization(self): """ A canteen with images should serialize those images """ canteen = CanteenFactory.create(publication_status=Canteen.PublicationStatus.PUBLISHED.value) image_names = [ "test-image-1.jpg", "test-image-2.jpg", "test-image-3.png", ] for image_name in image_names: path = os.path.join(CURRENT_DIR, f"files/{image_name}") with open(path, "rb") as image: file = File(image) file.name = image_name canteen_image = CanteenImage(image=file) canteen_image.canteen = canteen canteen_image.save() response = self.client.get(reverse("published_canteens")) self.assertEqual(response.status_code, status.HTTP_200_OK) body = response.json() results = body.get("results", []) self.assertEqual(body.get("count"), 1) self.assertEqual(len(results[0].get("images")), 3)
def test_create_duplicate_diagnostic(self): """ Shouldn't be able to add a diagnostic with the same canteen and year as an existing diagnostic """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) self.client.post( reverse("diagnostic_creation", kwargs={"canteen_pk": canteen.id}), { "year": 2020, "value_bio_ht": 10 }, ) payload = { "year": 2020, "value_bio_ht": 1000, } try: with transaction.atomic(): response = self.client.post( reverse("diagnostic_creation", kwargs={"canteen_pk": canteen.id}), payload, ) except BadRequest: pass self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) diagnostic = Diagnostic.objects.get(canteen__id=canteen.id) self.assertEqual(diagnostic.value_bio_ht, 10)
def test_update_purchase(self): """ A user can update the data from a purchase object """ purchase = PurchaseFactory.create() purchase.canteen.managers.add(authenticate.user) new_canteen = CanteenFactory.create() new_canteen.managers.add(authenticate.user) payload = { "id": purchase.id, "canteen": new_canteen.id, "description": "Saumon", "provider": "Test provider", "price_ht": 15.23, } response = self.client.patch(reverse( "purchase_retrieve_update_destroy", kwargs={"pk": purchase.id}), payload, format="json") self.assertEqual(response.status_code, status.HTTP_200_OK) purchase.refresh_from_db() self.assertEqual(purchase.canteen, new_canteen) self.assertEqual(purchase.description, "Saumon") self.assertEqual(purchase.provider, "Test provider") self.assertEqual(float(purchase.price_ht), 15.23)
def test_location_overridden(self, mock): """ If the canteen already has city/department data, update it on import to be consistent with handling of name, meal count, etc """ canteen = CanteenFactory.create( siret="32441387130915", city_insee_code="55555", city="Ma ville", postal_code="66666", department=Department.ardeche, ) canteen.managers.add(authenticate.user) address_api_text = "siret,citycode,postcode,result_citycode,result_postcode,result_city,result_context\n" address_api_text += '21340172201787,,11111,00000,11111,Ma ville,"01,Something,Other"\n' address_api_text += '73282932000074,00000,,00000,11111,Ma ville,"01,Something,Other"\n' address_api_text += '32441387130915,07293,11111,00000,22222,Saint-Romain-de-Lerps,"01,Something,Other"\n' mock.post( "https://api-adresse.data.gouv.fr/search/csv/", text=address_api_text, ) with open("./api/tests/files/diagnostics_locations.csv") as diag_file: response = self.client.post(reverse("import_diagnostics"), {"file": diag_file}) self.assertEqual(response.status_code, status.HTTP_200_OK) canteen = Canteen.objects.get(siret="32441387130915") self.assertEqual(canteen.city_insee_code, "00000") self.assertEqual(canteen.postal_code, "22222") self.assertEqual(canteen.city, "Saint-Romain-de-Lerps") self.assertEqual(canteen.department, Department.ain)
def test_canteen_image_modification(self): """ The API should allow image addition and deletion for canteen managers """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) self.assertEqual(canteen.images.count(), 0) image_path = os.path.join(CURRENT_DIR, "files/test-image-1.jpg") image_base_64 = None with open(image_path, "rb") as image: image_base_64 = base64.b64encode(image.read()).decode("utf-8") # Create image payload = { "images": [{ "image": "data:image/jpeg;base64," + image_base_64, }] } self.client.patch(reverse("single_canteen", kwargs={"pk": canteen.id}), payload, format="json") canteen.refresh_from_db() self.assertEqual(canteen.images.count(), 1) # Delete image payload = {"images": []} self.client.patch(reverse("single_canteen", kwargs={"pk": canteen.id}), payload, format="json") canteen.refresh_from_db() self.assertEqual(canteen.images.count(), 0)
def test_get_single_unpublished_canteen(self): """ A 404 is raised if we try to get a sinlge published canteen that has not been published by the manager. """ private_canteen = CanteenFactory.create() response = self.client.get(reverse("single_published_canteen", kwargs={"pk": private_canteen.id})) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_diversification_badge_earned(self): """ Test that the right canteens are identifies in diversification badge qs """ primaire = SectorFactory(name="Scolaire primaire", category="education") secondaire = SectorFactory(name="Scolaire secondaire", category="education") # --- canteens which don't earn diversification badge: high_canteen = CanteenFactory.create() high_canteen.sectors.remove(primaire) high_canteen.sectors.remove(secondaire) DiagnosticFactory.create( canteen=high_canteen, vegetarian_weekly_recurrence=Diagnostic.MenuFrequency.HIGH.value) low_canteen = CanteenFactory.create() low_canteen.sectors.add(primaire) DiagnosticFactory.create( canteen=low_canteen, vegetarian_weekly_recurrence=Diagnostic.MenuFrequency.LOW.value) # --- canteens which earn diversification badge: daily_vege = CanteenFactory.create() daily_vege.sectors.remove(primaire) daily_vege.sectors.remove(secondaire) DiagnosticFactory.create( canteen=daily_vege, vegetarian_weekly_recurrence=Diagnostic.MenuFrequency.DAILY.value) scolaire_mid_vege = CanteenFactory.create() scolaire_mid_vege.sectors.add(secondaire) DiagnosticFactory.create( canteen=scolaire_mid_vege, vegetarian_weekly_recurrence=Diagnostic.MenuFrequency.MID.value) badges = badges_for_queryset(Diagnostic.objects.all()) diversification_badge_qs = badges["diversification"] self.assertEqual(diversification_badge_qs.count(), 2) self.assertTrue( diversification_badge_qs.filter(canteen=daily_vege).exists()) self.assertTrue( diversification_badge_qs.filter( canteen=scolaire_mid_vege).exists())
def test_filter_by_canteen(self): canteen = CanteenFactory.create() other_canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) other_canteen.managers.add(authenticate.user) PurchaseFactory.create(description="avoine", canteen=canteen) PurchaseFactory.create(description="tomates", canteen=other_canteen) PurchaseFactory.create(description="pommes", canteen=canteen) canteen_id = canteen.id response = self.client.get( f"{reverse('purchase_list_create')}?canteen__id={canteen_id}") self.assertEqual(response.status_code, status.HTTP_200_OK) results = response.json().get("results", []) self.assertEqual(len(results), 2)
def test_get_nonexistant_reservation_expe(self): """ Test attempting to get a reservation expe that doesn't exist """ canteen = CanteenFactory.create() canteen.managers.add(authenticate.user) response = self.client.get(reverse("canteen_reservation_expe", kwargs={"canteen_pk": canteen.id})) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_unauthenticated_create_diagnostic_call(self): """ When calling this API unathenticated we expect a 403 """ canteen = CanteenFactory.create() response = self.client.post( reverse("diagnostic_creation", kwargs={"canteen_pk": canteen.id}), {}) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_remove_manager_forbidden_canteen(self): """ When calling this API on a canteen that the user doesn't manage, we expect a 404 """ canteen = CanteenFactory.create() payload = {"canteenId": canteen.id, "email": "*****@*****.**"} response = self.client.post(reverse("remove_manager"), payload) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)