def notify_service(notify_db, notify_db_session):
user = create_user()
service = Service.query.get(current_app.config['NOTIFY_SERVICE_ID'])
if not service:
service = Service(
name='Notify Service',
message_limit=1000,
restricted=False,
email_from='notify.service',
created_by=user,
prefix_sms=False,
)
dao_create_service(service=service,
service_id=current_app.config['NOTIFY_SERVICE_ID'],
user=user)
data = {
'service': service,
'email_address': "*****@*****.**",
'is_default': True,
}
reply_to = ServiceEmailReplyTo(**data)
db.session.add(reply_to)
db.session.commit()
return service, user
def setup_service(db_session,
service_name="Sample service",
user=None,
restricted=False,
limit=1000,
email_from=None,
permissions=None,
research_mode=None):
if user is None:
user = create_user()
if email_from is None:
email_from = service_name.lower().replace(' ', '.')
data = {
'name': service_name,
'message_limit': limit,
'restricted': restricted,
'email_from': email_from,
'created_by': user,
'crown': True
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user, service_permissions=permissions)
if research_mode:
service.research_mode = research_mode
else:
if user not in service.users:
dao_add_user_to_service(service, user)
return service
def test_create_service(notify_db_session):
user = create_user()
create_letter_branding()
assert Service.query.count() == 0
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
organisation_type="central",
created_by=user,
)
dao_create_service(service, user)
assert Service.query.count() == 1
service_db = Service.query.one()
assert service_db.name == "service_name"
assert service_db.id == service.id
assert service_db.email_from == "email_from"
assert service_db.research_mode is False
assert service_db.prefix_sms is True
assert service.active is True
assert user in service_db.users
assert service_db.organisation_type == "central"
assert service_db.crown is None
assert not service.letter_branding
assert not service.organisation_id
def sample_broadcast_service(notify_db_session, broadcast_organisation):
user = create_user()
service_name = 'Sample broadcast service'
email_from = service_name.lower().replace(' ', '.')
data = {
'name': service_name,
'message_limit': 1000,
'restricted': False,
'email_from': email_from,
'created_by': user,
'crown': True,
'count_as_live': False,
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user, service_permissions=[BROADCAST_TYPE])
insert_or_update_service_broadcast_settings(service, channel="severe")
dao_add_service_to_organisation(service, current_app.config['BROADCAST_ORGANISATION_ID'])
else:
if user not in service.users:
dao_add_user_to_service(service, user)
return service
def test_create_nhs_service_get_default_branding_based_on_email_address(
notify_db_session,
branding_name_to_create,
expected_branding,
email_address,
organisation_type,
):
user = create_user(email=email_address)
letter_branding = create_letter_branding(name=branding_name_to_create)
email_branding = create_email_branding(name=branding_name_to_create)
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
organisation_type=organisation_type,
created_by=user,
)
dao_create_service(service, user)
service_db = Service.query.one()
if expected_branding:
assert service_db.letter_branding == letter_branding
assert service_db.email_branding == email_branding
else:
assert service_db.letter_branding is None
assert service_db.email_branding is None
def test_create_service_creates_a_history_record_with_current_data(
notify_db_session):
user = create_user()
create_letter_branding()
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user,
)
dao_create_service(service, user)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 1
service_from_db = Service.query.first()
service_history = Service.get_history_model().query.first()
assert service_from_db.id == service_history.id
assert service_from_db.name == service_history.name
assert service_from_db.version == 1
assert service_from_db.version == service_history.version
assert user.id == service_history.created_by_id
assert service_from_db.created_by.id == service_history.created_by_id
def sample_service(notify_db,
notify_db_session,
service_name="Sample service",
user=None,
active=True,
restricted=False,
limit=1000,
email_from=None):
if user is None:
user = sample_user(notify_db, notify_db_session)
if email_from is None:
email_from = service_name.lower().replace(' ', '.')
data = {
'name': service_name,
'message_limit': limit,
'active': active,
'restricted': restricted,
'email_from': email_from,
'created_by': user
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user)
else:
if user not in service.users:
dao_add_user_to_service(service, user)
return service
def test_dao_fetch_service_creator(notify_db_session):
active_user_1 = create_user(email="*****@*****.**", state="active")
active_user_2 = create_user(email="*****@*****.**", state="active")
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=active_user_1,
)
dao_create_service(
service,
active_user_1,
service_permissions=[
SMS_TYPE,
EMAIL_TYPE,
INTERNATIONAL_SMS_TYPE,
],
)
service.created_by_id = active_user_2.id
service.name = "New Name"
dao_update_service(service)
assert Service.query.count() == 1
history_model = Service.get_history_model()
entries = history_model.query.all()
assert len(entries) == 2
assert entries[1].created_by_id == active_user_2.id
assert active_user_1 == dao_fetch_service_creator(service.id)
def test_update_service_creates_a_history_record_with_current_data(notify_db_session):
user = create_user()
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
dao_create_service(service, user)
assert Service.query.count() == 1
assert Service.query.first().version == 1
assert Service.get_history_model().query.count() == 1
service.name = 'updated_service_name'
dao_update_service(service)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 2
service_from_db = Service.query.first()
assert service_from_db.version == 2
assert Service.get_history_model().query.filter_by(name='service_name').one().version == 1
assert Service.get_history_model().query.filter_by(name='updated_service_name').one().version == 2
def test_create_service_with_organisation(notify_db_session):
user = create_user(email='*****@*****.**')
organisation = create_organisation(
name='Some local authority', organisation_type='local', domains=['local-authority.gov.uk'])
assert Service.query.count() == 0
service = Service(name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
organisation_type='central',
created_by=user)
dao_create_service(service, user)
assert Service.query.count() == 1
service_db = Service.query.one()
organisation = Organisation.query.get(organisation.id)
assert service_db.name == "service_name"
assert service_db.id == service.id
assert service_db.email_from == 'email_from'
assert service_db.research_mode is False
assert service_db.prefix_sms is True
assert service.active is True
assert user in service_db.users
assert service_db.organisation_type == 'local'
assert service_db.crown is None
assert not service.letter_branding
assert service.organisation_id == organisation.id
assert service.organisation == organisation
def create_service(
user=None,
service_name="Sample service",
service_id=None,
restricted=False,
service_permissions=[EMAIL_TYPE, SMS_TYPE],
research_mode=False,
active=True,
email_from=None,
prefix_sms=True,
message_limit=1000,
organisation_type='central'
):
service = Service(
name=service_name,
message_limit=message_limit,
restricted=restricted,
email_from=email_from if email_from else service_name.lower().replace(' ', '.'),
created_by=user or create_user(email='{}@digital.cabinet-office.gov.uk'.format(uuid.uuid4())),
prefix_sms=prefix_sms,
organisation_type=organisation_type
)
dao_create_service(service, service.created_by, service_id, service_permissions=service_permissions)
service.active = active
service.research_mode = research_mode
return service
def create_service():
data = request.get_json()
if not data.get("user_id"):
errors = {"user_id": ["Missing data for required field."]}
raise InvalidRequest(errors, status_code=400)
data.pop("service_domain", None)
# validate json with marshmallow
service_schema.load(data)
user = get_user_by_id(data.pop("user_id"))
# unpack valid json into service object
valid_service = Service.from_json(data)
dao_create_service(valid_service, user)
try:
# try-catch; just in case, we don't want to error here
ZenDeskSell().send_create_service(valid_service, user)
except Exception as e:
current_app.logger.exception(e)
return jsonify(data=service_schema.dump(valid_service).data), 201
def test_cannot_create_service_with_no_user(notify_db_session, sample_user):
assert Service.query.count() == 0
service = Service(
name="service_name", email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user
)
with pytest.raises(FlushError) as excinfo:
dao_create_service(service, None)
assert "Can't flush None value found in collection Service.users" in str(excinfo.value)
def create_service(
user=None,
service_name="Sample service",
service_id=None,
restricted=False,
count_as_live=True,
service_permissions=None,
research_mode=False,
active=True,
email_from=None,
prefix_sms=True,
message_limit=1000,
organisation_type='central',
check_if_service_exists=False,
go_live_user=None,
go_live_at=None,
crown=True,
organisation=None,
purchase_order_number=None,
billing_contact_names=None,
billing_contact_email_addresses=None,
billing_reference=None,
):
if check_if_service_exists:
service = Service.query.filter_by(name=service_name).first()
if (not check_if_service_exists) or (check_if_service_exists and not service):
service = Service(
name=service_name,
message_limit=message_limit,
restricted=restricted,
email_from=email_from if email_from else service_name.lower().replace(' ', '.'),
created_by=user if user else create_user(email='{}@digital.cabinet-office.gov.uk'.format(uuid.uuid4())),
prefix_sms=prefix_sms,
organisation_type=organisation_type,
organisation=organisation,
go_live_user=go_live_user,
go_live_at=go_live_at,
crown=crown,
purchase_order_number=purchase_order_number,
billing_contact_names=billing_contact_names,
billing_contact_email_addresses=billing_contact_email_addresses,
billing_reference=billing_reference,
)
dao_create_service(
service,
service.created_by,
service_id,
service_permissions=service_permissions,
)
service.active = active
service.research_mode = research_mode
service.count_as_live = count_as_live
else:
if user and user not in service.users:
dao_add_user_to_service(service, user)
return service
def test_add_existing_user_to_another_service_doesnot_change_old_permissions(
notify_db_session, ):
user = create_user()
service_one = Service(
name="service_one",
email_from="service_one",
message_limit=1000,
restricted=False,
created_by=user,
)
dao_create_service(service_one, user)
assert user.id == service_one.users[0].id
test_user_permissions = Permission.query.filter_by(service=service_one,
user=user).all()
assert len(test_user_permissions) == 8
other_user = User(
name="Other Test User",
email_address="*****@*****.**",
password="******",
mobile_number="+447700900987",
)
save_model_user(other_user)
service_two = Service(
name="service_two",
email_from="service_two",
message_limit=1000,
restricted=False,
created_by=other_user,
)
dao_create_service(service_two, other_user)
assert other_user.id == service_two.users[0].id
other_user_permissions = Permission.query.filter_by(service=service_two,
user=other_user).all()
assert len(other_user_permissions) == 8
other_user_service_one_permissions = Permission.query.filter_by(
service=service_one, user=other_user).all()
assert len(other_user_service_one_permissions) == 0
# adding the other_user to service_one should leave all other_user permissions on service_two intact
permissions = []
for p in ["send_emails", "send_texts", "send_letters"]:
permissions.append(Permission(permission=p))
dao_add_user_to_service(service_one, other_user, permissions=permissions)
other_user_service_one_permissions = Permission.query.filter_by(
service=service_one, user=other_user).all()
assert len(other_user_service_one_permissions) == 3
other_user_service_two_permissions = Permission.query.filter_by(
service=service_two, user=other_user).all()
assert len(other_user_service_two_permissions) == 8
def test_cannot_create_service_with_no_user(notify_db_session):
user = create_user()
assert Service.query.count() == 0
service = Service(name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
with pytest.raises(ValueError) as excinfo:
dao_create_service(service, None)
assert "Can't create a service without a user" in str(excinfo.value)
def test_create_service_and_history_is_transactional(sample_user):
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(name=None, email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user)
with pytest.raises(IntegrityError) as excinfo:
dao_create_service(service, sample_user)
assert 'column "name" violates not-null constraint' in str(excinfo.value)
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
def test_cannot_create_two_services_with_same_email_from(sample_user):
assert Service.query.count() == 0
service1 = Service(
name="service_name1", email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user
)
service2 = Service(
name="service_name2", email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user
)
with pytest.raises(IntegrityError) as excinfo:
dao_create_service(service1, sample_user)
dao_create_service(service2, sample_user)
assert 'duplicate key value violates unique constraint "services_email_from_key"' in str(excinfo.value)
def test_fetch_stats_filters_on_service(sample_notification):
service_two = Service(
name="service_two",
created_by=sample_notification.service.created_by,
email_from="hello",
restricted=False,
message_limit=1000,
)
dao_create_service(service_two, sample_notification.service.created_by)
stats = dao_fetch_stats_for_service(service_two.id)
assert len(stats) == 0
def test_update_service_permission_creates_a_history_record_with_current_data(
notify_db_session, ):
user = create_user()
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user,
)
dao_create_service(
service,
user,
service_permissions=[
SMS_TYPE,
EMAIL_TYPE,
INTERNATIONAL_SMS_TYPE,
],
)
service.permissions.append(
ServicePermission(service_id=service.id, permission="letter"))
dao_update_service(service)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 2
service_from_db = Service.query.first()
assert service_from_db.version == 2
_assert_service_permissions(
service.permissions,
(SMS_TYPE, EMAIL_TYPE, INTERNATIONAL_SMS_TYPE, LETTER_TYPE))
permission = [p for p in service.permissions if p.permission == "sms"][0]
service.permissions.remove(permission)
dao_update_service(service)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 3
service_from_db = Service.query.first()
assert service_from_db.version == 3
_assert_service_permissions(
service.permissions, (EMAIL_TYPE, INTERNATIONAL_SMS_TYPE, LETTER_TYPE))
assert len(Service.get_history_model().query.filter_by(
name="service_name").all()) == 3
assert Service.get_history_model().query.filter_by(
name="service_name").all()[2].version == 3
def create_service(
user=None,
service_name="Sample service",
service_id=None,
restricted=False,
count_as_live=True,
service_permissions=[EMAIL_TYPE, SMS_TYPE],
research_mode=False,
active=True,
email_from=None,
prefix_sms=True,
message_limit=1000,
organisation_type="central",
check_if_service_exists=False,
go_live_user=None,
go_live_at=None,
crown=True,
organisation=None,
):
if check_if_service_exists:
service = Service.query.filter_by(name=service_name).first()
if (not check_if_service_exists) or (check_if_service_exists
and not service):
service = Service(
name=service_name,
message_limit=message_limit,
restricted=restricted,
email_from=email_from
if email_from else service_name.lower().replace(" ", "."),
created_by=user if user else create_user(
email="{}@digital.cabinet-office.gov.uk".format(uuid.uuid4())),
prefix_sms=prefix_sms,
organisation_type=organisation_type,
go_live_user=go_live_user,
go_live_at=go_live_at,
crown=crown,
)
dao_create_service(
service,
service.created_by,
service_id,
service_permissions=service_permissions,
)
service.active = active
service.research_mode = research_mode
service.count_as_live = count_as_live
else:
if user and user not in service.users:
dao_add_user_to_service(service, user)
return service
def test_fetch_stats_filters_on_service(notify_db_session):
service_one = create_service()
create_notification(template=create_template(service=service_one))
service_two = Service(name="service_two",
created_by=service_one.created_by,
email_from="hello",
restricted=False,
message_limit=1000)
dao_create_service(service_two, service_one.created_by)
stats = dao_fetch_stats_for_service(service_two.id, 7)
assert len(stats) == 0
def test_should_remove_provider_from_service(notify_db_session, ses_provider):
user = create_user()
service = Service(name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user,
email_provider_id=ses_provider.id)
dao_create_service(service, user)
stored_service = dao_fetch_service_by_id(service.id)
stored_service.email_provider_id = None
dao_update_service(service)
updated_service = dao_fetch_service_by_id(service.id)
assert not updated_service.email_provider_id
def test_create_service(sample_user):
assert Service.query.count() == 0
service = Service(
name="service_name", email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user
)
dao_create_service(service, sample_user)
assert Service.query.count() == 1
service_db = Service.query.first()
assert service_db.name == "service_name"
assert service_db.id == service.id
assert service_db.branding == BRANDING_GOVUK
assert service_db.research_mode is False
assert service.active is True
assert sample_user in service_db.users
def test_should_add_user_to_service(sample_user):
service = Service(
name="service_name", email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user
)
dao_create_service(service, sample_user)
assert sample_user in Service.query.first().users
new_user = User(
name="Test User",
email_address="*****@*****.**",
password="******",
mobile_number="+447700900986",
)
save_model_user(new_user)
dao_add_user_to_service(service, new_user)
assert new_user in Service.query.first().users
def test_cannot_create_service_with_non_existent_sms_provider(
notify_db_session):
user = create_user()
dummy_sms_provider_details_id = uuid.uuid4()
service = Service(name="service_name",
email_from="email_from1",
message_limit=1000,
restricted=False,
created_by=user,
sms_provider_id=dummy_sms_provider_details_id)
with pytest.raises(IntegrityError) as excinfo:
dao_create_service(service, user)
assert 'services_sms_provider_id_fkey' in str(excinfo.value)
def test_create_service_and_history_is_transactional(notify_db_session):
user = create_user()
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(name=None,
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
with pytest.raises(IntegrityError) as excinfo:
dao_create_service(service, user)
assert 'column "name" violates not-null constraint' in str(excinfo.value)
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
def test_should_add_user_to_service(notify_db_session):
user = create_user()
service = Service(name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
dao_create_service(service, user)
assert user in Service.query.first().users
new_user = User(name='Test User',
email_address='*****@*****.**',
password='******',
mobile_number='+16502532222')
save_model_user(new_user)
dao_add_user_to_service(service, new_user)
assert new_user in Service.query.first().users
def test_cannot_create_two_services_with_same_email_from(notify_db_session):
user = create_user()
assert Service.query.count() == 0
service1 = Service(name="service_name1",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
service2 = Service(name="service_name2",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
with pytest.raises(IntegrityError) as excinfo:
dao_create_service(service1, user)
dao_create_service(service2, user)
assert 'duplicate key value violates unique constraint "services_email_from_key"' in str(excinfo.value)
def test_can_create_service_with_valid_sms_provider(notify_db_session,
firetext_provider):
user = create_user()
service = Service(name="service_with_sms_provider_name",
message_limit=1000,
restricted=False,
created_by=user,
sms_provider_id=firetext_provider.id)
try:
dao_create_service(service, user)
except IntegrityError:
pytest.fail("Could not create service with with valid sms provider")
stored_service = dao_fetch_service_by_id(service.id)
assert stored_service is not None
assert stored_service.sms_provider_id == firetext_provider.id
def create_service():
data = request.get_json()
if not data.get('user_id'):
errors = {'user_id': ['Missing data for required field.']}
raise InvalidRequest(errors, status_code=400)
# validate json with marshmallow
service_schema.load(data)
user = get_user_by_id(data.pop('user_id'))
# unpack valid json into service object
valid_service = Service.from_json(data)
dao_create_service(valid_service, user)
return jsonify(data=service_schema.dump(valid_service).data), 201
def test_can_create_two_services_with_same_email_from(notify_db_session):
user = create_user()
assert Service.query.count() == 0
service1 = Service(name="service_name1",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
service2 = Service(name="service_name2",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user)
try:
dao_create_service(service1, user)
dao_create_service(service2, user)
except IntegrityError:
pytest.fail("Could not create two services with same email from")
def test_add_existing_user_to_another_service_doesnot_change_old_permissions(sample_user):
service_one = Service(
name="service_one", email_from="service_one", message_limit=1000, restricted=False, created_by=sample_user
)
dao_create_service(service_one, sample_user)
assert sample_user.id == service_one.users[0].id
test_user_permissions = Permission.query.filter_by(service=service_one, user=sample_user).all()
assert len(test_user_permissions) == 8
other_user = User(
name="Other Test User",
email_address="*****@*****.**",
password="******",
mobile_number="+447700900987",
)
save_model_user(other_user)
service_two = Service(
name="service_two", email_from="service_two", message_limit=1000, restricted=False, created_by=other_user
)
dao_create_service(service_two, other_user)
assert other_user.id == service_two.users[0].id
other_user_permissions = Permission.query.filter_by(service=service_two, user=other_user).all()
assert len(other_user_permissions) == 8
other_user_service_one_permissions = Permission.query.filter_by(service=service_one, user=other_user).all()
assert len(other_user_service_one_permissions) == 0
# adding the other_user to service_one should leave all other_user permissions on service_two intact
permissions = []
for p in ["send_emails", "send_texts", "send_letters"]:
permissions.append(Permission(permission=p))
dao_add_user_to_service(service_one, other_user, permissions=permissions)
other_user_service_one_permissions = Permission.query.filter_by(service=service_one, user=other_user).all()
assert len(other_user_service_one_permissions) == 3
other_user_service_two_permissions = Permission.query.filter_by(service=service_two, user=other_user).all()
assert len(other_user_service_two_permissions) == 8
def sample_service(notify_db,
notify_db_session,
service_name="Sample service",
user=None,
restricted=False,
limit=1000,
email_from=None,
permissions=None,
research_mode=None):
if user is None:
user = create_user()
if email_from is None:
email_from = service_name.lower().replace(' ', '.')
data = {
'name': service_name,
'message_limit': limit,
'restricted': restricted,
'email_from': email_from,
'created_by': user,
'crown': True
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user, service_permissions=permissions)
if research_mode:
service.research_mode = research_mode
else:
if user not in service.users:
dao_add_user_to_service(service, user)
if permissions and INBOUND_SMS_TYPE in permissions:
create_inbound_number('12345', service_id=service.id)
if permissions and INBOUND_SMS_KEYWORD_TYPE in permissions:
create_inbound_shortnumber('12345', service_id=service.id)
return service
def test_should_remove_user_from_service(notify_db_session):
user = create_user()
service = Service(
name="service_name",
email_from="email_from",
message_limit=1000,
restricted=False,
created_by=user,
)
dao_create_service(service, user)
new_user = User(
name="Test User",
email_address="*****@*****.**",
password="******",
mobile_number="+16502532222",
)
save_model_user(new_user)
dao_add_user_to_service(service, new_user)
assert new_user in Service.query.first().users
dao_remove_user_from_service(service, new_user)
assert new_user not in Service.query.first().users
def create_service():
data = request.get_json()
if not data.get('user_id'):
errors = {'user_id': ['Missing data for required field.']}
raise InvalidRequest(errors, status_code=400)
data.pop('service_domain', None)
# validate json with marshmallow
service_schema.load(data)
user = get_user_by_id(data.pop('user_id'))
# unpack valid json into service object
valid_service = Service.from_json(data)
with transaction():
dao_create_service(valid_service, user)
set_default_free_allowance_for_service(service=valid_service, year_start=None)
return jsonify(data=service_schema.dump(valid_service).data), 201
def test_create_service_creates_a_history_record_with_current_data(sample_user):
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(
name="service_name", email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user
)
dao_create_service(service, sample_user)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 1
service_from_db = Service.query.first()
service_history = Service.get_history_model().query.first()
assert service_from_db.id == service_history.id
assert service_from_db.name == service_history.name
assert service_from_db.version == 1
assert service_from_db.version == service_history.version
assert sample_user.id == service_history.created_by_id
assert service_from_db.created_by.id == service_history.created_by_id
assert service_from_db.branding == BRANDING_GOVUK
assert service_history.branding == BRANDING_GOVUK
def sample_service(
notify_db,
notify_db_session,
service_name="Sample service",
user=None,
restricted=False,
limit=1000,
email_from=None,
permissions=None,
research_mode=None,
):
if user is None:
user = create_user()
if email_from is None:
email_from = service_name.lower().replace(" ", ".")
data = {
"name": service_name,
"message_limit": limit,
"restricted": restricted,
"email_from": email_from,
"created_by": user,
"crown": True,
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user, service_permissions=permissions)
if research_mode:
service.research_mode = research_mode
else:
if user not in service.users:
dao_add_user_to_service(service, user)
if permissions and INBOUND_SMS_TYPE in permissions:
create_inbound_number("12345", service_id=service.id)
return service
def sample_broadcast_service(notify_db_session):
user = create_user()
service_name = 'Sample broadcast service'
email_from = service_name.lower().replace(' ', '.')
data = {
'name': service_name,
'message_limit': 1000,
'restricted': False,
'email_from': email_from,
'created_by': user,
'crown': True
}
service = Service.query.filter_by(name=service_name).first()
if not service:
service = Service(**data)
dao_create_service(service, user, service_permissions=[BROADCAST_TYPE])
else:
if user not in service.users:
dao_add_user_to_service(service, user)
return service
def test_update_service_creates_a_history_record_with_current_data(sample_user):
assert Service.query.count() == 0
assert Service.get_history_model().query.count() == 0
service = Service(
name="service_name", email_from="email_from", message_limit=1000, restricted=False, created_by=sample_user
)
dao_create_service(service, sample_user)
assert Service.query.count() == 1
assert Service.query.first().version == 1
assert Service.get_history_model().query.count() == 1
service.name = "updated_service_name"
dao_update_service(service)
assert Service.query.count() == 1
assert Service.get_history_model().query.count() == 2
service_from_db = Service.query.first()
assert service_from_db.version == 2
assert Service.get_history_model().query.filter_by(name="service_name").one().version == 1
assert Service.get_history_model().query.filter_by(name="updated_service_name").one().version == 2
