def test_get_timeframe(self):
## Each test tests that it gets the correct start / endpoints, even if the time is the start point
tf = Timeframe.get_timeframe("daily", datetime.datetime(2016, 1, 1))
self.assertEqual(tf.start, datetime.datetime(2016, 1, 1))
self.assertEqual(tf.end, datetime.datetime(2016, 1, 2))
new_tf = Timeframe.get_timeframe("daily", datetime.datetime(2016, 1, 1, 23, 59, 59, 99999))
self.assertEqual(new_tf.to_dict(), tf.to_dict())
tf = Timeframe.get_timeframe("weekly", datetime.datetime(2016, 2, 7))
self.assertEqual(tf.start, datetime.datetime(2016, 2, 7))
self.assertEqual(tf.end, datetime.datetime(2016, 2, 14))
new_tf = Timeframe.get_timeframe("weekly", datetime.datetime(2016, 2, 13, 23, 59, 59, 99999))
self.assertEqual(new_tf.to_dict(), tf.to_dict())
tf = Timeframe.get_timeframe("monthly", datetime.datetime(2016, 2, 1))
self.assertEqual(tf.start, datetime.datetime(2016, 2, 1))
self.assertEqual(tf.end, datetime.datetime(2016, 3, 1))
new_tf = Timeframe.get_timeframe("monthly", datetime.datetime(2016, 2, 29, 23, 59, 59, 99999))
self.assertEqual(new_tf.to_dict(), tf.to_dict())
tf = Timeframe.get_timeframe("quarterly", datetime.datetime(2016, 1, 1))
self.assertEqual(tf.start, datetime.datetime(2016, 1, 1))
self.assertEqual(tf.end, datetime.datetime(2016, 4, 1))
new_tf = Timeframe.get_timeframe("quarterly", datetime.datetime(2016, 3, 31, 23, 59, 59, 99999))
self.assertEqual(new_tf.to_dict(), tf.to_dict())
tf = Timeframe.get_timeframe("yearly", datetime.datetime(2016, 1, 1))
self.assertEqual(tf.start, datetime.datetime(2016, 1, 1))
self.assertEqual(tf.end, datetime.datetime(2017, 1, 1))
new_tf = Timeframe.get_timeframe("yearly", datetime.datetime(2016, 12, 31, 23, 59, 59, 99999))
self.assertEqual(new_tf.to_dict(), tf.to_dict())
def test_get_most_recent_week_start(self):
## Should work for all days of the week
for x in range(0, 7):
time = datetime.datetime(2016, 2, 7) ## known Sunday
test_time = time + dateutil.relativedelta.relativedelta(days=x)
self.assertEqual(time, Timeframe.get_most_recent_week_start(test_time))
## Should work around edge cases -- year and month breaks
time = datetime.datetime(2016, 1, 1)
self.assertEqual(datetime.datetime(2015, 12, 27), Timeframe.get_most_recent_week_start(time))
def test_pull_by_start_end(self):
## Pulling by start / end should return None if none exists:
self.assertIsNone(Timeframe.pull_by_start_end(datetime.datetime(2016, 1, 1), datetime.datetime(2017, 1, 1)))
tf = Timeframe("yearly", datetime.datetime(2016, 1, 1))
tf.persist()
self.assertTrue(tf.exists())
check_tf = Timeframe.pull_by_start_end(tf.start, tf.end).to_dict()
for key, val in tf.to_dict().iteritems():
self.assertEqual(check_tf[key], val)
## Should *not* pull if the start is right and end is wrong or vice versa:
self.assertIsNone(Timeframe.pull_by_start_end(tf.start, datetime.datetime(2016, 2, 1)))
self.assertIsNone(Timeframe.pull_by_start_end(datetime.datetime(2016, 2, 1), tf.end))
def test_pull_by_goal_timeframes(self):
ci = self.get_test_check_in()
timeframes = [ci.timeframe]
ci.persist()
for x in range(0, 7):
tf = ci.timeframe_obj
new_tf = Timeframe(tf.frequency_name, tf.start + datetime.timedelta(1))
timeframes.append(new_tf.get_id())
ci = CheckIn(ci.goal_obj, new_tf, x)
ci.persist()
cis = CheckIn.pull_by_goal_timeframes(ci.goal, timeframes)
self.assertEqual(len(cis), 8)
def test_pull_by_id(self):
## Test that a timeframe that exists can be pulled by ID
self.assertIsNone(Timeframe.pull_by_id(0))
tf = Timeframe("yearly", datetime.datetime(2016, 1, 1))
tf.persist()
self.assertTrue(tf.exists())
check_tf = Timeframe.pull_by_id(tf.get_id()).to_dict()
for key, val in tf.to_dict().iteritems():
self.assertEqual(check_tf[key], val)
def test_persist(self):
## Test that data persists to the database
tf = Timeframe("yearly", datetime.datetime(2016, 1, 1))
tf.persist()
self.assertTrue(tf.exists())
check_tf = Timeframe.pull_by_start_end(tf.start, tf.end).to_dict()
for key, val in tf.to_dict().iteritems():
self.assertEqual(check_tf[key], val)
## Test that you can persist the same one twice without duplicate key, etc errors
tf.persist()
def pull_by_goal_start_end(self, goal, start, end):
"""Return an array of check-ins given a goal ID and start date and an end date"""
goal = Goal.pull_by_id(goal)
timeframes = Timeframe.get_timeframes(goal.check_in_frequency_name, start, end)
timeframes = [x.get_id() for x in timeframes]
return self.pull_by_goal_timeframes(goal.get_id(), timeframes)
def test_get(self):
tc = self.test_client
## Login required
setup.assertRequiresLogin(self, tc.get("/goals/0/check-ins/0/"))
## Goal exists
self.login()
setup.assert404(self, tc.get("/goals/0/check-ins/0/"))
## user is goal owner
goal = self.create_test_numeric_goal()
goal_id = str(goal.get_id())
self.logout()
self.login_other_user()
setup.assertInvalidCredentials(self, tc.get("/goals/" + goal_id + "/check-ins/0/"))
## Check in must exist
self.logout()
self.login()
setup.assert404(self, tc.get("/goals/" + goal_id + "/check-ins/0/"))
## Returns correctly
ci = CheckIn(goal, Timeframe.get_current_timeframe(goal.check_in_frequency_name), 1)
ci.persist()
tfid = str(ci.timeframe)
res = tc.get("/goals/" + goal_id + "/check-ins/" + tfid + "/")
setup.assertOk(self, res, 200)
self.assertEqual(json.loads(res.data), ci.to_dict())
def test_init(self):
## Should fail if bogus goal is specified
with self.assertRaisesRegexp(AssertionError, "Passed goal must be a goal object"):
ci = CheckIn("bogus", self.test_tf, 1)
## Should fail if not a timeframe
with self.assertRaisesRegexp(AssertionError, "Passed timeframe must be a timeframe object"):
ci = CheckIn(self.test_numeric_goal, "bogus", 1)
## Should fail if timeframe doesn't conform:
with self.assertRaisesRegexp(AssertionError, "Passed timeframe frequency must match"):
ci = CheckIn(self.test_numeric_goal, Timeframe("weekly", datetime.datetime(2016,2,7)), 1)
## Should fail if numeric and a boolean is passed
with self.assertRaisesRegexp(AssertionError, "Value must be numeric"):
ci = CheckIn(self.test_numeric_goal, self.test_tf, "orange you glad I didn't say banana?'")
## Should fail if binary and a number is passed
with self.assertRaisesRegexp(AssertionError, "Value must be a boolean"):
ci = CheckIn(self.test_binary_goal, self.test_tf, 30)
## Should actually work if everything is provided correctly
ci = CheckIn(self.test_numeric_goal, self.test_tf, 30)
self.assertEqual(ci.goal_obj, self.test_numeric_goal)
self.assertEqual(ci.goal, self.test_numeric_goal.get_id())
self.assertEqual(ci.timeframe_obj, self.test_tf)
self.assertEqual(ci.timeframe, self.test_tf.get_id())
self.assertEqual(ci.value, 30)
ci = CheckIn(self.test_binary_goal, self.test_tf, True)
self.assertEqual(ci.goal_obj, self.test_binary_goal)
self.assertEqual(ci.goal, self.test_binary_goal.get_id())
self.assertEqual(ci.timeframe_obj, self.test_tf)
self.assertEqual(ci.timeframe, self.test_tf.get_id())
self.assertEqual(ci.value, 1)
def test_get(self):
tc = self.test_client
## Login required
setup.assertRequiresLogin(self, tc.get("/goals/0/check-ins/0/"))
## Goal exists
self.login()
setup.assert404(self, tc.get("/goals/0/check-ins/0/"))
## user is goal owner
goal = self.create_test_numeric_goal()
goal_id = str(goal.get_id())
self.logout()
self.login_other_user()
setup.assertInvalidCredentials(
self, tc.get("/goals/" + goal_id + "/check-ins/0/"))
## Check in must exist
self.logout()
self.login()
setup.assert404(self, tc.get("/goals/" + goal_id + "/check-ins/0/"))
## Returns correctly
ci = CheckIn(
goal,
Timeframe.get_current_timeframe(goal.check_in_frequency_name), 1)
ci.persist()
tfid = str(ci.timeframe)
res = tc.get("/goals/" + goal_id + "/check-ins/" + tfid + "/")
setup.assertOk(self, res, 200)
self.assertEqual(json.loads(res.data), ci.to_dict())
def test_sub_timeframes(self):
tf = Timeframe.get_timeframe("yearly", datetime.datetime(2016, 1, 1))
tfs = tf.sub_timeframes("daily")
start = tf.start
self.assertEqual(len(tfs), 366)
for x in tfs:
self.assertEqual(start, x.start)
start = start + datetime.timedelta(1)
def check_in(id):
validate_form(request.form, ["value"])
goal = Goal.pull_by_id(id)
if (not goal):
raise NotFoundError()
if goal.user != current_user.get_id():
raise UnauthorizedError
if ('timeframe' in request.form):
timeframe = Timeframe.pull_by_id(request.form['timeframe'])
else:
timeframe = Timeframe.get_current_timeframe(goal.check_in_frequency_name)
check_in = CheckIn(goal, timeframe, request.form['value'])
return_code = 200 if check_in.exists() else 201
check_in.persist()
return check_in.to_json(), return_code
def test_pull_by_goal_start_end(self):
ci = self.get_test_check_in()
ci.persist()
for x in range(0, 7):
tf = ci.timeframe_obj
new_tf = Timeframe(tf.frequency_name, tf.start + datetime.timedelta(1))
ci = CheckIn(ci.goal_obj, new_tf, x)
ci.persist()
cis = CheckIn.pull_by_goal_start_end(ci.goal, datetime.datetime(2016, 1, 1), datetime.datetime(2016, 1, 8))
self.assertEqual(len(cis), 7)
def get_current_check_in(id):
"""Get the current check-in for a given goal. Returns 404 if the current check-in or goal does not exist"""
goal = Goal.pull_by_id(id)
if (not goal):
raise NotFoundError()
if goal.user != current_user.get_id():
raise UnauthorizedError
check_in = CheckIn.pull_by_goal_timeframe(id, Timeframe.get_current_timeframe(goal.check_in_frequency_name).get_id())
if (not check_in):
raise NotFoundError()
return check_in.to_json(), 200
def reconstruct(self):
self.goal_obj = Goal.pull_by_id(self.goal)
self.timeframe_obj = Timeframe.pull_by_id(self.timeframe)
def test_check_in(self):
tc = self.test_client
# Requires Login:
res = tc.post("/goals/1/check-ins/", data={"value": 1})
setup.assertRequiresLogin(self, res)
## Requires "value"
self.login()
res = tc.post("/goals/1/check-ins/", data={"not-value": 1})
setup.assertInvalid(self, res, "value")
## Must be a goal that exists
res = tc.post("/goals/0/check-ins/", data={"value": 1})
setup.assert404(self, res)
## User must own the goal in question
numeric_goal = self.create_test_numeric_goal()
numeric_goal_id = str(numeric_goal.get_id()) ## You have to do this before you log out, for some reason?
binary_goal = self.create_test_binary_goal()
binary_goal_id = str(binary_goal.get_id())
self.logout()
self.login_other_user()
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/", data={"value": 1})
setup.assertInvalidCredentials(self, res)
## Check-in must conform (true / false vs. numeric)
self.logout()
self.login()
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/", data={"value": "true"})
setup.assertBadData(self, res, "Value must be numeric")
res = tc.post("/goals/" + binary_goal_id + "/check-ins/", data={"value": 10})
setup.assertBadData(self, res, "Value must be a boolean")
## Check-in is returned with 201 if no timeframe is given, returning current timeframe (both numeric & binary)
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/", data={"value": 1})
setup.assertOk(self, res, 201)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 1)
self.assertEqual(data['timeframe'], Timeframe.get_current_timeframe('daily').to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
res = tc.post("/goals/" + binary_goal_id + "/check-ins/", data={"value": True})
setup.assertOk(self, res, 201)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), binary_goal_id)
self.assertEqual(data['value'], 1)
self.assertEqual(data['timeframe'], Timeframe.get_current_timeframe('daily').to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
## An updated check-in is returned with 200 if no timeframe is given, returning current timeframe
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/", data={"value": 3})
setup.assertOk(self, res, 200)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 3)
self.assertEqual(data['timeframe'], Timeframe.get_current_timeframe('daily').to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
## Check-in is returned with 201 if timeframe ID is given, returning correct timeframe
tf = Timeframe.get_timeframe("daily", datetime.datetime(2016, 1, 1))
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/", data={"value": 1, "timeframe": tf.get_id()})
setup.assertOk(self, res, 201)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 1)
self.assertEqual(data['timeframe'], tf.to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
## Updated check-in is returned with 200 if Timeframe ID is given, returning correct timeframe
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/", data={"value": 3, "timeframe": tf.get_id()})
setup.assertOk(self, res, 200)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 3)
self.assertEqual(data['timeframe'], tf.to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
def test_check_in(self):
tc = self.test_client
# Requires Login:
res = tc.post("/goals/1/check-ins/", data={"value": 1})
setup.assertRequiresLogin(self, res)
## Requires "value"
self.login()
res = tc.post("/goals/1/check-ins/", data={"not-value": 1})
setup.assertInvalid(self, res, "value")
## Must be a goal that exists
res = tc.post("/goals/0/check-ins/", data={"value": 1})
setup.assert404(self, res)
## User must own the goal in question
numeric_goal = self.create_test_numeric_goal()
numeric_goal_id = str(numeric_goal.get_id(
)) ## You have to do this before you log out, for some reason?
binary_goal = self.create_test_binary_goal()
binary_goal_id = str(binary_goal.get_id())
self.logout()
self.login_other_user()
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/",
data={"value": 1})
setup.assertInvalidCredentials(self, res)
## Check-in must conform (true / false vs. numeric)
self.logout()
self.login()
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/",
data={"value": "true"})
setup.assertBadData(self, res, "Value must be numeric")
res = tc.post("/goals/" + binary_goal_id + "/check-ins/",
data={"value": 10})
setup.assertBadData(self, res, "Value must be a boolean")
## Check-in is returned with 201 if no timeframe is given, returning current timeframe (both numeric & binary)
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/",
data={"value": 1})
setup.assertOk(self, res, 201)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 1)
self.assertEqual(data['timeframe'],
Timeframe.get_current_timeframe('daily').to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
res = tc.post("/goals/" + binary_goal_id + "/check-ins/",
data={"value": True})
setup.assertOk(self, res, 201)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), binary_goal_id)
self.assertEqual(data['value'], 1)
self.assertEqual(data['timeframe'],
Timeframe.get_current_timeframe('daily').to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
## An updated check-in is returned with 200 if no timeframe is given, returning current timeframe
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/",
data={"value": 3})
setup.assertOk(self, res, 200)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 3)
self.assertEqual(data['timeframe'],
Timeframe.get_current_timeframe('daily').to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
## Check-in is returned with 201 if timeframe ID is given, returning correct timeframe
tf = Timeframe.get_timeframe("daily", datetime.datetime(2016, 1, 1))
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/",
data={
"value": 1,
"timeframe": tf.get_id()
})
setup.assertOk(self, res, 201)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 1)
self.assertEqual(data['timeframe'], tf.to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
## Updated check-in is returned with 200 if Timeframe ID is given, returning correct timeframe
res = tc.post("/goals/" + numeric_goal_id + "/check-ins/",
data={
"value": 3,
"timeframe": tf.get_id()
})
setup.assertOk(self, res, 200)
data = json.loads(res.data)
self.assertIn("id", data)
self.assertEqual(str(data['goal']), numeric_goal_id)
self.assertEqual(data['value'], 3)
self.assertEqual(data['timeframe'], tf.to_dict())
self.assertEqual(CheckIn.pull_by_id(data['id']).to_dict(), data)
def test_get_by_time(self):
tc = self.test_client
## Login required
setup.assertRequiresLogin(self, tc.get("/goals/0/check-ins/"))
## Goal must exist
self.login()
setup.assert404(self, tc.get("/goals/0/check-ins/"))
## User is the goal's owner
goal = self.create_test_numeric_goal()
goal_id = str(goal.get_id())
self.logout()
self.login_other_user()
setup.assertInvalidCredentials(
self, tc.get("/goals/" + goal_id + "/check-ins/"))
## Start and end are present
self.logout()
self.login()
setup.assertBadData(self, tc.get("/goals/" + goal_id + "/check-ins/"),
"start and end")
setup.assertBadData(
self, tc.get("/goals/" + goal_id + "/check-ins/?start=banana"),
"start and end")
setup.assertBadData(
self, tc.get("/goals/" + goal_id + "/check-ins/?end=banana"),
"start and end")
## Start and end in format YYYY-MM-DD HH:mm:ss
res = tc.get("/goals/" + goal_id +
"/check-ins/?start=2016-01-01 10:00:00&end=banana")
setup.assertBadData(self, res, "'banana' does not match format")
res = tc.get("/goals/" + goal_id +
"/check-ins/?start=strawberry&end=2016-01-01 10:00:00")
setup.assertBadData(self, res, "'strawberry' does not match format")
## Returns empty for no check-ins
res = tc.get(
"/goals/" + goal_id +
"/check-ins/?start=2016-01-01 00:00:00&end=2016-01-08 00:00:00")
setup.assertOk(self, res)
data = json.loads(res.data)
self.assertIn("check-ins", data)
self.assertEqual(len(data['check-ins']), 0)
## Correctly returns multiple check-ins
ci = CheckIn(
goal,
Timeframe(goal.check_in_frequency_name,
datetime.datetime(2015, 12, 31)), 0)
ci.persist()
for x in range(
0, 8
): #one preceding and one postceding so we can make sure this limits the results
tf = ci.timeframe_obj
new_tf = Timeframe(tf.frequency_name,
tf.start + datetime.timedelta(1))
ci = CheckIn(ci.goal_obj, new_tf, x)
ci.persist()
res = tc.get(
"/goals/" + goal_id +
"/check-ins/?start=2016-01-01 00:00:00&end=2016-01-08 00:00:00")
setup.assertOk(self, res)
data = json.loads(res.data)
self.assertIn("check-ins", data)
self.assertEqual(len(data['check-ins']), 7)
for index, check_in in enumerate(data['check-ins']):
self.assertEqual(index, check_in['value'])
def test_init(self):
## Should fail if bogus frequency is specified
with self.assertRaisesRegexp(AssertionError, "Frequency must be one of"):
tf = Timeframe("bogus", datetime.datetime.now())
## start date for daily should always be the start of a day
with self.assertRaisesRegexp(AssertionError, "Timeframe must begin at midnight"):
tf = Timeframe("daily", datetime.datetime(2016, 1, 1, 1, 1, 1))
with self.assertRaisesRegexp(AssertionError, "Timeframe must begin at midnight"):
tf = Timeframe("daily", datetime.datetime(2016, 1, 1, 1, 1))
with self.assertRaisesRegexp(AssertionError, "Timeframe must begin at midnight"):
tf = Timeframe("daily", datetime.datetime(2016, 1, 1, 1))
tf = Timeframe("daily", datetime.datetime(2016, 1, 1))
self.assertEqual(tf.end, datetime.datetime(2016, 1, 2))
with self.assertRaisesRegexp(AssertionError, "Weekly timeframes must begin on Sunday"):
tf = Timeframe("weekly", datetime.datetime(2016, 1, 1))
## start date for monthly should always be the start of a month
with self.assertRaisesRegexp(AssertionError, "Monthly timeframes must begin on the first"):
tf = Timeframe("monthly", datetime.datetime(2016, 1, 2))
tf = Timeframe("monthly", datetime.datetime(2016, 1, 1))
self.assertEqual(tf.end, datetime.datetime(2016, 2, 1))
## start date for quarterly should always be the start of a quarter
with self.assertRaisesRegexp(AssertionError, "Quarterly timeframes must begin "):
tf = Timeframe("quarterly", datetime.datetime(2016, 2, 1))
tf = Timeframe("quarterly", datetime.datetime(2016, 1, 1))
self.assertEqual(tf.end, datetime.datetime(2016, 4, 1))
## start date for yearly should always be the start of a year
with self.assertRaisesRegexp(AssertionError, "Yearly timeframes must begin on"):
tf = Timeframe("yearly", datetime.datetime(2016, 4, 1))
tf = Timeframe("yearly", datetime.datetime(2016, 1, 1))
self.assertEqual(tf.end, datetime.datetime(2017, 1, 1))
## Should create a weekly timeframe if everything's cool
now = datetime.datetime(2016, 2, 7)
tf = Timeframe("weekly", now)
self.assertEqual(tf.start, now)
self.assertEqual(tf.end, now + datetime.timedelta(7))
self.assertEqual(tf.frequency_name, "weekly")
self.assertIs(type(tf.frequency), long)
def test_get_id(self):
## Test that a Timeframe that has just been persisted returns an ID
tf = Timeframe("yearly", datetime.datetime(2016, 1, 1))
tf.persist()
self.assertIsNotNone(tf.get_id())
## Test that a timeframe pulled by id returns same id
check_tf = Timeframe.pull_by_id(tf.get_id())
self.assertEqual(check_tf.get_id(), tf.get_id())
## Test that a timeframe created by start / end persistes, then returns an ID
tf = Timeframe("monthly", datetime.datetime(2016, 1, 1))
self.assertIsNotNone(tf.get_id())
self.assertTrue(tf.exists())
self.assertNotEqual(tf.get_id(), check_tf.get_id())
## Test that a timeframe pulled by start / end returns an ID
check_tf = Timeframe.pull_by_start_end(tf.start, tf.end)
self.assertEqual(check_tf.get_id(), tf.get_id())
def test__calculate_end(self):
time = datetime.datetime(2016, 2, 29) ## pretty much as edge case as you can get?
tf = Timeframe("daily", time)
self.assertEqual(tf._calculate_end(), datetime.datetime(2016, 3, 1))
tf.frequency_name = "weekly"
self.assertEqual(tf._calculate_end(), datetime.datetime(2016, 3, 7))
tf.frequency_name = "monthly"
self.assertEqual(tf._calculate_end(), datetime.datetime(2016, 3, 29))
tf.frequency_name = "quarterly"
self.assertEqual(tf._calculate_end(), datetime.datetime(2016, 5, 29))
tf.frequency_name = "yearly"
self.assertEqual(tf._calculate_end(), datetime.datetime(2017, 2, 28))
def test_exists(self):
tf = Timeframe("yearly", datetime.datetime(2016, 1, 1))
self.assertFalse(tf.exists())
tf.persist()
self.assertTrue(tf.exists())
class TestCheckIn(unittest.TestCase):
test_tf = Timeframe("daily", datetime.datetime(2016, 1, 1))
test_user = setup.create_test_user()
test_binary_goal = Goal(test_user, "test binary goal", "is this goal a test?", "weekly", 10, "binary", "daily")
test_numeric_goal = Goal(test_user, "test numeric goal", "is this goal a test?", "weekly", 10, "numeric", "daily")
test_binary_goal.persist()
test_numeric_goal.persist()
@classmethod
def startUpClass(self):
Goal.query.delete()
db.session.commit()
@classmethod
def tearDownClass(self):
CheckIn.query.delete()
Goal.query.delete()
db.session.commit()
def startUp(self):
CheckIn.query.delete()
def tearDown(self):
CheckIn.query.delete()
def test_init(self):
## Should fail if bogus goal is specified
with self.assertRaisesRegexp(AssertionError, "Passed goal must be a goal object"):
ci = CheckIn("bogus", self.test_tf, 1)
## Should fail if not a timeframe
with self.assertRaisesRegexp(AssertionError, "Passed timeframe must be a timeframe object"):
ci = CheckIn(self.test_numeric_goal, "bogus", 1)
## Should fail if timeframe doesn't conform:
with self.assertRaisesRegexp(AssertionError, "Passed timeframe frequency must match"):
ci = CheckIn(self.test_numeric_goal, Timeframe("weekly", datetime.datetime(2016,2,7)), 1)
## Should fail if numeric and a boolean is passed
with self.assertRaisesRegexp(AssertionError, "Value must be numeric"):
ci = CheckIn(self.test_numeric_goal, self.test_tf, "orange you glad I didn't say banana?'")
## Should fail if binary and a number is passed
with self.assertRaisesRegexp(AssertionError, "Value must be a boolean"):
ci = CheckIn(self.test_binary_goal, self.test_tf, 30)
## Should actually work if everything is provided correctly
ci = CheckIn(self.test_numeric_goal, self.test_tf, 30)
self.assertEqual(ci.goal_obj, self.test_numeric_goal)
self.assertEqual(ci.goal, self.test_numeric_goal.get_id())
self.assertEqual(ci.timeframe_obj, self.test_tf)
self.assertEqual(ci.timeframe, self.test_tf.get_id())
self.assertEqual(ci.value, 30)
ci = CheckIn(self.test_binary_goal, self.test_tf, True)
self.assertEqual(ci.goal_obj, self.test_binary_goal)
self.assertEqual(ci.goal, self.test_binary_goal.get_id())
self.assertEqual(ci.timeframe_obj, self.test_tf)
self.assertEqual(ci.timeframe, self.test_tf.get_id())
self.assertEqual(ci.value, 1)
def test_persist(self): ## also tests exists, really -- and pull_by_id
ci = self.get_test_check_in()
self.assertFalse(ci.exists())
ci.persist()
self.assertTrue(ci.exists())
self.assertIsNotNone(ci.get_id())
self.assertEqual(ci.to_dict(), CheckIn.pull_by_id(ci.get_id()).to_dict())
## now if you overwrite that it should still work.
ci = CheckIn(self.test_numeric_goal, self.test_tf, 60)
self.assertTrue(ci.exists())
ci.persist()
test_ci = CheckIn.pull_by_id(ci.get_id())
self.assertEqual(ci.to_dict(), test_ci.to_dict())
self.assertEqual(test_ci.value, 60)
def test_pull_by_goal_timeframe(self):
ci = CheckIn.pull_by_goal_timeframe(self.test_numeric_goal.get_id(), self.test_tf.get_id())
self.assertIsNone(ci)
ci = self.get_test_check_in()
ci.persist()
test_ci = CheckIn.pull_by_goal_timeframe(self.test_numeric_goal.get_id(), self.test_tf.get_id())
self.assertEqual(ci.to_dict(), test_ci.to_dict())
def test_destroy(self):
ci = self.get_test_check_in()
ci.persist()
self.assertTrue(ci.exists())
ci.destroy()
self.assertFalse(ci.exists())
def test_pull_by_goal_start_end(self):
ci = self.get_test_check_in()
ci.persist()
for x in range(0, 7):
tf = ci.timeframe_obj
new_tf = Timeframe(tf.frequency_name, tf.start + datetime.timedelta(1))
ci = CheckIn(ci.goal_obj, new_tf, x)
ci.persist()
cis = CheckIn.pull_by_goal_start_end(ci.goal, datetime.datetime(2016, 1, 1), datetime.datetime(2016, 1, 8))
self.assertEqual(len(cis), 7)
def test_pull_by_goal_timeframes(self):
ci = self.get_test_check_in()
timeframes = [ci.timeframe]
ci.persist()
for x in range(0, 7):
tf = ci.timeframe_obj
new_tf = Timeframe(tf.frequency_name, tf.start + datetime.timedelta(1))
timeframes.append(new_tf.get_id())
ci = CheckIn(ci.goal_obj, new_tf, x)
ci.persist()
cis = CheckIn.pull_by_goal_timeframes(ci.goal, timeframes)
self.assertEqual(len(cis), 8)
def get_test_check_in(self):
return CheckIn(self.test_numeric_goal, self.test_tf, 30)
def test_get_timeframes(self):
with self.assertRaisesRegexp(AssertionError, "End must be after start"):
Timeframe.get_timeframes("yearly", datetime.datetime(2016, 1, 2), datetime.datetime(2016, 1, 1))
start = datetime.datetime(2016, 1, 1)
end = datetime.datetime(2017, 1, 1) ## Should not include intervals starting on this date / time
tfs = Timeframe.get_timeframes("daily", start, end)
self.assertEqual(len(tfs), 366)
for x in tfs:
self.assertEqual(x.frequency_name, "daily")
tfs = Timeframe.get_timeframes("weekly", start, end)
self.assertEqual(len(tfs), 53)
for x in tfs:
self.assertEqual(x.start.weekday(), 6)
self.assertEqual(x.frequency_name, "weekly")
tfs = Timeframe.get_timeframes("monthly", start, end)
self.assertEqual(len(tfs), 12)
for x in tfs:
self.assertEqual(x.start.day, 1)
self.assertEqual(x.end.day, 1)
self.assertEqual(x.frequency_name, "monthly")
tfs = Timeframe.get_timeframes("quarterly", start, end)
self.assertEqual(len(tfs), 4)
for x in tfs:
self.assertEqual(x.start.day, 1)
self.assertEqual(x.end.day, 1)
self.assertEqual(x.start.month % 3, 1)
self.assertEqual(x.end.month % 3, 1)
self.assertEqual(x.frequency_name, "quarterly")
tfs = Timeframe.get_timeframes("yearly", start, end)
self.assertEqual(len(tfs), 1)
for x in tfs:
self.assertEqual(x.start.day, 1)
self.assertEqual(x.end.day, 1)
self.assertEqual(x.start.month, 1)
self.assertEqual(x.end.month, 1)
self.assertEqual(x.frequency_name, "yearly")
end = datetime.datetime(2017, 1, 1, 1) ## Should include intervals starting on this date
tfs = Timeframe.get_timeframes("daily", start, end)
self.assertEqual(len(tfs), 367)
for x in tfs:
self.assertEqual(x.frequency_name, "daily")
tfs = Timeframe.get_timeframes("monthly", start, end)
self.assertEqual(len(tfs), 13)
for x in tfs:
self.assertEqual(x.start.day, 1)
self.assertEqual(x.end.day, 1)
self.assertEqual(x.frequency_name, "monthly")
tfs = Timeframe.get_timeframes("quarterly", start, end)
self.assertEqual(len(tfs), 5)
for x in tfs:
self.assertEqual(x.start.day, 1)
self.assertEqual(x.end.day, 1)
self.assertEqual(x.start.month % 3, 1)
self.assertEqual(x.end.month % 3, 1)
self.assertEqual(x.frequency_name, "quarterly")
