class TestMessage(unittest.TestCase): """ Test messages """ def setUp(self): self.user = UserFactory() self.region = RegionFactory() self.message = MessageFactory.build(georegion=self.region) def tearDown(self): self.user.delete() self.region.delete() self.message = None def test_message_unicode(self): self.assertEqual(self.message.title, "%s" % self.message) def test_message_save(self): self.message.save() self.assertIsNotNone(self.message.pk) self.message.delete() def test_message_remove(self): self.message.is_removed = True self.assertTrue(self.message.is_removed) def test_message_restore(self): self.message.is_removed = True self.assertTrue(self.message.is_removed) self.message.is_removed = False self.assertFalse(self.message.is_removed)
def test_email_registration_existing_email(test_client, db_init): """ GIVEN one inserted user WHEN register is hit with existing email THEN - Redirection on signin - Expected message is flashed in email category - No user is inserted """ UserFactory.create(email="*****@*****.**") expected_flash = "Email already exists" response = test_client.post("/register", data={ "signin_email": "*****@*****.**", "signin_first_name": user["first_name"], "signin_last_name": user["last_name"], "signin_password": user["password"], "signin_password_confirm": user["password"], "signin_birth_data": user["birth_date"] }) assert response.location.endswith("/signin") with test_client.session_transaction() as session: assert "email" in dict(session["_flashes"]).keys() assert dict(session["_flashes"])["email"] is not None assert dict(session["_flashes"])["email"] == expected_flash assert User.query.count() == 1
class UserAuthCodeTest(unittest.TestCase): def setUp(self): self.encoder = UserAuthCode('secret') self.user = UserFactory(is_active=False) def tearDown(self): self.encoder = None self.user.delete() self.user = None def test_user(self): self.assertIsNotNone(self.user.date_joined) self.assertTrue(self.user.date_joined >= self.user.last_login) def test_salt(self): salt = self.encoder.salt() self.assertEqual(8, len(salt)) def test_auth_code(self): code = self.encoder.auth_code(self.user) self.assertIsNotNone(code) def test_complete_activation(self): code = self.encoder.auth_code(self.user) self.assertTrue(self.encoder.is_valid(self.user, code)) def test_wrong_key(self): self.assertFalse(self.encoder.is_valid(self.user, 'aaa')) def test_already_activated(self): code = self.encoder.auth_code(self.user) self.user.last_login = timezone.now() self.user.save() self.assertFalse(self.encoder.is_valid(self.user, code))
def setUp(self): self.ion = IonAuth() self.user = UserFactory.build( is_active=True ) self.user.password = self.ion.password_hash('123') self.active_user = UserFactory(is_active=True) self.inactive_user = UserFactory(is_active=False)
def setUp(self): super(TestOpportunitiesAdminBase, self).setUp() try: mkdir(current_app.config.get('UPLOAD_DESTINATION')) except OSError: rmtree(current_app.config.get('UPLOAD_DESTINATION')) mkdir(current_app.config.get('UPLOAD_DESTINATION')) import_nigp(current_app.config.get('PROJECT_ROOT') + '/test/mock/nigp.csv') self.department1 = DepartmentFactory(name='test') AcceptedEmailDomainsFactory.create(domain='foo.com') self.admin = UserFactory.create( email='*****@*****.**', roles=[RoleFactory.create(name='admin')] ) self.staff = UserFactory.create( email='*****@*****.**', roles=[RoleFactory.create(name='staff')] ) self.document = RequiredBidDocumentFactory.create() self.vendor = VendorFactory.create(email='*****@*****.**', business_name='foo2') self.opportunity1 = OpportunityFactory.create( contact=self.admin, created_by=self.staff, title=u'tést unïcode title', description=u'tést unïcode déscription', is_public=True, is_archived=False, planned_publish=datetime.date.today() + datetime.timedelta(1), planned_submission_start=datetime.date.today() + datetime.timedelta(2), planned_submission_end=datetime.datetime.today() + datetime.timedelta(2), vendor_documents_needed=[self.document.id], categories=(Category.query.first(),) ).save() self.opportunity2 = OpportunityFactory.create( contact=self.admin, created_by=self.staff, is_public=True, is_archived=False, planned_publish=datetime.date.today(), planned_submission_start=datetime.date.today() + datetime.timedelta(2), planned_submission_end=datetime.datetime.today() + datetime.timedelta(2), categories=(Category.query.first(),), enable_qa=False, qa_start=None, qa_end=None ).save() self.opportunity3 = OpportunityFactory.create( contact=self.admin, created_by=self.staff, is_public=True, is_archived=False, planned_publish=datetime.date.today() - datetime.timedelta(2), planned_submission_start=datetime.date.today() - datetime.timedelta(2), planned_submission_end=datetime.datetime.today() - datetime.timedelta(1), categories=(Category.query.first(),) ).save() self.opportunity4 = OpportunityFactory.create( contact=self.admin, created_by=self.staff, is_public=True, is_archived=False, planned_publish=datetime.date.today() - datetime.timedelta(1), planned_submission_start=datetime.date.today(), planned_submission_end=datetime.datetime.today() + datetime.timedelta(2), title='TEST TITLE!', categories=(Category.query.first(),) ).save()
def test_knownuser_form(self): ''' Form for authenticated user contain initial data for some fields''' user = UserFactory(is_active=True) form = self.app.get( '/message/pomogite/dobavit', user=user.username).forms['mainForm'] self.assertEqual(user.first_name, form['contact_first_name'].value) self.assertEqual(user.last_name, form['contact_last_name'].value) self.assertEqual(user.email, form['contact_mail'].value) self.assertEqual(user.profile.phones, form['contact_phone'].value) user.delete()
class TestUserMessage(unittest.TestCase): def setUp(self): self.user = UserFactory() def tearDown(self): self.user.delete() self.user = None def test_user_message(self): msg = MessageFactory(user=self.user) self.assertIsNotNone(msg) self.assertEqual(self.user, msg.user)
def test_can_edit_is_public(self): staff = UserFactory.build(roles=[RoleFactory.build(name='staff')]) creator = UserFactory.build(roles=[RoleFactory.build(name='staff')]) admin = UserFactory.build(roles=[RoleFactory.build(name='admin')]) opportunity = OpportunityFactory.build( is_public=True, planned_publish=self.yesterday, planned_submission_start=self.today, planned_submission_end=self.tomorrow, created_by=creator, created_by_id=creator.id, contact_id=creator.id ) self.assertFalse(opportunity.can_edit(staff)) self.assertFalse(opportunity.can_edit(creator)) self.assertTrue(opportunity.can_edit(admin))
def test_can_edit_is_public(self): staff = UserFactory.build(role=RoleFactory.build(name='staff')) creator = UserFactory.build(role=RoleFactory.build(name='staff')) admin = UserFactory.build(role=RoleFactory.build(name='admin')) opportunity = OpportunityFactory.build( is_public=True, planned_publish=self.yesterday, planned_submission_start=self.today, planned_submission_end=self.tomorrow, created_by=creator, created_by_id=creator.id, contact_id=creator.id) self.assertFalse(opportunity.can_edit(staff)) self.assertFalse(opportunity.can_edit(creator)) self.assertTrue(opportunity.can_edit(admin))
def test_templates(self): # insert our opportunity, users admin_role = RoleFactory.create(name='admin') admin = UserFactory.create(role=admin_role) opportunity = OpportunityFactory.create( contact=admin, created_by=admin, is_public=True, planned_publish=datetime.date.today() - datetime.timedelta(1), planned_submission_start=datetime.date.today() + datetime.timedelta(2), planned_submission_end=datetime.datetime.today() + datetime.timedelta(2)) for rule in current_app.url_map.iter_rules(): _endpoint = rule.endpoint.split('.') # filters out non-beacon endpoints if (len(_endpoint) > 1 and _endpoint[1] == 'static') or \ _endpoint[0] != ('opportunities', 'opportunities_admin'): continue else: if '<int:' in rule.rule: response = self.client.get( url_for(rule.endpoint, opportunity_id=opportunity.id)) else: response = self.client.get(rule.rule) self.assert200(response)
def test_cannot_create_organization_with_taken_name( create_organization: CreateOrganization): user = UserFactory.create() create_organization.do(user, VALID_ORGANIZATION_DATA) with pytest.raises(ConflictError): create_organization.do(user, VALID_ORGANIZATION_DATA)
def test_organization_is_associated_with_user( create_organization: CreateOrganization, session): user = UserFactory.create() organization = create_organization.do(user, VALID_ORGANIZATION_DATA) user = session.query(User).get(user.id) assert user.organization.id == organization.id
def test_user_update_profile(self): user = UserFactory.create( roles=[self.staff], department=self.new_dept ) db.session.commit() self.login_user(user) first_profile_visit = self.client.get('/users/profile') self.assertTrue('Welcome to Beacon' in first_profile_visit.data) bad_update = self.client.post('/users/profile', data=dict( department='THIS IS NOT A VALID DEPARTMENT' ), follow_redirects=True) self.assertTrue( 'THIS IS NOT A VALID DEPARTMENT' not in [i.department for i in User.query.all()] ) self.assertTrue('Not a valid choice' in bad_update.data) update = self.client.post('/users/profile', data=dict( first_name='foo', last_name='bar', department=str(self.department1.id) )) self.assertEquals(update.status_code, 302) self.assert_flashes('Updated your profile!', 'alert-success') repeat_visit = self.client.get('/users/profile') self.assertFalse('Welcome to Beacon' in repeat_visit.data)
def setUp(self): self.user = UserFactory.build( email='*****@*****.**', ) self.user.set_password('test') self.user.save() self.auth = EmailAuthBackend()
def test_templates(self): # insert our opportunity, users admin_role = RoleFactory.create(name='admin') admin = UserFactory.create(role=admin_role) opportunity = OpportunityFactory.create( contact=admin, created_by=admin, is_public=True, planned_publish=datetime.date.today() - datetime.timedelta(1), planned_submission_start=datetime.date.today() + datetime.timedelta(2), planned_submission_end=datetime.datetime.today() + datetime.timedelta(2) ) for rule in current_app.url_map.iter_rules(): _endpoint = rule.endpoint.split('.') # filters out non-beacon endpoints if (len(_endpoint) > 1 and _endpoint[1] == 'static') or \ _endpoint[0] != ('opportunities', 'opportunities_admin'): continue else: if '<int:' in rule.rule: response = self.client.get(url_for(rule.endpoint, opportunity_id=opportunity.id)) else: response = self.client.get(rule.rule) self.assert200(response)
def setUp(self): super(TestBeaconJobs, self).setUp() self.yesterday = datetime.datetime.today() - datetime.timedelta(days=1) today = datetime.datetime.today() tomorrow = datetime.datetime.today() + datetime.timedelta(days=1) self.category = CategoryFactory.create() self.admin = UserFactory.create() self.opportunity = OpportunityFactory.create( is_public=True, planned_publish=today, planned_submission_start=today, planned_submission_end=tomorrow, categories=set([self.category]), created_by=self.admin, published_at=today ) self.opportunity2 = OpportunityFactory.create( is_public=True, planned_publish=self.yesterday, planned_submission_start=today, planned_submission_end=tomorrow, publish_notification_sent=True, categories=set([self.category]), created_by=self.admin, published_at=self.yesterday ) self.opportunity3 = OpportunityFactory.create( is_public=False, planned_publish=today, planned_submission_start=today, planned_submission_end=tomorrow, publish_notification_sent=False, categories=set([self.category]), created_by=self.admin, published_at=today ) self.opportunity4 = OpportunityFactory.create( is_public=True, planned_publish=self.yesterday, planned_submission_start=self.yesterday, planned_submission_end=today, publish_notification_sent=True, categories=set([self.category]), created_by=self.admin, published_at=self.yesterday ) VendorFactory.create(opportunities=set([self.opportunity])) VendorFactory.create(categories=set([self.category]))
def setUp(self): super(TestUserAuth, self).setUp() self.email = '*****@*****.**' user = UserFactory.create(email=self.email) user.save() AcceptedEmailDomains.create(domain='foo.com') DepartmentFactory.create(name='New User').save() self.department1 = DepartmentFactory.create(name='Test').save()
def setUp(self): user = UserFactory.build() self.user = create_new_user( first_name=user.first_name, last_name=user.last_name, email=user.email, password='******' )
class TestUserActivation(unittest.TestCase): def setUp(self): encoder = UserAuthCode(settings.SECRET_KEY) self.user = UserFactory(is_active=False) self.code = encoder.auth_code(self.user) def tearDown(self): self.user.delete() self.code = None def test_user_activation(self): self.assertTrue(activate_user(self.user, self.code)) self.assertTrue(self.user.is_active) def test_wrong_code(self): self.assertFalse(activate_user(self.user, 'self.code')) self.assertFalse(self.user.is_active)
def test_create_organization_with_long_username( create_organization: CreateOrganization): user = UserFactory.create() long_name = str(["a"] * 100) data = {**VALID_ORGANIZATION_DATA, "name": long_name} testutils.assert_validation_errors( ["name"], lambda: create_organization.do(user, data))
def test_knownuser_message(self): ''' Authenticated user send message and this message must be linked to user profile''' before = Message.objects.count() user = UserFactory(is_active=True) form = self.app.get( '/message/pomogite/dobavit', user=user.username).forms['mainForm'] form['title'] = 'Test message' form['message'] = "This is simple test message" form['georegion'] = self.region.pk form['address'] = 'Some address' form.submit() self.assertEqual(before + 1, Message.objects.count()) msg = Message.objects.all().select_related().reverse()[0] self.assertEqual(msg.user, user) user.delete()
class IonTest(unittest.TestCase): '''Authorization tests''' def setUp(self): self.ion = IonAuth() self.user = UserFactory.build( is_active=True ) self.user.password = self.ion.password_hash('123') self.active_user = UserFactory(is_active=True) self.inactive_user = UserFactory(is_active=False) def tearDown(self): self.active_user.delete() self.inactive_user.delete() self.user = None def test_ion_auth(self): self.assertEquals(40, len(self.user.password)) def test_password_rewrite(self): ''' If user enters correct ion password, backend will rehash password to django-specific password hash. ''' self.user.save() u2 = self.ion.authenticate(username=self.user.email, password='******') self.assertIsNotNone(u2) self.assertFalse(u2.is_anonymous()) self.assertNotEqual(self.user.password, u2.password) self.user.delete() def test_inactive_user(self): u2 = self.ion.authenticate( username=self.inactive_user.email, password='******') self.assertIsNone(u2) def test_unexists_user(self): u2 = self.ion.authenticate(username="******", password='******') self.assertIsNone(u2) def test_wrong_password(self): u2 = self.ion.authenticate( username=self.active_user.email, password='******') self.assertIsNone(u2)
def setUp(self): self.data = { 'first_name': 'test', 'last_name': 'user', 'email': '*****@*****.**', 'password1': '123', 'password2': '123' } self.user = UserFactory()
def test_me_returns_user_when_successful(client, session): user = UserFactory.create(username="******") headers = {"Authorization": "Bearer {}".format(user.id)} response = client.get(url_for("me"), headers=headers) assert response.status_code == 200 assert response.json["user"]["id"] == user.id assert response.json["user"]["username"] == "meow"
class TestMessageCleanData(unittest.TestCase): """ Test message cleaf functionality. """ def setUp(self): self.user = UserFactory() self.region = RegionFactory() self.message = MessageFactory.build(georegion=self.region) def tearDown(self): self.message = None self.region.delete() self.user.delete() def catch_wrong_data(self): """ Common test missed data""" with self.assertRaises(ValidationError): self.message.save() self.message.delete() def test_no_message_contacts(self): self.message.contact_phone = None self.message.contact_mail = None self.catch_wrong_data() def test_invalid_email(self): self.message.contact_mail = "notamail" self.catch_wrong_data() def test_phone_contact(self): self.message.contact_mail = "" self.message.save() self.assertIsNotNone(self.message.pk) self.message.delete() def test_email_contact(self): self.message.contact_phone = "" self.message.save() self.assertIsNotNone(self.message.pk) self.message.delete()
def test_delete_button_dont_appear_on_other_users_page(test_client, db_init, insert_user, login_user): """ GIVEN one inserted and logged-in user WHEN browsing another's user page THEN delete button is not displayed """ second_user = UserFactory.create() db_init.session.commit() response = test_client.get(f"/user/{second_user.id}") assert "Delete post" not in response.data.decode("utf-8")
class TestSimpleRequestForm(unittest.TestCase): def setUp(self): self.form = SimpleRequestForm() self.user = UserFactory() self.region = RegionFactory() self.data = { "title": lorem_ipsum(words_count=3), "message": lorem_ipsum(), "messageType": MessageType.TYPE_REQUEST, "contact_first_name": self.user.first_name, "contact_last_name": self.user.last_name, "contact_mail": self.user.email, "georegion": self.region.pk, "location_0": 0.0, "location_1": 0.0, "address": lorem_ipsum(words_count=4), } def tearDown(self): self.region.delete() self.region = None self.form = None self.user.delete() def test_form_type(self): self.assertEqual(1, self.form.fields["messageType"].initial) def test_send_data(self): form = SimpleRequestForm(self.data) self.assertTrue(form.is_bound) self.assertTrue(form.is_valid(), form.errors) msg = form.save(commit=True) self.assertIsNotNone(msg) self.assertIsNotNone(msg.pk) self.assertEqual(1, msg.status) self.assertEqual(1, msg.messageType) msg.delete()
def test_create_organization_returns_organization_when_successful( client, session): user = UserFactory.create(username="******") headers = {"Authorization": "Bearer {}".format(user.id)} org_data = {"name": "My Organization"} response = client.post(url_for("create_organization"), headers=headers, json=org_data) assert response.status_code == 201 assert response.json["organization"]["id"] assert response.json["organization"]["name"] == "My Organization"
class TestForgotPasswordForm(unittest.TestCase): ''' First step reset password functionality - validate email ''' def setUp(self): self.user = UserFactory() def tearDown(self): self.user.delete() def test_reset_password(self): data = {'email': self.user.email} form = ForgotPasswordForm(data) self.assertTrue(form.is_bound) self.assertTrue(form.is_valid()) def test_unknown_email(self): data = {'email': '*****@*****.**',} form = ForgotPasswordForm(data) self.assertTrue(form.is_bound) self.assertFalse(form.is_valid()) self.assertEqual([_(u'This email isn\'t registered'),], form['email'].errors)
def setUp(self): self.user = UserFactory.build() self.region = RegionFactory() self.data = { "message": lorem_ipsum(), "messageType": MessageType.TYPE_REQUEST, "contact_first_name": self.user.first_name, "contact_last_name": self.user.last_name, "contact_mail": self.user.email, "contact_phone": "12345678", "address": lorem_ipsum(words_count=4), "georegion": self.region.pk, "location_0": 25.0, "location_1": 50.0, }
def test_user_info(): client = ClientFactory() role1 = RoleFactory() role2 = RoleFactory() user = UserFactory(roles=(role1, role2)) actual_user_info = get_user_info(user.id, client.id) expected_user_info = UserInfo( sub=user.id, email=user.email, email_verified=user.verified, name=user.name, picture=None, roles=[role1.id, role2.id], ) assert expected_user_info == actual_user_info
def setUp(self): self.form = SimpleRequestForm() self.user = UserFactory() self.region = RegionFactory() self.data = { "title": lorem_ipsum(words_count=3), "message": lorem_ipsum(), "messageType": MessageType.TYPE_REQUEST, "contact_first_name": self.user.first_name, "contact_last_name": self.user.last_name, "contact_mail": self.user.email, "georegion": self.region.pk, "location_0": 0.0, "location_1": 0.0, "address": lorem_ipsum(words_count=4), }
def test_update_user_not_found(api, user_batch): scopes = [ODPScope.USER_ADMIN] user = UserFactory.build( id='foo', name=user_batch[2].name, email=user_batch[2].email, verified=user_batch[2].verified, roles=RoleFactory.create_batch(randint(0, 3)), ) r = api(scopes).put('/user/', json=dict( id=user.id, active=user.active, role_ids=role_ids(user), )) assert_not_found(r) assert_db_state(user_batch)
def test_platform_roles(): scopes = ScopeFactory.create_batch(8, type='odp') client = ClientFactory(scopes=scopes[1:7]) role1 = RoleFactory(scopes=scopes[:3]) role2 = RoleFactory(scopes=scopes[5:]) user = UserFactory(roles=(role1, role2)) actual_user_perm = get_user_permissions(user.id, client.id) expected_user_perm = { scope.id: '*' for n, scope in enumerate(scopes) if n in (1, 2, 5, 6) } assert_compare(expected_user_perm, actual_user_perm) actual_client_perm = get_client_permissions(client.id) expected_client_perm = {scope.id: '*' for scope in scopes[1:7]} assert_compare(expected_client_perm, actual_client_perm)
def test_user_info_collection_roles_and_client(): client = ClientFactory(is_collection_client=True) role1 = RoleFactory() role2 = RoleFactory(collection=client.collection) role3 = RoleFactory(collection=client.collection) role4 = RoleFactory(is_collection_role=True) user = UserFactory(roles=(role1, role2, role3, role4)) actual_user_info = get_user_info(user.id, client.id) expected_user_info = UserInfo( sub=user.id, email=user.email, email_verified=user.verified, name=user.name, picture=None, roles=[role1.id, role2.id, role3.id], ) assert expected_user_info == actual_user_info
def setUp(self): self.cats = list() for x in xrange(5): self.cats.append(CategoryFactory()) self.user = UserFactory.build() self.region = RegionFactory() self.data = { "message": lorem_ipsum(), "messageType": MessageType.TYPE_REQUEST, "contact_first_name": self.user.first_name, "contact_last_name": self.user.last_name, "contact_mail": self.user.email, "contact_phone": "12345678", "address": lorem_ipsum(words_count=4), "georegion": self.region.pk, "location_0": 25.0, "location_1": 50.0, "category": [x.pk for x in self.cats], }
def test_collection_client_platform_collection_role_mix(): scopes = ScopeFactory.create_batch(8, type='odp') client = ClientFactory(scopes=scopes[1:7], is_collection_client=True) role1 = RoleFactory(scopes=scopes[:3]) role2 = RoleFactory(scopes=scopes[3:5], is_collection_role=True) role3 = RoleFactory(scopes=scopes[5:], collection=client.collection) user = UserFactory(roles=(role1, role2, role3)) actual_user_perm = get_user_permissions(user.id, client.id) expected_user_perm = { scope.id: [client.collection_id] for n, scope in enumerate(scopes) if n in (1, 2, 5, 6) } assert_compare(expected_user_perm, actual_user_perm) actual_client_perm = get_client_permissions(client.id) expected_client_perm = { scope.id: [client.collection_id] for scope in scopes[1:7] } assert_compare(expected_client_perm, actual_client_perm)
def test_update_user(api, user_batch, scopes): authorized = ODPScope.USER_ADMIN in scopes modified_user_batch = user_batch.copy() modified_user_batch[2] = (user := UserFactory.build( id=user_batch[2].id, name=user_batch[2].name, email=user_batch[2].email, verified=user_batch[2].verified, roles=RoleFactory.create_batch(randint(0, 3)), )) r = api(scopes).put('/user/', json=dict( id=user.id, active=user.active, role_ids=role_ids(user), )) if authorized: assert_empty_result(r) assert_db_state(modified_user_batch) else: assert_forbidden(r) assert_db_state(user_batch)
def test_like_model_inserts_data_correctly(test_client, db_init, insert_user): """ GIVEN one inserted post, two users WHEN Likes are inserted using model THEN - Likes are indeed inserted - Likes's attributes are correct - Relationship is bi-directionnal (likes can be retrieved from post) """ first_user = User.query.first() post = PostFactory(user=first_user, user_id=first_user.id) like = Like( user=first_user, user_id=first_user.id, post=post, post_id=post.id ) second_user = UserFactory.create() second_like = Like( user=second_user, user_id=second_user.id, post=post, post_id=post.id ) DB.session.add_all([like, second_like, second_user]) DB.session.commit() assert Like.query.count() == 2 first_like = Like.query.filter(Like.user_id == first_user.id).first() assert first_like is not None assert first_like.post == post assert first_like.post_id == post.id second_like = Like.query.filter(Like.user_id == second_user.id).first() assert second_like is not None assert second_like.post == post assert second_like.post_id == post.id assert len(post.likes) == 2 assert first_like in post.likes assert second_like in post.likes
def test_collection_roles(): scopes = ScopeFactory.create_batch(8, type='odp') client = ClientFactory(scopes=scopes[1:7]) role1 = RoleFactory(scopes=scopes[:5], is_collection_role=True) role2 = RoleFactory(scopes=scopes[3:], is_collection_role=True) user = UserFactory(roles=(role1, role2)) actual_user_perm = get_user_permissions(user.id, client.id) expected_user_perm = { scope.id: [role1.collection_id] for n, scope in enumerate(scopes) if n in (1, 2) } | { scope.id: [role1.collection_id, role2.collection_id] for n, scope in enumerate(scopes) if n in (3, 4) } | { scope.id: [role2.collection_id] for n, scope in enumerate(scopes) if n in (5, 6) } assert_compare(expected_user_perm, actual_user_perm) actual_client_perm = get_client_permissions(client.id) expected_client_perm = {scope.id: '*' for scope in scopes[1:7]} assert_compare(expected_client_perm, actual_client_perm)
class SimpleRegistrationFormTest(unittest.TestCase): ''' Registration form test''' def setUp(self): self.data = { 'first_name': 'test', 'last_name': 'user', 'email': '*****@*****.**', 'password1': '123', 'password2': '123' } self.user = UserFactory() def tearDown(self): self.data = None self.user.delete() Profile.objects.all().delete() def test_user_creation(self): form = SimpleRegistrationForm(self.data) self.assertTrue(form.is_bound) self.assertTrue(form.is_valid()) def test_lost_firstname(self): self.data['first_name'] = None form = SimpleRegistrationForm(self.data) self.assertTrue(form.is_bound) self.assertFalse(form.is_valid()) self.assertEqual([_(u'This field is required.'), ], form['first_name'].errors) def test_empty_firstname(self): self.data['first_name'] = ' ' form = SimpleRegistrationForm(self.data) self.assertTrue(form.is_bound) self.assertFalse(form.is_valid()) self.assertEqual([_(u'You must provide a first name!'), ], form['first_name'].errors) def test_lost_lastname(self): self.data['last_name'] = None form = SimpleRegistrationForm(self.data) self.assertTrue(form.is_bound) self.assertFalse(form.is_valid()) self.assertEqual([_(u'This field is required.'), ], form['last_name'].errors) def test_empty_lastname(self): self.data['last_name'] = ' ' form = SimpleRegistrationForm(self.data) self.assertTrue(form.is_bound) self.assertFalse(form.is_valid()) self.assertEqual([_(u'You must provide a last name!'), ], form['last_name'].errors) def test_existing_email(self): self.data['email'] = self.user.email form = SimpleRegistrationForm(self.data) self.assertTrue(form.is_bound) self.assertFalse(form.is_valid()) self.assertEqual([_(u'This email already registered'), ], form['email'].errors) def test_passwords_diff(self): self.data['password1'] = 'qwe' form = SimpleRegistrationForm(self.data) self.assertTrue(form.is_bound) self.assertFalse(form.is_valid()) self.assertEqual([_(u'The password fields did not match'), ], form.errors['__all__'])
def user_batch(): """Create and commit a batch of User instances.""" return [ UserFactory(roles=RoleFactory.create_batch(randint(0, 3))) for _ in range(randint(3, 5)) ]
def test_create_user(): user = UserFactory() result = Session.execute(select(User)).scalar_one() assert (result.id, result.name, result.email, result.active, result.verified) \ == (user.id, user.name, user.email, user.active, user.verified)
def test_create_user_with_roles(): roles = RoleFactory.create_batch(5) user = UserFactory(roles=roles) result = Session.execute(select(UserRole)).scalars() assert [(row.user_id, row.role_id) for row in result] \ == [(user.id, role.id) for role in roles]
def setUp(self): encoder = UserAuthCode(settings.SECRET_KEY) self.user = UserFactory(is_active=False) self.code = encoder.auth_code(self.user)
def test_create_hold(create_hold: CreateHold): user = UserFactory.create() event = EventFactory.create() hold = create_hold.do(user, {"event_id": event.id, "quantity": 3})
def setUp(self): self.user = UserFactory() self.region = RegionFactory() self.message = MessageFactory.build(georegion=self.region)
def test_signup(self): admin_role = RoleFactory.create(name='admin') superadmin_role = RoleFactory.create(name='superadmin') UserFactory.create(role=admin_role) UserFactory.create(email='*****@*****.**', role=superadmin_role) response = self.client.get('/signup') self.assert200(response) subcats = json.loads(self.get_context_variable('subcategories')) # assert three categories (plus the total category) self.assertEquals(len(subcats.keys()), 4) # assert five total subcatgories (plus 5 in the total field) self.assertEquals(len([item for sublist in subcats.values() for item in sublist]), 10) # assert email, business, categories needed no_email_post = self.client.post('/signup', data=dict( first_name='foo' )) self.assert200(no_email_post) self.assertTrue(no_email_post.data.count('alert-danger'), 3) # ensure that there are two required field notes self.assertTrue(no_email_post.data.count('This field is required'), 2) # assert valid email address invalid_email_post = self.client.post('/signup', data=dict( email='INVALID', business_name='test' )) self.assert200(invalid_email_post) self.assertTrue(invalid_email_post.data.count('alert-danger'), 1) self.assertTrue(invalid_email_post.data.count('Invalid email address.'), 1) # assert you need at least one category invalid_no_categories = self.client.post('/signup', data=dict( email='*****@*****.**', business_name='foo' )) self.assert200(invalid_no_categories) self.assertTrue(invalid_no_categories.data.count('alert-danger'), 1) self.assertTrue(invalid_no_categories.data.count('You must select at least one!'), 1) # assert valid categories with mail.record_messages() as outbox: # successful post with only one set of subcategories success_post = self.client.post('/signup', data={ 'email': '*****@*****.**', 'business_name': 'foo', 'subcategories-1': 'on', 'categories': 'Apparel', 'subscribed_to_newsletter': True }) with self.client.session_transaction() as session: assert 'email' in session assert 'business_name' in session self.assertEquals(session['email'], '*****@*****.**') self.assertEquals(session['business_name'], 'foo') self.assertEquals(success_post.status_code, 302) self.assertEquals(success_post.location, 'http://localhost/') # should send three emails # one to the vendor, one to the admins self.assertEquals(len(outbox), 2) self.assertEquals(Vendor.query.count(), 1) self.assertTrue(Vendor.query.first().subscribed_to_newsletter) self.assertEquals(len(Vendor.query.first().categories), 1) self.assert_flashes( 'Thank you for signing up! Check your email for more information', 'alert-success' ) # successful post with two sets of subcategories success_post_everything = self.client.post('/signup', data={ 'email': '*****@*****.**', 'business_name': 'foo', 'subcategories-1': 'on', 'subcategories-2': 'on', 'subcategories-3': 'on', 'subcategories-4': 'on', 'subcategories-5': 'on', 'categories': 'Apparel', 'subscribed_to_newsletter': True }) self.assertEquals(success_post_everything.status_code, 302) self.assertEquals(success_post_everything.location, 'http://localhost/') self.assertEquals(len(outbox), 4) self.assertEquals(Vendor.query.count(), 2) self.assertEquals(len(Vendor.query.filter(Vendor.email == '*****@*****.**').first().categories), 5) self.assert_flashes('Thank you for signing up! Check your email for more information', 'alert-success') # successful post with existing email should update the profile, not send message success_post_old_email = self.client.post('/signup', data={ 'email': '*****@*****.**', 'business_name': 'foo', 'subcategories-1': 'on', 'subcategories-2': 'on', 'subcategories-3': 'on', 'categories': 'Apparel', 'subscribed_to_newsletter': True }) self.assertEquals(success_post_old_email.status_code, 302) self.assertEquals(success_post_old_email.location, 'http://localhost/') self.assertEquals(len(outbox), 4) self.assertEquals(Vendor.query.count(), 2) self.assertEquals(len(Vendor.query.filter(Vendor.email == '*****@*****.**').first().categories), 5) self.assert_flashes( "You are already signed up! Your profile was updated with this new information", 'alert-info' ) admin_mail, vendor_mail = 0, 0 for _mail in outbox: if 'new vendor has signed up on beacon' in _mail.subject: admin_mail += 1 if 'Thank you for signing up' in _mail.subject: vendor_mail += 1 self.assertEquals(admin_mail, 2) self.assertEquals(vendor_mail, 2) with self.client.session_transaction() as session: assert 'email' in session assert 'business_name' in session self.assertEquals(session['email'], '*****@*****.**') self.assertEquals(session['business_name'], 'foo')
def test_signup(self): admin_role = RoleFactory.create(name='admin') superadmin_role = RoleFactory.create(name='superadmin') UserFactory.create(role=admin_role) UserFactory.create(email='*****@*****.**', role=superadmin_role) response = self.client.get('/signup') self.assert200(response) subcats = json.loads(self.get_context_variable('subcategories')) # assert three categories (plus the total category) self.assertEquals(len(subcats.keys()), 4) # assert five total subcatgories (plus 5 in the total field) self.assertEquals( len([item for sublist in subcats.values() for item in sublist]), 10) # assert email, business, categories needed no_email_post = self.client.post('/signup', data=dict(first_name='foo')) self.assert200(no_email_post) self.assertTrue(no_email_post.data.count('alert-danger'), 3) # ensure that there are two required field notes self.assertTrue(no_email_post.data.count('This field is required'), 2) # assert valid email address invalid_email_post = self.client.post('/signup', data=dict(email='INVALID', business_name='test')) self.assert200(invalid_email_post) self.assertTrue(invalid_email_post.data.count('alert-danger'), 1) self.assertTrue( invalid_email_post.data.count('Invalid email address.'), 1) # assert you need at least one category invalid_no_categories = self.client.post('/signup', data=dict( email='*****@*****.**', business_name='foo')) self.assert200(invalid_no_categories) self.assertTrue(invalid_no_categories.data.count('alert-danger'), 1) self.assertTrue( invalid_no_categories.data.count('You must select at least one!'), 1) # assert valid categories with mail.record_messages() as outbox: # successful post with only one set of subcategories success_post = self.client.post('/signup', data={ 'email': '*****@*****.**', 'business_name': 'foo', 'subcategories-1': 'on', 'categories': 'Apparel', 'subscribed_to_newsletter': True }) with self.client.session_transaction() as session: assert 'email' in session assert 'business_name' in session self.assertEquals(session['email'], '*****@*****.**') self.assertEquals(session['business_name'], 'foo') self.assertEquals(success_post.status_code, 302) self.assertEquals(success_post.location, 'http://localhost/') # should send three emails # one to the vendor, one to the admins self.assertEquals(len(outbox), 2) self.assertEquals(Vendor.query.count(), 1) self.assertTrue(Vendor.query.first().subscribed_to_newsletter) self.assertEquals(len(Vendor.query.first().categories), 1) self.assert_flashes( 'Thank you for signing up! Check your email for more information', 'alert-success') # successful post with two sets of subcategories success_post_everything = self.client.post( '/signup', data={ 'email': '*****@*****.**', 'business_name': 'foo', 'subcategories-1': 'on', 'subcategories-2': 'on', 'subcategories-3': 'on', 'subcategories-4': 'on', 'subcategories-5': 'on', 'categories': 'Apparel', 'subscribed_to_newsletter': True }) self.assertEquals(success_post_everything.status_code, 302) self.assertEquals(success_post_everything.location, 'http://localhost/') self.assertEquals(len(outbox), 4) self.assertEquals(Vendor.query.count(), 2) self.assertEquals( len( Vendor.query.filter( Vendor.email == '*****@*****.**').first().categories), 5) self.assert_flashes( 'Thank you for signing up! Check your email for more information', 'alert-success') # successful post with existing email should update the profile, not send message success_post_old_email = self.client.post( '/signup', data={ 'email': '*****@*****.**', 'business_name': 'foo', 'subcategories-1': 'on', 'subcategories-2': 'on', 'subcategories-3': 'on', 'categories': 'Apparel', 'subscribed_to_newsletter': True }) self.assertEquals(success_post_old_email.status_code, 302) self.assertEquals(success_post_old_email.location, 'http://localhost/') self.assertEquals(len(outbox), 4) self.assertEquals(Vendor.query.count(), 2) self.assertEquals( len( Vendor.query.filter( Vendor.email == '*****@*****.**').first().categories), 5) self.assert_flashes( "You are already signed up! Your profile was updated with this new information", 'alert-info') admin_mail, vendor_mail = 0, 0 for _mail in outbox: if 'new vendor has signed up on beacon' in _mail.subject: admin_mail += 1 if 'Thank you for signing up' in _mail.subject: vendor_mail += 1 self.assertEquals(admin_mail, 2) self.assertEquals(vendor_mail, 2) with self.client.session_transaction() as session: assert 'email' in session assert 'business_name' in session self.assertEquals(session['email'], '*****@*****.**') self.assertEquals(session['business_name'], 'foo')
def setUp(self): self.encoder = UserAuthCode('secret') self.user = UserFactory(is_active=False)
def setUp(self): self.user = UserFactory()
def setUp(self): self.user = UserFactory.build( first_name='Boy', last_name='Factory' )
def test_create_organization(create_organization: CreateOrganization): user = UserFactory.create() org = create_organization.do(user, VALID_ORGANIZATION_DATA) assert org.id assert org.name == VALID_ORGANIZATION_DATA["name"]