def test_data():
mixer.cycle(30).blend(User, password='******')
mixer.cycle(50).blend(ReviewGroup)
mixer.cycle(100).blend(Proposal, review_group=mixer.SELECT)
mixer.cycle(200).blend(ReviewVote,
review_group=mixer.SELECT,
user=mixer.SELECT)
mixer.cycle(30).blend(Vote, user=mixer.SELECT, proposal=mixer.SELECT)
def test_converse_responds_with_two_quotes_per_person(client, session, mock_bot):
mock_person1 = mixer.blend(Person, first_name="Beth")
mock_person2 = mixer.blend(Person, first_name="Valisy")
mock_quotes1 = mixer.cycle().blend(Quote, person=mock_person1)
mock_quotes2 = mixer.cycle().blend(Quote, person=mock_person2)
session.bulk_save_objects([mock_person1, mock_person2, *mock_quotes1, *mock_quotes2])
session.commit()
result = mock_bot.converse([mock_person1.slack_user_id, mock_person2.slack_user_id])
message = result.message
assert message.count("Beth:") == 2
assert message.count("Valisy:") == 2
def test_get_all_quotes_from_person(num_quotes, client, session):
person = mixer.blend(Person)
expected_quotes = mixer.cycle(num_quotes).blend(Quote, person=person)
actual_quotes = get_all_quotes_from_person(person.slack_user_id)
assert actual_quotes == expected_quotes
def blend_geokret(self, *args, **kwargs):
with mixer.ctx():
if 'created_on_datetime' not in kwargs:
kwargs['created_on_datetime'] = "2019-01-12T16:33:46"
if kwargs.get('count'):
return mixer.cycle(kwargs.get('count')).blend(Geokret, **kwargs)
return mixer.blend(Geokret, **kwargs)
def setUp(self):
app.config['TESTING'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + \
os.path.join(basedir, 'test.db')
self.__app__ = app.test_client()
db.create_all()
titles = ['Title1', 'Title2', 'Title3']
authors = ['Author1', 'Author2', 'Author3']
user_emails = ['*****@*****.**', '*****@*****.**', '*****@*****.**']
mixer.init_app(app)
users = mixer.cycle(2).blend(User, email=(email for email in user_emails))
books = mixer.cycle(2).blend(Book, title=(title for title in titles),
author=(author for author in authors))
user_book = mixer.cycle(2).blend(UserBooks,
user_id=(user.id for user in users),
book_id=(book.id for book in books))
def test_get_random_quotes_from_person_defaults_to_one(client, session):
person = mixer.blend(Person)
expected_quotes = mixer.cycle().blend(Quote, person=person)
random_quotes = get_random_quotes_from_person(person.slack_user_id)
assert set(random_quotes).issubset(expected_quotes)
assert len(random_quotes) == 1
def generate_data(self, cls, number, **kwargs):
"""
Generate random data for a given data model.
"""
mixer.init_app(self.flask_app)
return mixer.cycle(number).blend(
cls,
id=fields.gen_uuid,
**kwargs
)
def blend_move_comment(self, *args, **kwargs):
with mixer.ctx():
if kwargs.get('count'):
move_comments = mixer.cycle(kwargs.get('count')).blend(MoveComment, **kwargs)
for move_comment in move_comments:
update_geokret_and_moves(db.session, move_comment.move.geokret_id, move_comment.move.id)
return move_comments
move_comment = mixer.blend(MoveComment, **kwargs)
update_geokret_and_moves(db.session, move_comment.move.geokret_id, move_comment.move.id)
return move_comment
def test_converse_notifies_users_if_person_does_not_exist(client, session, mock_bot):
mock_person = mixer.blend(Person, first_name="Beth")
mock_quotes = mixer.cycle().blend(Quote, person=mock_person)
non_existent_id1 = "foo"
non_existent_id2 = "bar"
session.bulk_save_objects([mock_person, *mock_quotes])
session.commit()
result = mock_bot.converse([mock_person.slack_user_id, non_existent_id1, non_existent_id2])
message = result.message
assert message == f"I don't recognize {non_existent_id1}, {non_existent_id2}"
def test_random_responds_with_random_quote(client, session, mock_bot):
mock_person = mixer.blend(Person)
mock_quotes = mixer.cycle().blend(Quote, person=mock_person)
quote_contents = [quote.content for quote in mock_quotes]
session.bulk_save_objects([mock_person, *mock_quotes])
session.commit()
result = mock_bot.random()
result_quote, result_user = result.message.replace('"', "").split(" - ")
assert result_quote in quote_contents
assert result_user == mock_person.first_name
def test_converse_repeats_quote_if_person_has_fewer_than_two_quotes(client, session, mock_bot):
mock_person1 = mixer.blend(Person, first_name="Beth")
mock_person2 = mixer.blend(Person, first_name="Vasily")
mock_quotes1 = mixer.cycle().blend(Quote, person=mock_person1)
mock_quotes2 = [Quote(content="I only have one quote", person_id=mock_person2.id)]
session.bulk_save_objects([mock_person1, mock_person2, *mock_quotes1, *mock_quotes2])
session.commit()
result = mock_bot.converse([mock_person1.slack_user_id, mock_person2.slack_user_id])
message = result.message
assert message.count("Beth:") == 2
assert message.count("Vasily:") == 2
def generate_data(people: int, quotes: int):
"""
Create people amount of Person objects in the database each
with quotes amount of Quotes.
"""
current_app.logger.info(
f"Generating {people} People objects with {quotes} Quotes each..."
)
# May need to modify this when this command is unit tested
mixer.init_app(current_app)
people = mixer.cycle(people).blend(Person,
slack_user_id=mixer.faker.isbn10,
last_name=mixer.faker.last_name)
quotes = mixer.cycle(quotes).blend(Quote,
person=mixer.SELECT)
current_app.logger.info("Generated the following people:")
for person in people:
current_app.logger.info(
f"{person.slack_user_id} - {person.first_name} {person.last_name}"
)
def test_get_all_quotes_from_person(num_quotes, client, session,
prepared_user):
quotes = mixer.cycle(num_quotes).blend(Quote, person=prepared_user)
expected_data = [get_serialized_quote(quote) for quote in quotes]
response = client.get(
url_for(
"api.personquotelistresource",
slack_user_id=prepared_user.slack_user_id,
))
response_json = response.json
assert response.status_code == 200
assert len(response_json) == num_quotes
assert response_json == expected_data
def test_remind_pings_multiple_targes(client, session, mock_bot):
mock_nostalgia_person = mixer.blend(Person)
mock_target_persons = mixer.cycle(3).blend(Person)
mock_quote = mixer.blend(Quote, person=mock_nostalgia_person)
target_user_ids = [target.slack_user_id for target in mock_target_persons]
expected_message = (
f"{' '.join(f'<@{user_id}>' for user_id in target_user_ids)} Do you remember this?"
f'\n\n"{mock_quote.content}" - {mock_nostalgia_person.first_name}'
)
session.bulk_save_objects([mock_nostalgia_person, *mock_target_persons, mock_quote])
session.commit()
result = mock_bot.remind(mock_nostalgia_person.slack_user_id, target_user_ids)
assert expected_message == result.message
def test_get_random_person(client, session):
people = mixer.cycle().blend(Person)
slack_user_ids = [person.slack_user_id for person in people]
different_user_returned = False
random_person = get_random_person()
assert random_person in slack_user_ids
# Note because this part of the test tests randomness it could be flaky,
# but the probability of returning the same user 6 times is quite low.
for _ in range(5):
new_random_person = get_random_person()
if new_random_person != random_person:
different_user_returned = True
break
assert different_user_returned
def create_persons(self, number=3):
persons = mixer.cycle(number).blend(Person)
map(db.session.add, persons)
db.session.flush()
return persons
def blend_news_comment(self, *args, **kwargs):
with mixer.ctx():
if kwargs.get('count'):
return mixer.cycle(kwargs.get('count')).blend(NewsComment, **kwargs)
return mixer.blend(NewsComment, **kwargs)
def fake_data():
mixer.init_app(app)
mixer.cycle(50).blend(User, password=hashing.hash_value("123456"))
mixer.cycle(10).blend(Cinema, info=mixer.sequence("info_{0}"))
mixer.cycle(10).blend(Movie, length=(a for a in range(95, 126)))
def resetdb():
"Create a test database"
names = ['Jim', 'Bob', 'Sarah', 'Sue']
wards = ['Easton', 'AWL', 'BCR', 'WOT']
lead_statuses = ['Successful', 'Possible', 'Dead']
db.drop_all()
db.create_all()
admin_role = Role(name='admin')
db.session.add(admin_role)
db.session.add(Role(name='manager'))
db.session.add(Role(name='surveyor'))
admin_user = User(email='*****@*****.**',
active=True,
password=user_manager.hash_password('admin'))
admin_user.roles.append(admin_role)
db.session.add(admin_user)
for x in lead_statuses:
lead_status = SurveyLeadStatuses()
lead_status.name = x
db.session.add(lead_status)
db.session.commit()
# Generate some random entries.
def get_random_name():
return random.choice(names)
def get_random_ward():
return random.choice(wards)
def get_random_box_number():
return random.randrange(100)
def get_random_date():
start = PHASE_START_DATES[0]
end = PHASE_START_DATES[-1]
delta = end - start
return start + datetime.timedelta(random.randrange(delta.days))
def get_random_phase():
return random.randint(1, NUM_PHASES)
mixer.cycle(10).blend(User)
mixer.cycle(50).blend(Surveys,
name=mixer.RANDOM,
ward=mixer.RANDOM,
free_survey_consideration=mixer.RANDOM,
lead_status=mixer.SELECT,
survey_request_date=get_random_date,
phase=get_random_phase,
survey_date=get_random_date,
address_line=mixer.RANDOM,
availability=mixer.RANDOM,
expected_benefit=mixer.RANDOM,
box_collected=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(50).blend(Results,
survey=mixer.SELECT,
survey_date=get_random_date,
lead_surveyor=get_random_name,
assistant_surveyor=get_random_name,
cheese_box_number=get_random_box_number,
faults_identified=mixer.RANDOM,
recommendations=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(50).blend(MonthFeedback,
survey=mixer.SELECT,
completed_actions=mixer.RANDOM,
planned_actions=mixer.RANDOM,
cheese_box=mixer.RANDOM,
feedback=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(20).blend(YearFeedback,
householders_name=mixer.RANDOM,
survey=mixer.SELECT,
diy_work=mixer.RANDOM,
prof_work=mixer.RANDOM,
contractors_used=mixer.RANDOM,
planned_work=mixer.RANDOM,
wellbeing_improvement=mixer.RANDOM,
behaviour_changes=mixer.RANDOM,
feedback=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(10).blend(Wards)
mixer.cycle(10).blend(BuildingTypes)
mixer.cycle(10).blend(WallConstructionTypes)
mixer.cycle(10).blend(OccupationTypes)
mixer.cycle(10).blend(SpaceHeatingTypes)
mixer.cycle(10).blend(WaterHeatingTypes)
mixer.cycle(10).blend(CookingTypes)
# Remove duplicate references (where there should only be one).
for s in Surveys.query.all():
if len(s.result) > 1:
for x in s.result[1:]:
db.session.delete(x)
if len(s.month_feedback) > 1:
for x in s.month_feedback[1:]:
db.session.delete(x)
if len(s.year_feedback) > 1:
for x in s.year_feedback[1:]:
db.session.delete(x)
db.session.commit()
def blend_badge(self, *args, **kwargs):
with mixer.ctx():
if kwargs.get('count'):
return mixer.cycle(kwargs.get('count')).blend(Badge, **kwargs)
return mixer.blend(Badge, **kwargs)
def blend_news_subscription(self, *args, **kwargs):
with mixer.ctx():
if kwargs.get('count'):
return mixer.cycle(kwargs.get('count')).blend(NewsSubscription, **kwargs)
return mixer.blend(NewsSubscription, **kwargs)
from mixer.main import TypeMixer
@mixer.middleware(models.Task)
def encrypt_password(task):
task.due_date = datetime.datetime.utcnow() + datetime.timedelta(days=randint(5, 10))
return task
with app.app_context():
db.drop_all()
db.create_all()
mixer.init_app(app)
mixer.register(models.Task, description=lambda: 'LALAAL')
for task in mixer.cycle(10).blend(models.Task,
name=mixer.faker.name,
description=mixer.FAKE):
print(task.due_date)
db.session.flush()
for item in mixer.cycle(100).blend(models.Item,
name=mixer.faker.name,
description=mixer.faker.text,
task=mixer.SELECT):
item.handled = True if randint(0, 1) == 1 else False
item.due_date = datetime.datetime.utcnow() + datetime.timedelta(days=randint(0, 5) + (365 * 30))
if item.handled is True:
item.handled_date = datetime.datetime.utcnow() - datetime.timedelta(days=randint(0, 3))
db.session.add(item)
def test_data():
mixer.cycle(30).blend(User, password='******')
mixer.cycle(50).blend(ReviewGroup)
mixer.cycle(100).blend(Proposal, review_group=mixer.SELECT)
mixer.cycle(200).blend(ReviewVote, review_group=mixer.SELECT, user=mixer.SELECT)
mixer.cycle(30).blend(Vote, user=mixer.SELECT, proposal=mixer.SELECT)
def test_get_all_people_returns_all_people(client, session, num_people):
mixer.cycle(num_people).blend(Person)
assert len(get_all_people()) == num_people
def create_fixtures(cls):
# Create some random links
link_fixtures = mixer.cycle(5).blend(Link, geom='SRID=4326; LINESTRING EMPTY')
db.session.add_all(link_fixtures)
def resetdb():
"Create a test database"
names = ['Sue', 'Dave', 'Mike', 'Brian', 'Roz', 'Jeremy', 'Jamie', 'Maddy']
wards = ['Easton', 'Lawrence Hill', 'Clifton', 'Kingsdown']
lead_statuses = ['Successful', 'Possible', 'Dead']
building_types = ['Flat', 'Terrace', 'Detached', 'Unknown']
wall_construction_types = ['Brick', 'Stone', 'Timber', 'Unknown']
occupation_types = ['Rented', 'Owner', 'Unknown']
space_heating_types = [
'Central heating', 'Gas fire', 'Electric heaters', 'Unknown'
]
water_heating_types = ['Electricity', 'Gas', 'Solar', 'Unknown']
cooking_types = ['Electricity', 'Gas', 'Other', 'Unknown']
db.drop_all()
db.create_all()
admin_role = Role(name='admin')
db.session.add(admin_role)
db.session.add(Role(name='manager'))
db.session.add(Role(name='surveyor'))
admin_user = User(email='*****@*****.**',
active=True,
password=user_manager.hash_password('admin'))
admin_user.roles.append(admin_role)
db.session.add(admin_user)
# Create enum tables.
create_enum_values(db, Wards, wards)
create_enum_values(db, SurveyLeadStatuses, lead_statuses)
create_enum_values(db, BuildingTypes, building_types)
create_enum_values(db, WallConstructionTypes, wall_construction_types)
create_enum_values(db, OccupationTypes, occupation_types)
create_enum_values(db, SpaceHeatingTypes, space_heating_types)
create_enum_values(db, WaterHeatingTypes, water_heating_types)
create_enum_values(db, CookingTypes, cooking_types)
db.session.commit()
# Generate some random entries.
def get_random_name():
return random.choice(names)
def get_random_ward():
return random.choice(wards)
def get_random_box_number():
return random.randrange(100)
def get_random_date():
start = PHASE_START_DATES[0]
end = PHASE_START_DATES[-1]
delta = end - start
return start + datetime.timedelta(random.randrange(delta.days))
def get_random_phase():
return random.randint(1, NUM_PHASES)
mixer.cycle(10).blend(User)
mixer.cycle(50).blend(Surveys,
name=mixer.RANDOM,
ward=mixer.RANDOM,
free_survey_consideration=mixer.RANDOM,
lead_status=mixer.SELECT,
survey_request_date=get_random_date,
phase=get_random_phase,
survey_date=get_random_date,
address_line=mixer.RANDOM,
availability=mixer.RANDOM,
expected_benefit=mixer.RANDOM,
box_collected=mixer.RANDOM,
notes=mixer.RANDOM)
# This table is now deprecated for phase 5 and onwards.
mixer.cycle(50).blend(Results,
survey=mixer.SELECT,
survey_date=get_random_date,
lead_surveyor=get_random_name,
assistant_surveyor=get_random_name,
cheese_box_number=get_random_box_number,
faults_identified=mixer.RANDOM,
recommendations=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(50).blend(PreSurveyDetails,
survey=mixer.SELECT,
householder_name=get_random_name,
postcode=mixer.RANDOM,
building_type=mixer.SELECT,
year_of_construction=mixer.RANDOM,
wall_construction_type=mixer.SELECT,
occupation_type=mixer.SELECT,
primary_heating_type=mixer.SELECT,
secondary_heating_type=mixer.SELECT,
water_heating_type=mixer.SELECT,
cooking_type=mixer.SELECT,
depth_loft_insulation=mixer.RANDOM,
number_open_fireplaces=mixer.RANDOM,
double_glazing=mixer.RANDOM,
has_asbestos=mixer.RANDOM,
asbestos_details=mixer.RANDOM,
num_occupants=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(50).blend(PostSurveyDetails,
survey=mixer.SELECT,
lead_surveyor=get_random_name,
assistant_surveyor=get_random_name,
survey_date=get_random_date,
camera_kit_number=mixer.RANDOM,
external_temperature=mixer.RANDOM,
faults_identified=mixer.RANDOM,
recommendations=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(50).blend(MonthFeedback,
survey=mixer.SELECT,
completed_actions=mixer.RANDOM,
planned_actions=mixer.RANDOM,
cheese_box=mixer.RANDOM,
feedback=mixer.RANDOM,
notes=mixer.RANDOM)
mixer.cycle(20).blend(YearFeedback,
householders_name=mixer.RANDOM,
survey=mixer.SELECT,
diy_work=mixer.RANDOM,
prof_work=mixer.RANDOM,
contractors_used=mixer.RANDOM,
planned_work=mixer.RANDOM,
wellbeing_improvement=mixer.RANDOM,
behaviour_changes=mixer.RANDOM,
feedback=mixer.RANDOM,
notes=mixer.RANDOM)
# Remove duplicate references (where there should only be one).
for s in Surveys.query.all():
if len(s.result) > 1:
for x in s.result[1:]:
db.session.delete(x)
if len(s.pre_details) > 1:
for x in s.pre_details[1:]:
db.session.delete(x)
if len(s.post_details) > 1:
for x in s.post_details[1:]:
db.session.delete(x)
if len(s.month_feedback) > 1:
for x in s.month_feedback[1:]:
db.session.delete(x)
if len(s.year_feedback) > 1:
for x in s.year_feedback[1:]:
db.session.delete(x)
db.session.commit()