def test_create_user_with_generated_username(mocker, valid_address_dict): """ Integration test to assert that create_user_with_generated_username tries to find an available username and try again to save a User if there was a username collision """ username = "******" # Create a user with the desired username before calling the function so we get a collision UserFactory.create(username=username) data = { "username": username, "email": "*****@*****.**", "name": "Test User", "legal_address": valid_address_dict, "password": "******", } serializer = UserSerializer(data=data) serializer.is_valid() patched_find_username = mocker.patch( "authentication.api.find_available_username", return_value="testuser1") created_user = api.create_user_with_generated_username( serializer, username) patched_find_username.assert_called_once_with(username) assert created_user is not None assert created_user.username == patched_find_username.return_value
def test_find_available_username( mocker, username_base, suffixed_to_create, expected_available_username ): """find_available_username should return an available username with the lowest possible suffix""" # Change the username max length to 10 for test data simplicity's sake temp_username_max_len = 10 mocker.patch("users.api.USERNAME_MAX_LEN", temp_username_max_len) def suffixed_username_generator(): """Generator for usernames with suffixes that will not exceed the username character limit""" for suffix_int in range(1, suffixed_to_create + 1): suffix = str(suffix_int) username = "******".format(username_base, suffix) if len(username) <= temp_username_max_len: yield username else: num_extra_characters = len(username) - temp_username_max_len yield "{}{}".format( username_base[0 : len(username_base) - num_extra_characters], suffix ) UserFactory.create(username=username_base) UserFactory.create_batch( suffixed_to_create, username=factory.Iterator(suffixed_username_generator()) ) available_username = find_available_username(username_base) assert available_username == expected_available_username
def test_safe_format_recipients(): """Test that we get a list of emailable recipients""" user = UserFactory.create() user_no_email = UserFactory.create(email="") user_no_name = UserFactory.create(name="") assert safe_format_recipients([user, user_no_email, user_no_name]) == [ (formataddr((user.name, user.email)), user), (formataddr((None, user_no_name.email)), user_no_name), ]
def test_course_available_runs(): """enrolled runs for a user should not be in the list of available runs""" user = UserFactory.create() course = CourseFactory.create() runs = CourseRunFactory.create_batch(2, course=course, live=True) runs.sort(key=lambda run: run.start_date) CourseRunEnrollmentFactory.create(run=runs[0], user=user) assert course.available_runs(user) == [runs[1]] assert course.available_runs(UserFactory.create()) == runs
def test_website_endpoint_search(drf_client): """ should limit the queryset based on the search param """ superuser = UserFactory.create(is_superuser=True) drf_client.force_login(superuser) WebsiteFactory.create(title="Apple", name="Bacon", short_id="Cheese").save() WebsiteFactory.create(title="Xylophone", name="Yellow", short_id="Zebra").save() WebsiteFactory.create( title="U.S. Military Power", name="17-482-u-s-military-power-spring-2015", short_id="17.482-Spring-2015", ).save() WebsiteFactory.create( title="Biomedical Signal and Image Processing", name="hst-582j-biomedical-signal-and-image-processing-spring-2007", short_id="HST.582J-Spring-2007", ).save() for word in ["Apple", "Bacon", "Cheese"]: resp = drf_client.get(reverse("websites_api-list"), {"search": word}) assert [website["title"] for website in resp.data.get("results")] == ["Apple"] for word in ["Xylophone", "Yellow", "Zebra"]: resp = drf_client.get(reverse("websites_api-list"), {"search": word}) assert [website["title"] for website in resp.data.get("results")] == ["Xylophone"] for word in ["U.S. military", "17-482", "17.482"]: resp = drf_client.get(reverse("websites_api-list"), {"search": word}) assert [website["title"] for website in resp.data.get("results") ] == ["U.S. Military Power"] for word in ["signal and image", "HsT.582", "hSt-582"]: resp = drf_client.get(reverse("websites_api-list"), {"search": word}) assert [website["title"] for website in resp.data.get("results") ] == ["Biomedical Signal and Image Processing"]
def test_batch_delete_files(mocker, mock_api_wrapper, has_user): """Batch delete multiple git files in a single commit""" user = UserFactory.create() if has_user else None mock_element = mocker.patch("content_sync.apis.github.InputGitTreeElement") mock_git_user = mocker.patch("content_sync.apis.github.InputGitAuthor") paths = [ "content/testpages/page1.md", "content/testresources/video1.md", "content/testresources/video2.md", ] mock_api_wrapper.batch_delete_files(paths, user=user) tree_args = mock_api_wrapper.org.get_repo.return_value.create_git_tree.call_args[ 0][0] assert len(tree_args) == len(paths) for path in paths: mock_element.assert_any_call( path, "100644", "blob", sha=None, ) mock_api_wrapper.org.get_repo.return_value.create_git_commit.assert_called_once_with( "Sync all content", mock_api_wrapper.org.get_repo.return_value.create_git_tree. return_value, mocker.ANY, committer=mocker.ANY, author=mocker.ANY, ) if has_user: mock_git_user.assert_called_once_with(user.name, user.email) else: mock_git_user.assert_called_once_with(settings.GIT_DEFAULT_USER_NAME, settings.GIT_DEFAULT_USER_EMAIL)
def setUp(self): self.user = UserFactory.create(email="*****@*****.**", password="******") self.application = Application( name="Test Application", redirect_uris="http://localhost", user=self.user, client_type=Application.CLIENT_CONFIDENTIAL, authorization_grant_type=Application.GRANT_PASSWORD, ) self.application.save() self.token = AccessToken.objects.create( user=self.user, token="1234567890", application=self.application, expires=timezone.now() + datetime.timedelta(days=1), scope="read write", ) self.client.credentials( HTTP_AUTHORIZATION="Bearer {}".format(self.token.token)) self.url_list = reverse("accounts-list") self.accounts_data = AccountsFactory.create_batch(size=10) self.return_fields = ( "url", "slug", "title", "description", "created", "modified", )
def test_order_status_customer_name(client): """ Test that the correct customer name is returned by order status API """ order = B2BOrderFactory.create() resp = client.get( reverse("b2b-order-status", kwargs={"hash": str(order.unique_id)})) # Order status API returns no customer name if there is no existing user associated with order email and there is no # receipt associated with order assert resp.status_code == status.HTTP_200_OK assert resp.json().get("customer_name") == "" receipt_date = { "req_bill_to_forename": "Test", "req_bill_to_surname": "Name" } # Order status API returns customer name from the receipt data when there is no user account with order email B2BReceipt.objects.create(order=order, data=receipt_date) resp = client.get( reverse("b2b-order-status", kwargs={"hash": str(order.unique_id)})) assert resp.status_code == status.HTTP_200_OK assert resp.json().get("customer_name") == "Test Name" # Order status API returns name of the existing user if there exists an order's email matching user account test_user = UserFactory.create(email=order.email) resp = client.get( reverse("b2b-order-status", kwargs={"hash": str(order.unique_id)})) assert resp.status_code == status.HTTP_200_OK assert resp.json().get("customer_name") == test_user.name
def test_update_user_email(mocker, user, raises_error): # pylint: disable=too-many-arguments """Test that update edx user email takes the correct action""" mock_update_edx_user_email = mocker.patch( "courseware.tasks.api.update_edx_user_email") new_user = UserFactory.create() if raises_error: mock_update_edx_user_email.side_effect = Exception("error") new_email = new_user.email else: new_email = "*****@*****.**" mock_change_edx_user_email_task = mocker.patch( "courseware.tasks.change_edx_user_email_async") change_request = ChangeEmailRequest.objects.create(user=user, new_email=new_email) serializer = ChangeEmailRequestUpdateSerializer(change_request, {"confirmed": True}) try: serializer.is_valid() serializer.save() except ValidationError: pass if raises_error: mock_update_edx_user_email.assert_not_called() else: mock_update_edx_user_email.assert_called_once_with(user) mock_change_edx_user_email_task.apply_async.assert_not_called()
def test_fetch_user(prop, value, db_value): """ fetch_user should return a User that matches a provided value which represents an id, email, or username """ user = UserFactory.create(**{prop: db_value or value}) found_user = fetch_user(value) assert user == found_user
def test_post_ok(self): payload = DriverGroupFactory.attributes() payload["drivers"] = [DriverFactory.create().id] payload["author"] = UserFactory.create().id response = self.client.post(reverse("api:drivergroup-list"), data=payload, format="json") self.assert_post_ok(response)
def test_full_username_creation(): """ Integration test to ensure that the USERNAME_MAX_LEN constant is set correctly, and that generated usernames do not exceed it. """ expected_username_max = 30 user_full_name = "Longerton McLongernamenbergenstein" generated_username = usernameify(user_full_name) assert len(generated_username) == expected_username_max UserFactory.create(username=generated_username, name=user_full_name) new_user_full_name = "{} Jr.".format(user_full_name) new_generated_username = usernameify(new_user_full_name) assert new_generated_username == generated_username available_username = find_available_username(new_generated_username) assert available_username == "{}1".format( new_generated_username[0 : expected_username_max - 1] )
def test_fetch_user_case_sens(): """fetch_user should be able to fetch a User with a case-insensitive filter""" email = "*****@*****.**" user = UserFactory.create(email=email) upper_email = email.upper() with pytest.raises(User.DoesNotExist): fetch_user(upper_email, ignore_case=False) assert fetch_user(upper_email, ignore_case=True) == user
def test_websites_endpoint_detail_methods_denied(drf_client, method, status): """Certain request methods should always be denied""" website = WebsiteFactory.create() drf_client.force_login(UserFactory.create(is_superuser=True)) client_func = getattr(drf_client, method) resp = client_func( reverse("websites_api-detail", kwargs={"name": website.name})) assert resp.status_code == status
def setUp(self): self.dsr_admin = UserFactory.create(group=DsrGroupFactory.create( slug_field=settings.DSR_ADMIN_SLUG_FIELD, linked_group__name=settings.DSR_ADMIN_GROUP_NAME, custom_user_permissions=[settings.CAN_ADD_DSR_EMPLOYEE_NAME], )) self.dsr_employee = UserFactory.create(group=DsrGroupFactory.create( slug_field=settings.DSR_EMPLOYEE_SLUG_FIELD, linked_group__name=settings.DSR_EMPLOYEE_GROUP_NAME, custom_user_permissions=[ # Add User Permissions ], )) self.dsr_customer_super_admin = UserFactory.create( group=DsrGroupFactory.create( slug_field=settings.DSR_CUSTOMER_SUPER_ADMIN_SLUG_FIELD, linked_group__name=settings. DSR_CUSTOMER_SUPER_ADMIN_GROUP_NAME, custom_user_permissions=[ # Add User Permissions settings.CAN_ADD_DSR_CUSTOMER_ADMIN_NAME, settings.CAN_ADD_DSR_CUSTOMER_USER_NAME ], )) self.dsr_customer_admin = UserFactory.create( group=DsrGroupFactory.create( slug_field=settings.DSR_CUSTOMER_ADMIN_SLUG_FIELD, linked_group__name=settings.DSR_CUSTOMER_ADMIN_GROUP_NAME, custom_user_permissions=[ # Add User Permissions settings.CAN_ADD_DSR_CUSTOMER_USER_NAME ], )) self.dsr_customer_user = UserFactory.create( group=DsrGroupFactory.create( slug_field=settings.DSR_CUSTOMER_USER_SLUG_FIELD, linked_group__name=settings.DSR_CUSTOMER_USER_GROUP_NAME, custom_user_permissions=[ # Add User Permissions ], ))
def handle(self, *args, **kwargs): UserFactory.create(email="*****@*****.**", is_staff=True, is_superuser=True) dealers = [] for dealer in [("Parts Express", "https://www.parts-express.com")]: dealers.append( DealerFactory.create(name=dealer[0], website=dealer[1])) self.stdout.write("Created {0} Dealer(s)".format(len(dealers))) dealer_scrapers = [] for dealer in dealers: dealer_scrapers.append( DealerScraperFactory.create(class_name="PartsExpressScraper", dealer=dealer)) self.stdout.write("Created {0} DealerScraper(s)".format( len(dealer_scrapers)))
def test_website_collaborator_serializer(): """ WebsiteCollaboratorSerializer should serialize a User object with correct fields """ collaborator = (User.objects.filter(id=UserFactory.create().id).annotate( role=Value(ROLE_EDITOR, CharField())).first()) serialized_data = WebsiteCollaboratorSerializer(instance=collaborator).data assert serialized_data["user_id"] == collaborator.id assert serialized_data["name"] == collaborator.name assert serialized_data["email"] == collaborator.email assert serialized_data["role"] == ROLE_EDITOR
def test_websites_endpoint_detail_get_denied(drf_client): """Anonymous user or user without permissions should not be able to view the site""" for user in (None, UserFactory.create()): if user: drf_client.force_login(user) website = WebsiteFactory.create() resp = drf_client.get( reverse("websites_api-detail", kwargs={"name": website.name})) assert resp.status_code == 403 if not user else 404
def test_multiple_success_blocking_user(self): """test block_users command blocking emails success with more than one user""" test_usernames = ["*****@*****.**", "*****@*****.**", "*****@*****.**"] for username in test_usernames: user = UserFactory.create(username=username, is_active=True) assert BlockList.objects.all().count() == 0 COMMAND.handle("block_users", users=test_usernames, block_users=True) assert BlockList.objects.all().count() == 3
def test_websites_endpoint_list_forbidden_methods(drf_client, method): """No put, patch, or delete requests allowed at this endpoint""" drf_client.force_login(UserFactory.create(is_superuser=True)) client_func = getattr(drf_client, method) resp = client_func(reverse("websites_api-list"), data={ "name": "fakename", "title": "Fake Title" }) assert resp.status_code == 405
def test_is_global_admin(permission_groups): """ Global admin users should be identified correctly """ superuser = UserFactory.create(is_superuser=True) for user in [permission_groups.global_admin, superuser]: assert permissions.is_global_admin(user) is True for user in [ permission_groups.global_author, permission_groups.site_admin, permission_groups.site_editor, ]: assert permissions.is_global_admin(user) is False
def test_update_email_change_request_existing_email(user): """Test that update change email request gives validation error for existing user email""" new_user = UserFactory.create() change_request = ChangeEmailRequest.objects.create( user=user, new_email=new_user.email) serializer = ChangeEmailRequestUpdateSerializer(change_request, {"confirmed": True}) with pytest.raises(ValidationError): serializer.is_valid() serializer.save()
def setUpClass(cls): super().setUpClass() cls.user = UserFactory.create() cls.user.save() # needed to get names of HVCs, have to do again because factory # remembers other tests, even if flushed from DB for i in range(255): HVCFactory.create( campaign_id='E%03d' % (i + 1), financial_year=16, )
def test_website_endpoint_empty_search(drf_client): """ should limit the queryset based on the search param """ superuser = UserFactory.create(is_superuser=True) drf_client.force_login(superuser) WebsiteFactory.create() WebsiteFactory.create() WebsiteFactory.create() resp = drf_client.get(reverse("websites_api-list"), {"search": ""}) expected_uuids = sorted( [site.uuid.__str__() for site in Website.objects.all()]) assert expected_uuids == sorted( [site["uuid"] for site in resp.data["results"]])
def test_admin_new_password(self): self._make_staff() self._login() UserFactory.create(email='*****@*****.**') response = self.alice_client.post( reverse('admin-new-password'), {'email': '*****@*****.**'}, ) self.assertEqual(response.status_code, 201) self.assertEquals(len(mail.outbox), 1) self.assertEquals( mail.outbox[0].subject, 'Export Wins Login Credentials', ) self.assertIn( 'This email contains your login credentials', mail.outbox[0].body, ) self.assertEqual( mail.outbox[0].to[0], '*****@*****.**', )
def setUp(self): self.client = Client() self.alice_client = AliceClient() self.user = UserFactory.create() self.user.set_password('asdf') self.user.save() self.superuser = UserFactory.create(is_superuser=True, email="[email protected]") self.wins_schema = reverse("drf:win-schema") self.wins_list = reverse("drf:win-list") self.wins_detail = reverse("drf:win-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.customerresponses_schema = reverse("drf:customerresponse-schema") self.customerresponses_list = reverse("drf:customerresponse-list") self.customerresponses_detail = reverse("drf:customerresponse-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.breakdowns_schema = reverse("drf:breakdown-schema") self.breakdowns_list = reverse("drf:breakdown-list") self.breakdowns_detail = reverse("drf:breakdown-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.advisors_schema = reverse("drf:advisor-schema") self.advisors_list = reverse("drf:advisor-list") self.advisors_detail = reverse("drf:advisor-detail", kwargs={ "pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" }) self.win = WinFactory.create() self.WINS_POST_SAMPLE = { "user": self.user.id, "cdms_reference": "cdms reference", "company_name": "company name", "country": "AF", "created": "2016-05-17T12:44:48.021705Z", "customer_email_address": "*****@*****.**", "customer_job_title": "customer job title", "customer_location": 3, "customer_name": "customer name", "date": "1979-06-01", "description": "asdlkjskdlfkjlsdjkl", "goods_vs_services": 1, "has_hvo_specialist_involvement": True, "hq_team": "other:1", "hvo_programme": "BSC-01", "is_e_exported": True, "is_line_manager_confirmed": True, "is_personally_confirmed": True, "is_prosperity_fund_related": True, "lead_officer_name": "lead officer name", "line_manager_name": "line manager name", "location": "Edinburgh, UK", "sector": 1, "team_type": "investment", "total_expected_export_value": 5, "total_expected_non_export_value": 5, "total_expected_odi_value": 5, "type": 1, "type_of_support_1": 1, "business_type": 1, "name_of_export": "name", "name_of_customer": "name", } self.CUSTOMER_RESPONSES_POST_SAMPLE = { "win": str(self.win.pk), "name": "bob", "improved_profile": "1", "gained_confidence": "1", "access_to_information": "1", "expected_portion_without_help": "1", "last_export": "1", "overcame_problem": "1", "developed_relationships": "1", "access_to_contacts": "1", "our_support": "1", "marketing_source": "1", "other_marketing_source": "" } self.BREAKDOWNS_POST_SAMPLE = { "win": str(self.win.pk), "type": Breakdown.TYPE_EXPORT, "year": "1999", "value": "1", } self.ADVISORS_POST_SAMPLE = { "win": str(self.win.pk), "name": "bob", "team_type": "other", "hq_team": "team:1", "location": "france" }