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}")