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