def test_create_view_with_conflicting_unique(self):
end_time = get_utc_now()
start_time = get_time_relative_units_ago(end_time, hours=8)
post_data = {"start_time": start_time, "end_time": end_time}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
data = response.data
value_name = data["end_time"]
value_parsed = parse_datetime_string(value_name)
self.assertEqual(end_time, value_parsed)
# post again, don't let you create something already made
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 400, response.data)
data = response.data
"""
error_message should be
{'non_field_errors': [ErrorDetail(string='The fields user, name must make a unique set.', code='unique')]}
"""
expected_error_found = "non_field_errors" in data
self.assertTrue(expected_error_found)
def setUpClass(cls):
cls.url = reverse(cls.url_name)
cls.current_time = get_utc_now()
cls.current_time_isoformat = cls.current_time.isoformat()
cls.current_date = cls.current_time.date()
cls.current_date_isoformat = cls.current_date.isoformat()
super().setUpClass()
def test_create_view_with_bad_supplement(self):
time = get_utc_now()
post_data = {
"supplement_uuid": TEST_CONSTANTS.INVALID_UUID,
"time": time.isoformat(),
"quantity": 5,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 400, response.data)
def test_create_view_with_nonsensical_start_time(self):
end_time = get_utc_now()
# get 8 hours in advance
start_time = get_time_relative_units_forward(end_time, hours=8)
post_data = {"start_time": start_time, "end_time": end_time}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 400, response.data)
self.assertTrue("non_field_errors" in response.data)
def test_create_view_with_blank_notes(self):
end_time = get_utc_now()
start_time = get_time_relative_units_ago(end_time, hours=8)
# important: notes has to have a space when failing with api client!
post_data = {
"start_time": start_time,
"end_time": end_time,
"notes": " "
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
def test_create_view(self):
end_time = get_utc_now()
start_time = get_time_relative_units_ago(end_time, hours=8)
post_data = {"start_time": start_time, "end_time": end_time}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
data = response.data
value_name = data["end_time"]
value_parsed = parse_datetime_string(value_name)
self.assertEqual(end_time, value_parsed)
def test_create_view_with_empty_notes(self):
supplement = SupplementFactory(user=self.user_1)
time = get_utc_now()
post_data = {
"supplement_uuid": str(supplement.uuid),
"time": time.isoformat(),
"quantity": 5,
"notes": " ",
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
def get_display_name(self, instance):
# a janky way to always serialize a display name that sort of explains the instance
time_ago = (get_utc_now() - instance.time).total_seconds()
hours_ago = time_ago / 3600
if hours_ago > 48:
days_ago = hours_ago / 24
relative_period_label = f"{days_ago:.01f} days ago"
else:
relative_period_label = f"{hours_ago:.01f} hours ago"
name = f"{instance.quantity:.0f} x {instance.supplement.name} from {relative_period_label}"
return name
def test_update_view_for_new_activity(self):
# create an instance already saved
instance = SleepLogFactory(user=self.user_1)
url = instance.get_update_url()
end_time = get_utc_now()
params = {"end_time": end_time}
response = self.client_1.post(url, data=params)
data = response.data
self.assertEqual(response.status_code, 200, data)
end_time_parsed = parse_datetime_string(data["end_time"])
self.assertEqual(end_time_parsed, end_time)
def test_display_name_on_log_serializer_some_days_ago(self):
supplement = SupplementFactory(user=self.user_1)
utc_now = get_utc_now()
time = get_time_relative_units_ago(utc_now, days=8.5)
post_data = {
"supplement_uuid": str(supplement.uuid),
"time": time.isoformat(),
"quantity": 5,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
display_name = response.data["display_name"]
self.assertTrue("8.5 days ago" in display_name, display_name)
def setUpTestData(cls):
user_1 = UserFactory()
user_2 = UserFactory()
cls.end_period = get_utc_now()
cls.end_period_date_string = cls.end_period.date().strftime(
yyyy_mm_dd_format_1)
cls.start_period = get_time_relative_units_ago(cls.end_period, days=7)
cls.start_period_date_string = cls.start_period.date().strftime(
yyyy_mm_dd_format_1)
supplements = SupplementFactory.create_batch(10, user=user_1)
for index in range(100):
# simulate some missing data
if index % 5 == 0 and index != 0:
continue
date_to_use = cls.end_period - relativedelta.relativedelta(
days=index)
SleepLogFactory(end_time=date_to_use, user=user_1)
for supplement in supplements:
SupplementLogFactory.create_batch(2,
user=user_1,
supplement=supplement,
time=date_to_use)
cls.user_1_id = user_1.id
cls.user_2_id = user_2.id
for index in range(100):
# simulate some missing data
if index % 5 == 0 and index != 0:
continue
date_to_use = cls.end_period - relativedelta.relativedelta(
days=index)
DailyProductivityLogFactory(user=user_1, date=date_to_use)
# add some random data to user_2 also to make sure no leaking
DailyProductivityLogFactory(user=user_2, date=date_to_use)
def test_create_view(self):
"""
dpy test open.core.betterself.tests.views.test_supplement_log_views.TestSupplementLogViews.test_create_view --keepdb
"""
supplement = SupplementFactory(user=self.user_1)
time = get_utc_now()
post_data = {
"supplement_uuid": str(supplement.uuid),
"time": time.isoformat(),
"quantity": 5,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
data = response.data
supplement_name = data["supplement"]["name"]
self.assertEqual(supplement.name, supplement_name)
self.assertIsNotNone(data["display_name"])
def test_create_serializer_with_no_notes(self):
"""
This is a REALLY weird problem where requests not originating from tests are failing when blank is left empty
"""
end_time = get_utc_now()
start_time = get_time_relative_units_ago(end_time, hours=8)
# empty string with notes here will still fail if it's broken -- this is with an RequestFactory
# to mimic how data is sent, i think APIClient serializes something
post_data = {
"start_time": start_time,
"end_time": end_time,
"notes": ""
}
context = create_api_request_context(self.url, self.user_1, post_data)
serializer = SleepLogCreateUpdateSerializer(data=post_data,
context=context)
valid = serializer.is_valid()
self.assertTrue(valid, serializer.errors)
def test_display_name_on_log_serializer_some_hours_ago(self):
"""
dpy test open.core.betterself.tests.views.test_supplement_log_views.TestSupplementLogViews.test_display_name_on_log_serializer_some_hours_ago --keepdb
"""
supplement = SupplementFactory(user=self.user_1)
utc_now = get_utc_now()
# if you adjust it this way, it should result in about 4.5 hours ago
time = get_time_relative_units_ago(utc_now, hours=5.0)
time = get_time_relative_units_forward(time, minutes=30)
post_data = {
"supplement_uuid": str(supplement.uuid),
"time": time.isoformat(),
"quantity": 5,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
display_name = response.data["display_name"]
self.assertTrue("4.5 hours ago" in display_name, display_name)
def test_create_view_with_conflicting_uniqueness(self):
supplement = SupplementFactory(user=self.user_1)
time = get_utc_now()
post_data = {
"supplement_uuid": str(supplement.uuid),
"time": time.isoformat(),
"quantity": 5,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
# don't let you recreate something that already's been made
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 400, response.data)
data = response.data
"""
error_message should be
{'non_field_errors': [ErrorDetail(string='The fields user, name must make a unique set.', code='unique')]}
"""
expected_error_found = "non_field_errors" in data
self.assertTrue(expected_error_found)
def test_create_supplement_log_with_supplement_stack(self):
"""
dpy test open.core.betterself.tests.views.test_supplement_log_views.TestSupplementLogViews.test_create_supplement_log_with_supplement_stack --keepdb
"""
# a hidden feature, not really restful, but allow a user to send a supplement_stack_uuid
# to create a set of supplements taken at the same time
supplements = SupplementFactory.create_batch(3, user=self.user_1)
stack = SupplementStackFactory(user=self.user_1)
compositions = []
for supplement in supplements:
composition = SupplementStackCompositionFactory(
user=self.user_1,
supplement=supplement,
stack=stack,
quantity=2)
compositions.append(composition)
stack_uuid = stack.uuid
utc_now = get_utc_now()
post_data = {
"supplement_uuid": str(stack_uuid),
"time": utc_now.isoformat(),
"quantity": 5,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200, response.data)
for supplement in supplements:
matching_log = SupplementLog.objects.get(supplement=supplement,
quantity=10,
user=self.user_1,
time=utc_now)
self.assertIsNotNone(matching_log)
def create_demo_fixtures_for_user(user):
username = user.username
if "demo" not in username:
raise ValueError(
f"Cannot Run Demo Fixtures for Username without DEMO {username}")
# wipe out all the previous models and start from scratch
models_to_clean = [
Activity,
ActivityLog,
DailyProductivityLog,
Ingredient,
IngredientComposition,
SleepLog,
Supplement,
SupplementLog,
SupplementStack,
SupplementStackComposition,
WellBeingLog,
FoodLog,
Food,
]
for model in models_to_clean:
model.objects.filter(user=user).delete()
# easier to see any row updates
daily_logs_to_create = 30
nested_models_logs_to_create = 10
supplements_to_create = 15
sleep_logs_to_create = 90
activities_to_create = 40
activities = ActivityFactory.create_batch(activities_to_create, user=user)
for activity in activities:
ActivityLogFactory.create_batch(nested_models_logs_to_create,
activity=activity,
user=user)
productivity_logs_to_create = 90
DailyProductivityLogFactory.create_batch(productivity_logs_to_create,
user=user)
supplements = SupplementFactory.create_batch(supplements_to_create,
user=user)
for supplement in supplements:
SupplementLogFactory.create_batch(nested_models_logs_to_create,
user=user,
supplement=supplement)
# ingredients = IngredientFactory.create_batch(fixtures_to_create, user=user)
#
# for ingredient in ingredients:
# ingredient_composition = IngredientCompositionFactory(
# ingredient=ingredient, user=user
# )
# supplement = SupplementFactory.create(
# user=user,
# name=ingredient.name,
# ingredient_compositions=[ingredient_composition],
# )
# SupplementLogFactory.create_batch(
# nested_models_logs_to_create, user=user, supplement=supplement
# )
WellBeingLogFactory.create_batch(daily_logs_to_create, user=user)
utc_now = get_utc_now()
# do 2 days ago, that way you can create data faster when self-testing
start_period = get_time_relative_units_ago(utc_now, days=2)
sleep_dates = []
for index in range(sleep_logs_to_create):
sleep_date = start_period - relativedelta.relativedelta(days=index)
sleep_dates.append(sleep_date)
for sleep_date in sleep_dates:
SleepLogFactory(end_time=sleep_date, user=user)
foods = FoodFactory.create_batch(daily_logs_to_create, user=user)
for food in foods:
FoodLogFactory.create_batch(nested_models_logs_to_create,
food=food,
user=user)
logger.info(f"Successfully Created Demo Fixtures for {user.username}")
def create_demo_fixtures_for_user(user):
username = user.username
if "demo" not in username:
raise ValueError(
f"Cannot Run Demo Fixtures for Username without DEMO {username}")
# wipe out all the previous models and start from scratch
models_to_clean = [
Activity,
ActivityLog,
DailyProductivityLog,
Ingredient,
IngredientComposition,
SleepLog,
Supplement,
SupplementLog,
SupplementStack,
SupplementStackComposition,
WellBeingLog,
FoodLog,
Food,
]
for model in models_to_clean:
model.objects.filter(user=user).delete()
# easier to see any row updates
daily_logs_to_create = 30
nested_models_logs_to_create = 10
supplements_to_create = 15
supplement_logs_to_create_daily = 2
sleep_logs_to_create = 90
activities_to_create = 40
activities = ActivityFactory.create_batch(activities_to_create, user=user)
for activity in activities:
ActivityLogFactory.create_batch(nested_models_logs_to_create,
activity=activity,
user=user)
productivity_logs_to_create = 90
# do a week ahead of time, that way you don't really have to deal with constantly rerunning
# this script for now on deployments
utc_now = get_utc_now()
# relative_end_date_of_fixtures_creation = get_time_relative_units_forward(
# utc_now, days=7
# )
# don't create dates in the advance now that we run this celery script every 30 minutes
relative_end_date_of_fixtures_creation = utc_now
dates_to_create = []
for index in range(productivity_logs_to_create):
relative_date = (relative_end_date_of_fixtures_creation -
relativedelta.relativedelta(days=index))
dates_to_create.append(relative_date)
supplements = SupplementFactory.create_batch(supplements_to_create,
user=user)
for date in dates_to_create:
DailyProductivityLogFactory(date=date, user=user)
start_dt = date.replace(hour=0)
end_dt = date.replace(hour=23)
for supplement in supplements:
result = FuzzyDateTime(start_dt=start_dt, end_dt=end_dt).fuzz()
# nothing more than right now, that's just noisy
if result > utc_now:
continue
SupplementLogFactory.create_batch(
supplement_logs_to_create_daily,
user=user,
supplement=supplement,
time=result,
)
# ingredients = IngredientFactory.create_batch(fixtures_to_create, user=user)
#
# for ingredient in ingredients:
# ingredient_composition = IngredientCompositionFactory(
# ingredient=ingredient, user=user
# )
# supplement = SupplementFactory.create(
# user=user,
# name=ingredient.name,
# ingredient_compositions=[ingredient_composition],
# )
# SupplementLogFactory.create_batch(
# nested_models_logs_to_create, user=user, supplement=supplement
# )
WellBeingLogFactory.create_batch(daily_logs_to_create, user=user)
sleep_dates = []
for index in range(sleep_logs_to_create):
sleep_date = (relative_end_date_of_fixtures_creation -
relativedelta.relativedelta(days=index))
sleep_dates.append(sleep_date)
for sleep_date in sleep_dates:
SleepLogFactory(end_time=sleep_date, user=user)
foods = FoodFactory.create_batch(daily_logs_to_create, user=user)
for food in foods:
FoodLogFactory.create_batch(nested_models_logs_to_create,
food=food,
user=user)
logger.info(f"Successfully Created Demo Fixtures for {user.username}")
