def collection_batch_no_projects():
"""Create and commit a batch of Collection instances
without projects, for testing the update API - we cannot
assign projects to collections, only the other way around."""
collections = [CollectionFactory() for _ in range(randint(3, 5))]
for collection in collections:
ClientFactory.create_batch(randint(0, 3), collection=collection)
RoleFactory.create_batch(randint(0, 3), collection=collection)
return collections
def collection_batch():
"""Create and commit a batch of Collection instances,
with associated projects, clients and roles."""
collections = [CollectionFactory() for _ in range(randint(3, 5))]
ProjectFactory.create_batch(randint(0, 3), collections=collections)
for collection in collections:
ClientFactory.create_batch(randint(0, 3), collection=collection)
RoleFactory.create_batch(randint(0, 3), collection=collection)
return collections
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_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_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_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 test_create_role_with_scopes():
scopes = ScopeFactory.create_batch(
5, type='odp') + ScopeFactory.create_batch(5, type='client')
role = RoleFactory(scopes=scopes)
result = Session.execute(select(RoleScope)).scalars()
assert [(row.role_id, row.scope_id, row.scope_type) for row in result] \
== [(role.id, scope.id, scope.type) for scope in scopes]
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 role_build(collection=None, **id):
"""Build and return an uncommitted Role instance.
Referenced scopes and/or collection are however committed."""
return RoleFactory.build(
**id,
scopes=ScopeFactory.create_batch(randint(0, 3), type=choice(('odp', 'client'))),
collection=collection or (collection := CollectionFactory() if randint(0, 1) else None),
collection_id=collection.id if collection else None,
)
def role_batch():
"""Create and commit a batch of Role instances."""
return [
RoleFactory(
scopes=ScopeFactory.create_batch(randint(0, 3), type=choice(('odp', 'client'))),
is_collection_role=n in (1, 2) or randint(0, 1),
)
for n in range(randint(3, 5))
]
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_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)
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_new_user_success(self, urlopen):
# insert all of our roles
RoleFactory.create(name='superadmin')
RoleFactory.create(name='admin')
RoleFactory.create(name='staff')
# assert we have only one user
self.assertEquals(User.query.count(), 1)
mock_open = Mock()
mock_open.read.side_effect = [
'{"status": "okay", "email": "*****@*****.**"}'
]
urlopen.return_value = mock_open
post = self.client.post('/users/auth?next=/explore/', data=dict(
assertion='test'
))
# assert we add a new user and redirect to the register page
self.assertEquals(User.query.count(), 2)
self.assertEquals(post.status_code, 200)
self.assertEquals(post.data, '/users/profile')
# assert we get the new user message
register = self.client.get('/users/profile')
self.assertTrue('Welcome to the Pittsbugh Purchasing Suite!' in register.data)
self.assert_template_used('users/profile.html')
# assert that you cannot update with junk information
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 the user successfully
update = self.client.post('/users/profile', data=dict(
first_name='foo', last_name='bar', department=str(self.department1.id)
))
# assert we successfully update
self.assertEquals(update.status_code, 302)
self.assertEquals(update.location, 'http://localhost/users/profile')
self.assert_flashes('Updated your profile!', 'alert-success')
# make sure the new user message is gone
updated = self.client.get('/users/profile')
self.assertTrue('Welcome to the Pittsbugh Purchasing Suite!' not in updated.data)
self.assert_template_used('users/profile.html')
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 setUp(self):
super(TestUsers, self).setUp()
self.staff = RoleFactory.create(name='staff')
AcceptedEmailDomainsFactory.create(domain='foo.com')
self.new_dept = DepartmentFactory.create(name='New User').save()
self.department1 = DepartmentFactory.create(name='Test').save()
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 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_signup(self):
admin_role = RoleFactory.create(name="admin")
superadmin_role = RoleFactory.create(name="superadmin")
UserFactory.create(roles=[admin_role])
UserFactory.create(email="*****@*****.**", roles=[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 test_create_role():
role = RoleFactory()
result = Session.execute(select(Role)).scalar_one()
assert (result.id, result.collection_id) == (role.id, None)
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 test_create_role_with_collection():
role = RoleFactory(is_collection_role=True)
result = Session.execute(select(Role, Collection).join(Collection)).one()
assert (result.Role.id, result.Role.collection_id, result.Collection.name) \
== (role.id, role.collection.id, role.collection.name)
