def test_test_publishing_a_brief_sets_published_at(self):
brief = Brief(data={}, framework=self.framework, lot=self.lot)
assert brief.published_at is None
brief.status = 'live'
assert not brief.clarification_questions_are_closed
assert isinstance(brief.published_at, datetime)
def brief(self, app, users):
with app.app_context():
now = pendulum.now('utc')
framework = frameworks_service.find(
slug='digital-marketplace').one_or_none()
specialist_lot = lots_service.find(slug='specialist').one_or_none()
brief = Brief(id=1,
data={
'openTo': 'selected',
'sellers': {
'123': {
'name': 'FriendFace'
},
'456': {
'name': 'FriendFlutter'
}
}
},
framework=framework,
lot=specialist_lot,
users=users,
published_at=now.subtract(days=2),
withdrawn_at=None)
brief.questions_closed_at = now.add(days=3)
brief.closed_at = now.add(days=5)
db.session.add(brief)
db.session.commit()
yield db.session.query(Brief).first()
def test_cannot_set_live_brief_to_draft(self):
brief = Brief(data={},
framework=self.framework,
lot=self.lot,
published_at=datetime.utcnow())
with pytest.raises(ValidationError):
brief.status = 'draft'
def test_can_set_live_brief_to_draft(self):
brief = Brief(data={},
framework=self.framework,
lot=self.lot,
published_at=datetime.utcnow())
brief.status = 'draft'
assert brief.published_at is None
def test_foreign_fields_stripped_from_brief_data(self):
brief = Brief(data={}, framework=self.framework, lot=self.lot)
brief.data = {
'frameworkSlug': 'test',
'frameworkName': 'test',
'lot': 'test',
'lotName': 'test',
'title': 'test',
}
assert brief.data == {'title': 'test'}
def test_new_clarification_questions_get_added_to_the_end(self):
with self.app.app_context():
brief = Brief(data={},
framework=self.framework,
lot=self.lot,
status="live")
db.session.add(brief)
brief.add_clarification_question("How?", "This")
brief.add_clarification_question("When", "Then")
db.session.commit()
assert brief.clarification_questions[0].question == "How?"
assert brief.clarification_questions[1].question == "When"
def test_updating_a_brief_updates_dates(self):
with self.app.app_context():
brief = Brief(data={}, framework=self.framework, lot=self.lot)
db.session.add(brief)
db.session.commit()
updated_at = brief.updated_at
created_at = brief.created_at
brief.data = {'foo': 'bar'}
db.session.add(brief)
db.session.commit()
assert brief.created_at == created_at
assert brief.updated_at > updated_at
def briefs(app, request, users):
with app.app_context():
now = pendulum.now('utc')
framework = frameworks_service.find(
slug='digital-marketplace').one_or_none()
atm_lot = lots_service.find(slug='atm').one_or_none()
rfx_lot = lots_service.find(slug='rfx').one_or_none()
specialist_lot = lots_service.find(slug='specialist').one_or_none()
training_lot = lots_service.find(slug='training2').one_or_none()
db.session.add(
Brief(id=1,
data={},
framework=framework,
lot=atm_lot,
users=users,
published_at=now.subtract(days=2),
withdrawn_at=None))
db.session.add(
Brief(id=2,
data={},
framework=framework,
lot=rfx_lot,
users=users,
published_at=now.subtract(days=2),
withdrawn_at=None))
db.session.add(
Brief(id=3,
data={},
framework=framework,
lot=specialist_lot,
users=users,
published_at=now.subtract(days=2),
withdrawn_at=None))
db.session.add(
Brief(id=4,
data={},
framework=framework,
lot=training_lot,
users=users,
published_at=now.subtract(days=2),
withdrawn_at=None))
db.session.commit()
yield db.session.query(Brief).all()
def test_cannot_update_lot_by_id(self):
with self.app.app_context():
with pytest.raises(ValidationError):
Brief(
data={},
framework=self.framework,
lot_id=self.framework.get_lot('user-research-studios').id)
def test_when_what_training_and_details_is_set():
brief_data = {
'whatTraining': ['other', 'content design', 'user research'],
'ldsContentDesignProposalOrLds': 'ldsUnits',
'ldsUserResearchProposalOrLds': 'specify',
'trainingDetailType': 'foo',
'trainingDetailCover': 'bar'
}
lot = Lot(name='Training', one_service_limit=True)
brief = Brief(lot=lot, data=brief_data)
required_fields = [
'trainingDetailType',
'trainingDetailCover',
'ldsContentDesignProposalOrLds',
'ldsContentDesignUnits',
'ldsUserResearchProposalOrLds',
'ldsUserResearchTrainingNeeds']
errors = check_lds(brief, required_fields)
assert errors is not []
assert len(errors) == 2
assert errors[0]['ldsContentDesignUnits'] == 'answer_required'
assert errors[1]['ldsUserResearchTrainingNeeds'] == 'answer_required'
def test_when_own_preference_and_approach_not_set():
brief_data = {'approachSelector': 'ownPreference'}
lot = Lot(name='Training', one_service_limit=True)
brief = Brief(lot=lot, data=brief_data)
error = check_training_method(brief)
assert error is not None
assert error['trainingApproachOwn'] == 'answer_required'
def test_list_brief_responses_for_brief_id(self):
with self.app.app_context():
brief = Brief(data=example_listings.brief_data().example(),
status='live',
framework_id=5,
lot=Lot.query.get(5))
db.session.add(brief)
db.session.commit()
another_brief_id = brief.id
for i in range(8):
self.setup_dummy_brief_response(brief_id=self.brief_id,
supplier_id=0)
self.setup_dummy_brief_response(brief_id=another_brief_id,
supplier_id=0)
res = self.list_brief_responses(brief_id=another_brief_id)
data = json.loads(res.get_data(as_text=True))
assert res.status_code == 200
assert len(data['briefResponses']) == 8
assert all(br['briefId'] == another_brief_id
for br in data['briefResponses'])
assert 'self' in data['links']
def briefs(app, request, users):
params = request.param if hasattr(request, 'param') else {}
published_at = pendulum.parse(
params['published_at']) if 'published_at' in params else utcnow()
published_at = None if 'unpublished' in params and params[
'unpublished'] else published_at
data = params[
'data'] if 'data' in params else COMPLETE_SPECIALIST_BRIEF.copy()
data['sellerCategory'] = params[
'sellerCategory'] if 'sellerCategory' in params else 1
lot_slug = params['lot_slug'] if 'lot_slug' in params else 'specialist'
framework_slug = params[
'framework_slug'] if 'framework_slug' in params else 'digital-marketplace'
with app.app_context():
for i in range(1, 6):
db.session.add(
Brief(id=i,
data=data,
framework=Framework.query.filter(
Framework.slug == framework_slug).first(),
lot=Lot.query.filter(Lot.slug == lot_slug).first(),
users=users,
published_at=published_at,
withdrawn_at=None))
db.session.flush()
db.session.commit()
yield Brief.query.all()
def test_list_brief_responses_by_one_framework_slug(
self, live_dos2_framework):
supplier_framework = SupplierFramework(
supplier_id=0, framework_id=live_dos2_framework["id"])
dos2_brief = Brief(data=example_listings.brief_data().example(),
status='live',
framework_id=live_dos2_framework["id"],
lot=Lot.query.get(6))
db.session.add_all([dos2_brief, supplier_framework])
db.session.commit()
dos2_brief_id = dos2_brief.id
for i in range(3):
self.setup_dummy_brief_response(brief_id=self.brief_id,
supplier_id=0)
self.setup_dummy_brief_response(brief_id=dos2_brief_id,
supplier_id=0)
res = self.list_brief_responses(
framework='digital-outcomes-and-specialists-2')
data = json.loads(res.get_data(as_text=True))
assert res.status_code == 200
assert len(data['briefResponses']) == 3
assert all(br['brief']['framework']['slug'] ==
"digital-outcomes-and-specialists-2"
for br in data['briefResponses'])
assert 'self' in data['links']
def test_update_from_json(self):
with self.app.app_context():
brief = Brief(data={}, framework=self.framework, lot=self.lot)
db.session.add(brief)
db.session.commit()
updated_at = brief.updated_at
created_at = brief.created_at
brief.update_from_json({"foo": "bar"})
db.session.add(brief)
db.session.commit()
assert brief.created_at == created_at
assert brief.updated_at > updated_at
assert brief.data == {'foo': 'bar'}
def setup_dummy_brief(
self, id=None, user_id=1, status=None, data=None, published_at=None, withdrawn_at=None,
framework_slug='digital-outcomes-and-specialists', lot_slug='digital-specialists'
):
if published_at is not None and status is not None:
raise ValueError('Cannot provide both status and published_at')
if withdrawn_at is not None and published_at is None:
raise ValueError('If setting withdrawn_at then published_at must also be set')
if not published_at:
if status == 'closed':
published_at = datetime.utcnow() - timedelta(days=1000)
elif status == 'withdrawn':
published_at = datetime.utcnow() - timedelta(days=1000)
withdrawn_at = datetime.utcnow()
else:
published_at = None if status == 'draft' else datetime.utcnow()
framework = Framework.query.filter(Framework.slug == framework_slug).first()
lot = Lot.query.filter(Lot.slug == lot_slug).first()
db.session.add(Brief(
id=id,
data=data,
framework=framework,
lot=lot,
users=[User.query.get(user_id)],
published_at=published_at,
withdrawn_at=withdrawn_at,
))
db.session.commit()
def setup(self):
super(BaseBriefResponseTest, self).setup()
self.supplier_ids = self.setup_dummy_suppliers(2)
supplier_frameworks = [
SupplierFramework(supplier_id=supplier_id, framework_id=5)
for supplier_id in self.supplier_ids
]
brief = Brief(data=example_listings.brief_data().example(),
status='live',
framework_id=5,
lot=Lot.query.get(5))
service = Service(
service_id='1234560987654321',
data={'locations': [brief.data['location']]},
status='published',
framework_id=5,
lot_id=5,
supplier_id=0,
)
specialist_brief = Brief(data=example_listings.brief_data().example(),
status='live',
framework_id=5,
lot=Lot.query.get(6))
specialist_service = Service(
service_id='1234560987654322',
data={
'developerLocations': [specialist_brief.data['location']],
'developerPriceMin': "0",
'developerPriceMax': "1000"
},
status='published',
framework_id=5,
lot_id=6,
supplier_id=0,
)
db.session.add_all(
[service, specialist_service, brief, specialist_brief] +
supplier_frameworks)
db.session.commit()
self.brief_id = brief.id
self.specialist_brief_id = specialist_brief.id
def test_brief_lot_must_be_associated_to_the_framework(self):
with self.app.app_context():
other_framework = Framework.query.filter(
Framework.slug == 'g-cloud-7').first()
brief = Brief(data={}, framework=other_framework, lot=self.lot)
db.session.add(brief)
with pytest.raises(IntegrityError):
db.session.commit()
def test_non_buyer_users_cannot_be_added_to_a_brief(self):
with self.app.app_context():
self.setup_dummy_user(role='admin')
with pytest.raises(ValidationError):
Brief(data={},
framework=self.framework,
lot=self.lot,
users=User.query.all())
def test_expired_status_for_a_brief_with_passed_close_date(self):
brief = Brief(data={},
framework=self.framework,
lot=self.lot,
published_at=datetime.utcnow() - timedelta(days=1000))
assert brief.status == 'closed'
assert brief.clarification_questions_are_closed
assert brief.applications_closed_at < datetime.utcnow()
def test_query_draft_brief(self):
with self.app.app_context():
db.session.add(
Brief(data={}, framework=self.framework, lot=self.lot))
db.session.commit()
assert Brief.query.filter(Brief.status == 'draft').count() == 1
assert Brief.query.filter(Brief.status == 'live').count() == 0
assert Brief.query.filter(Brief.status == 'closed').count() == 0
def test_when_own_preference_and_approach_is_set():
brief_data = {
'approachSelector': 'ownPreference',
'trainingApproachOwn': 'test'
}
lot = Lot(name='Training', one_service_limit=True)
brief = Brief(lot=lot, data=brief_data)
error = check_training_method(brief)
assert error is None
def setup_dummy_brief(self,
id=None,
user_id=1,
status=None,
data=None,
published_at=None,
withdrawn_at=None,
cancelled_at=None,
unsuccessful_at=None,
framework_slug='digital-outcomes-and-specialists',
lot_slug='digital-specialists',
add_clarification_question=False):
if published_at is not None and status is not None:
raise ValueError('Cannot provide both status and published_at')
if withdrawn_at is not None and published_at is None:
raise ValueError(
'If setting withdrawn_at then published_at must also be set')
if not published_at:
if status == 'closed':
published_at = datetime.utcnow() - timedelta(days=1000)
elif status == 'withdrawn':
published_at = datetime.utcnow() - timedelta(days=1000)
withdrawn_at = datetime.utcnow()
elif status == 'cancelled':
published_at = datetime.utcnow() - timedelta(days=1000)
cancelled_at = datetime.utcnow()
elif status == 'unsuccessful':
published_at = datetime.utcnow() - timedelta(days=1000)
unsuccessful_at = datetime.utcnow()
else:
published_at = None if status == 'draft' else datetime.utcnow()
framework = Framework.query.filter(
Framework.slug == framework_slug).first()
lot = Lot.query.filter(Lot.slug == lot_slug).first()
brief = Brief(id=id,
data=data,
framework=framework,
lot=lot,
users=[User.query.get(user_id)],
published_at=published_at,
withdrawn_at=withdrawn_at,
cancelled_at=cancelled_at,
unsuccessful_at=unsuccessful_at)
db.session.add(brief)
if add_clarification_question:
db.session.add(
BriefClarificationQuestion(
brief=brief,
question=
"What is the answer to the meaning of life, the Universe and everything?",
answer="42"))
db.session.commit()
return brief
def test_add_brief_clarification_question(self):
with self.app.app_context():
brief = Brief(data={},
framework=self.framework,
lot=self.lot,
status="live")
db.session.add(brief)
db.session.commit()
brief.add_clarification_question(
"How do you expect to deliver this?",
"By the power of Grayskull")
db.session.commit()
assert len(brief.clarification_questions) == 1
assert len(
BriefClarificationQuestion.query.filter(
BriefClarificationQuestion._brief_id ==
brief.id).all()) == 1
def test_buyer_users_can_be_added_to_a_brief(self):
with self.app.app_context():
self.setup_dummy_user(role='buyer')
brief = Brief(data={},
framework=self.framework,
lot=self.lot,
users=User.query.all())
assert len(brief.users) == 1
def briefs(self, app):
with app.app_context():
framework = frameworks_service.find(
slug='digital-marketplace').one_or_none()
digital_professional_lot = lots_service.find(
slug='digital-professionals').one_or_none()
specialist_lot = lots_service.find(slug='specialist').one_or_none()
db.session.add(
Brief(id=1,
data={},
framework=framework,
lot=digital_professional_lot))
db.session.add(
Brief(id=2, data={}, framework=framework, lot=specialist_lot))
db.session.commit()
yield db.session.query(Brief).all()
def test_create_a_new_brief(self):
with self.app.app_context():
brief = Brief(data={}, framework=self.framework, lot=self.lot)
db.session.add(brief)
db.session.commit()
assert isinstance(brief.created_at, datetime)
assert isinstance(brief.updated_at, datetime)
assert brief.id is not None
assert brief.data == dict()
def test_query_brief_applications_closed_at_date(self):
with self.app.app_context():
db.session.add(
Brief(data={},
framework=self.framework,
lot=self.lot,
published_at=datetime(2016, 3, 3, 12, 30, 1, 2)))
db.session.commit()
assert Brief.query.filter(Brief.applications_closed_at == datetime(
2016, 3, 17, 23, 59, 59)).count() == 1
def create_brief(self, user, team, framework, lot, data=None):
if not data:
data = {}
brief = None
if team:
team_brief = TeamBrief(team_id=team.get('id'), user_id=user.id)
brief = Brief(team_briefs=[team_brief],
framework=framework,
lot=lot,
data=data)
else:
brief = Brief(users=[user],
framework=framework,
lot=lot,
data=data)
db.session.add(brief)
db.session.commit()
return brief
def test_applications_closed_at_is_set_with_published_at(self):
brief = Brief(data={},
framework=self.framework,
lot=self.lot,
published_at=datetime(2016, 3, 3, 12, 30, 1, 2))
assert brief.applications_closed_at == datetime(
2016, 3, 17, 23, 59, 59)
assert brief.clarification_questions_closed_at == datetime(
2016, 3, 10, 23, 59, 59)
assert brief.clarification_questions_published_by == datetime(
2016, 3, 16, 23, 59, 59)
