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(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_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_opportunity_has_docs_true(self):
opp = OpportunityFactory.build(
is_public=False, planned_publish=self.yesterday,
planned_submission_start=self.today, planned_submission_end=self.tomorrow,
opportunity_documents=[OpportunityDocumentFactory.build()]
)
self.assertTrue(opp.has_docs)
def test_opportunity_closed(self):
closed_opportunity = OpportunityFactory.build(
is_public=True, planned_publish=self.yesterday,
planned_submission_start=self.yesterday, planned_submission_end=self.yesterday
)
self.assertTrue(closed_opportunity.is_published)
self.assertFalse(closed_opportunity.is_upcoming)
self.assertFalse(closed_opportunity.is_submission_start)
self.assertTrue(closed_opportunity.is_submission_end)
closed_opportunity_today_deadline = OpportunityFactory.build(
is_public=True, planned_publish=self.yesterday,
planned_submission_start=self.yesterday, planned_submission_end=self.today
)
self.assertTrue(closed_opportunity_today_deadline.is_published)
self.assertFalse(closed_opportunity_today_deadline.is_upcoming)
self.assertFalse(closed_opportunity_today_deadline.is_submission_start)
self.assertTrue(closed_opportunity_today_deadline.is_submission_end)
def test_opportunity_has_docs_true(self):
opp = OpportunityFactory.build(
is_public=False,
planned_publish=self.yesterday,
planned_submission_start=self.today,
planned_submission_end=self.tomorrow,
opportunity_documents=[OpportunityDocumentFactory.build()])
self.assertTrue(opp.has_docs)
def test_opportunity_open_not_published(self):
open_opportunity = OpportunityFactory.build(
is_public=True, planned_publish=self.tomorrow,
planned_submission_start=self.today, planned_submission_end=self.tomorrow
)
self.assertFalse(open_opportunity.is_published)
self.assertFalse(open_opportunity.is_upcoming)
self.assertFalse(open_opportunity.is_submission_start)
self.assertFalse(open_opportunity.is_submission_end)
def test_opportunity_notpublic(self):
notpublic_opportunity = OpportunityFactory.build(
is_public=False, planned_publish=self.yesterday,
planned_submission_start=self.today, planned_submission_end=self.tomorrow
)
self.assertFalse(notpublic_opportunity.is_published)
self.assertFalse(notpublic_opportunity.is_upcoming)
self.assertFalse(notpublic_opportunity.is_submission_start)
self.assertFalse(notpublic_opportunity.is_submission_end)
def test_opportunity_pending(self):
pending_opportunity = OpportunityFactory.build(
is_public=True, planned_publish=self.yesterday,
planned_submission_start=self.tomorrow, planned_submission_end=self.tomorrow
)
self.assertTrue(pending_opportunity.is_published)
self.assertTrue(pending_opportunity.is_upcoming)
self.assertFalse(pending_opportunity.is_submission_start)
self.assertFalse(pending_opportunity.is_submission_end)
def test_opportunity_closed(self):
closed_opportunity = OpportunityFactory.build(
is_public=True,
planned_publish=self.yesterday,
planned_submission_start=self.yesterday,
planned_submission_end=self.yesterday)
self.assertTrue(closed_opportunity.is_published)
self.assertFalse(closed_opportunity.is_upcoming)
self.assertFalse(closed_opportunity.is_submission_start)
self.assertTrue(closed_opportunity.is_submission_end)
closed_opportunity_today_deadline = OpportunityFactory.build(
is_public=True,
planned_publish=self.yesterday,
planned_submission_start=self.yesterday,
planned_submission_end=self.today)
self.assertTrue(closed_opportunity_today_deadline.is_published)
self.assertFalse(closed_opportunity_today_deadline.is_upcoming)
self.assertFalse(closed_opportunity_today_deadline.is_submission_start)
self.assertTrue(closed_opportunity_today_deadline.is_submission_end)
def test_opportunity_pending(self):
pending_opportunity = OpportunityFactory.build(
is_public=True,
planned_publish=self.yesterday,
planned_submission_start=self.tomorrow,
planned_submission_end=self.tomorrow)
self.assertTrue(pending_opportunity.is_published)
self.assertTrue(pending_opportunity.is_upcoming)
self.assertFalse(pending_opportunity.is_submission_start)
self.assertFalse(pending_opportunity.is_submission_end)
def test_opportunity_notpublic(self):
notpublic_opportunity = OpportunityFactory.build(
is_public=False,
planned_publish=self.yesterday,
planned_submission_start=self.today,
planned_submission_end=self.tomorrow)
self.assertFalse(notpublic_opportunity.is_published)
self.assertFalse(notpublic_opportunity.is_upcoming)
self.assertFalse(notpublic_opportunity.is_submission_start)
self.assertFalse(notpublic_opportunity.is_submission_end)
def test_opportunity_open_not_published(self):
open_opportunity = OpportunityFactory.build(
is_public=True,
planned_publish=self.tomorrow,
planned_submission_start=self.today,
planned_submission_end=self.tomorrow)
self.assertFalse(open_opportunity.is_published)
self.assertFalse(open_opportunity.is_upcoming)
self.assertFalse(open_opportunity.is_submission_start)
self.assertFalse(open_opportunity.is_submission_end)
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 send_publish_email(self, send):
should_send = OpportunityFactory.build(
is_public=True,
planned_publish=self.yesterday,
planned_submission_end=self.tomorrow,
publish_notification_sent=False)
self.assertTrue(should_send.send_publish_email())
self.assertTrue(send.called_once)
should_not_send = OpportunityFactory.build(
is_public=True,
planned_publish=self.yesterday,
planned_submission_end=self.tomorrow,
publish_notification_sent=True)
self.assertFalse(should_not_send.send_publish_email())
self.assertTrue(send.called_once)
should_not_send2 = OpportunityFactory.build(
is_public=False,
planned_publish=self.yesterday,
planned_submission_end=self.tomorrow,
publish_notification_sent=False)
self.assertFalse(should_not_send2.send_publish_email())
self.assertTrue(send.called_once)
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 send_publish_email(self, send):
should_send = OpportunityFactory.build(
is_public=True, planned_publish=self.yesterday,
planned_submission_end=self.tomorrow,
publish_notification_sent=False
)
self.assertTrue(should_send.send_publish_email())
self.assertTrue(send.called_once)
should_not_send = OpportunityFactory.build(
is_public=True, planned_publish=self.yesterday,
planned_submission_end=self.tomorrow,
publish_notification_sent=True
)
self.assertFalse(should_not_send.send_publish_email())
self.assertTrue(send.called_once)
should_not_send2 = OpportunityFactory.build(
is_public=False, planned_publish=self.yesterday,
planned_submission_end=self.tomorrow,
publish_notification_sent=False
)
self.assertFalse(should_not_send2.send_publish_email())
self.assertTrue(send.called_once)
def test_vendor_documents_needed_with_docs(self, query):
opportunity = OpportunityFactory.build(vendor_documents_needed=[1])
opportunity.get_vendor_documents()
self.assertTrue(query.filter.called)
def test_has_vendor_documents_needed_false(self):
opportunity = OpportunityFactory.build()
self.assertFalse(opportunity.has_vendor_documents())
opportunity2 = OpportunityFactory.build(vendor_documents_needed=[])
self.assertFalse(opportunity.has_vendor_documents())
def test_vendor_documents_needed_no_docs(self):
opportunity = OpportunityFactory.build()
self.assertEquals(opportunity.get_vendor_documents(), [])
def test_vendor_documents_needed_with_docs(self, query):
opportunity = OpportunityFactory.build(vendor_documents_needed=[1])
opportunity.get_vendor_documents()
self.assertTrue(query.filter.called)
def test_opportunity_has_docs_false(self):
opp = OpportunityFactory.build(is_public=False,
planned_publish=self.yesterday,
planned_submission_start=self.today,
planned_submission_end=self.tomorrow)
self.assertFalse(opp.has_docs)
def test_has_vendor_documents_needed_true(self):
opportunity = OpportunityFactory.build(vendor_documents_needed=[1])
self.assertTrue(opportunity.has_vendor_documents())
def test_has_vendor_documents_needed_false(self):
opportunity = OpportunityFactory.build()
self.assertFalse(opportunity.has_vendor_documents())
opportunity2 = OpportunityFactory.build(vendor_documents_needed=[])
self.assertFalse(opportunity.has_vendor_documents())
def test_vendor_documents_needed_no_docs(self):
opportunity = OpportunityFactory.build()
self.assertEquals(opportunity.get_vendor_documents(), [])
def test_opportunity_valid_qa_period(self):
good_qa = OpportunityFactory.build(
enable_qa=True, qa_start=self.yesterday, qa_end=self.tomorrow
)
self.assertTrue(good_qa.accepting_questions)
self.assertFalse(good_qa.qa_closed)
def test_opportunity_qa_open_in_future(self):
future_qa = OpportunityFactory.build(
enable_qa=True, qa_start=self.tomorrow, qa_end=self.tomorrow
)
self.assertFalse(future_qa.accepting_questions)
self.assertFalse(future_qa.qa_closed)
def test_opportunity_qa_closed(self):
closed_opp = OpportunityFactory.build(
enable_qa=True, qa_start=self.yesterday, qa_end=self.yesterday
)
self.assertFalse(closed_opp.accepting_questions)
self.assertTrue(closed_opp.qa_closed)
def test_opportunity_qa_disabled(self):
qa_disabled = OpportunityFactory.build(
enable_qa=False
)
self.assertFalse(qa_disabled.accepting_questions)
self.assertFalse(qa_disabled.qa_closed)
def test_opportunity_has_docs_false(self):
opp = OpportunityFactory.build(
is_public=False, planned_publish=self.yesterday,
planned_submission_start=self.today, planned_submission_end=self.tomorrow
)
self.assertFalse(opp.has_docs)
def test_has_vendor_documents_needed_true(self):
opportunity = OpportunityFactory.build(vendor_documents_needed=[1])
self.assertTrue(opportunity.has_vendor_documents())
