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"]
