def test_create_view_with_duplication_data_change_quantity(self):
"""
dpy test open.core.betterself.tests.views.test_supplement_stack_composition_views.SupplementStackCompositionCreateTestView.test_create_view_with_duplication_data_change_quantity --keepdb
"""
supplement_1 = SupplementFactory(user=self.user_1)
stack = SupplementStackFactory(user=self.user_1)
supplement_1_uuid = str(supplement_1.uuid)
stack_uuid = str(stack.uuid)
quantity = 5
post_data = {
"supplement_uuid": supplement_1_uuid,
"stack_uuid": stack_uuid,
"quantity": quantity,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
# now create a composition with supplement 2
supplement_2 = SupplementFactory(user=self.user_1,
name="Not Supplement 1")
self.assertNotEqual(supplement_1, supplement_2)
supplement_2_uuid = str(supplement_2.uuid)
post_data = {
"supplement_uuid": supplement_2_uuid,
"stack_uuid": stack_uuid,
"quantity": quantity,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
stack.refresh_from_db()
self.assertEqual(stack.compositions.count(), 2)
# now edit supplement 2 to be supplement 1
last_composition = SupplementStackComposition.objects.get(
user=self.user_1, supplement=supplement_2, stack__uuid=stack_uuid)
update_url = last_composition.get_update_url()
update_params = {"supplement_uuid": supplement_1_uuid}
response = self.client_1.post(update_url, data=update_params)
self.assertEqual(response.status_code, 400)
def test_url_with_supplements_requested(self):
url = reverse(BetterSelfResourceConstants.AGGREGATE)
start_date = "2020-01-02"
supplements = SupplementFactory.create_batch(2, user=self.user_1)
start_time = serialize_date_to_user_localized_datetime(
start_date, user=self.user_1)
for supplement in supplements:
SupplementLogFactory(user=self.user_1,
supplement=supplement,
time=start_time)
supplement_uuids = [str(supplement.uuid) for supplement in supplements]
kwargs = {
"start_date": "2020-01-01",
"end_date": "2020-01-02",
"supplement_uuids": supplement_uuids,
}
response = self.client_1.post(url, data=kwargs, format="json")
self.assertEqual(response.status_code, 200, response.data)
self.assertIsNotNone(response.data["supplements"])
def test_url_with_supplements_requested_filter(self):
url = reverse(BetterSelfResourceConstants.AGGREGATE)
start_date = "2020-01-02"
# delete any previous data to not screw up results
SupplementLog.objects.filter(user=self.user_1).delete()
supplements = SupplementFactory.create_batch(2, user=self.user_1)
start_time = serialize_date_to_user_localized_datetime(
start_date, user=self.user_1)
for supplement in supplements:
SupplementLogFactory(user=self.user_1,
supplement=supplement,
time=start_time)
# only do one uuid
supplement_uuids = [
str(supplement.uuid) for supplement in supplements[:1]
]
kwargs = {
"start_date": "2020-01-01",
"end_date": "2020-01-02",
"supplement_uuids": supplement_uuids,
}
response = self.client_1.post(url, data=kwargs, format="json")
self.assertEqual(response.status_code, 200, response.data)
expected_log_count = SupplementLog.objects.filter(
user=self.user_1, supplement__uuid__in=supplement_uuids).count()
returned_log_count = len(response.data["supplements"]["logs"])
self.assertEqual(expected_log_count, returned_log_count)
def test_create_view_with_separate_supplements_create_separate_compositions(
self):
"""
dpy test open.core.betterself.tests.views.test_supplement_stack_composition_views.SupplementStackCompositionCreateTestView.test_create_view_with_separate_supplements_create_separate_compositions --keepdb
"""
supplement_1 = SupplementFactory(user=self.user_1)
stack = SupplementStackFactory(user=self.user_1)
supplement_1_uuid = str(supplement_1.uuid)
stack_uuid = str(stack.uuid)
quantity = 5
post_data = {
"supplement_uuid": supplement_1_uuid,
"stack_uuid": stack_uuid,
"quantity": quantity,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
stack.refresh_from_db()
self.assertEqual(stack.compositions.count(), 1)
# now create it with supplement 2
supplement_2 = SupplementFactory(user=self.user_1)
self.assertNotEqual(supplement_1, supplement_2)
supplement_2_uuid = str(supplement_2.uuid)
post_data = {
"supplement_uuid": supplement_2_uuid,
"stack_uuid": stack_uuid,
"quantity": quantity,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
stack.refresh_from_db()
self.assertEqual(stack.compositions.count(), 2)
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 test_partial_validator_with_supplement_uuid(self):
supplement = SupplementFactory()
supplement_uuid = str(supplement.uuid)
validator = generic_model_uuid_validator(Supplement)
result = validator(supplement_uuid)
# if it's valid, it doesn't return anything
self.assertIsNone(result)
# bad uuid, it should trip
random_uuid = str(uuid.uuid4())
with self.assertRaises(ValidationError):
validator(random_uuid)
def test_update_supplement_in_supplement_stack_composition(self):
instance = SupplementStackCompositionFactory(user=self.user_1,
quantity=10)
supplement = SupplementFactory(user=self.user_1)
self.assertNotEqual(instance.supplement, supplement)
url = instance.get_update_url()
params = {"supplement_uuid": str(supplement.uuid), "quantity": 5}
response = self.client_1.post(url, data=params)
data = response.data
self.assertEqual(response.status_code, 200, data)
self.assertEqual(data["supplement"]["uuid"], str(supplement.uuid))
def test_create_view(self):
supplement = SupplementFactory(user=self.user_1)
stack = SupplementStackFactory(user=self.user_1)
supplement_uuid = str(supplement.uuid)
stack_uuid = str(stack.uuid)
quantity = 5
post_data = {
"supplement_uuid": supplement_uuid,
"stack_uuid": stack_uuid,
"quantity": quantity,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
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_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_duplication_data(self):
supplement = SupplementFactory(user=self.user_1)
stack = SupplementStackFactory(user=self.user_1)
supplement_uuid = str(supplement.uuid)
stack_uuid = str(stack.uuid)
quantity = 5
post_data = {
"supplement_uuid": supplement_uuid,
"stack_uuid": stack_uuid,
"quantity": quantity,
}
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
response = self.client_1.post(self.url, data=post_data)
self.assertEqual(response.status_code, 400)
expected_error_found = "non_field_errors" in response.data
self.assertTrue(expected_error_found)
def setUpTestData(cls):
user_1 = UserFactory()
user_2 = UserFactory()
# do 2 days ago, that way you can create data faster when self-testing
start_period = datetime.datetime(2020, 9, 22, tzinfo=user_1.timezone)
supplements = SupplementFactory.create_batch(2, user=user_1)
for index in range(3):
date_to_use = start_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
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
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}")
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}")
