def test_group_by_weekday(self):
"""
Test if function is grouping by weekdays.
"""
data = utils.get_data()
expected = {
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: [],
}
expected_2 = {
0: [24123],
1: [16564],
2: [25321],
3: [22969, 22999],
4: [6426],
5: [],
6: [],
}
self.assertDictEqual(utils.group_by_weekday(data[10]), expected)
self.assertDictEqual(utils.group_by_weekday(data[11]), expected_2)
def test_group_by_weekday(self):
"""
Test weekday grouping
"""
data = utils.get_data()
weekdays = utils.group_by_weekday(data[10])
self.assertItemsEqual(weekdays.keys(), range(7))
self.assertDictEqual(weekdays, {
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: [],
})
weekdays = utils.group_by_weekday(data[11])
self.assertDictEqual(weekdays, {
0: [24123],
1: [16564],
2: [25321],
3: [22969, 22999],
4: [6426],
5: [],
6: [],
})
def test_group_start_end_incorrect_input(self):
"""
Test grouping starts and ends by weekday.
Incorrect input type.
"""
with self.assertRaises(TypeError):
utils.group_by_weekday({'first': 123, 'second': '123'})
def test_group_by_weekday(self):
"""
Test groups presence entries by weekday.
"""
data = {
datetime.date(2012, 7, 5):
{
'start': datetime.time(9, 8, 37),
'end': datetime.time(18, 17, 4)
}
}
tmp = utils.group_by_weekday(data)
self.assertIsInstance(tmp, list)
self.assertEqual(tmp, [[], [], [], [32907], [], [], []])
data[datetime.date(2012, 6, 27)] = {
'start': datetime.time(8, 31, 6),
'end': datetime.time(15, 15, 27)
}
tmp = utils.group_by_weekday(data)
self.assertEqual(tmp, [[], [], [24261], [32907], [], [], []])
data[datetime.date(2012, 12, 12)] = {
'start': datetime.time(12, 12, 12),
'end': datetime.time(12, 12, 13)
}
tmp = utils.group_by_weekday(data)
self.assertEqual(tmp, [[], [], [24261, 1], [32907], [], [], []])
def test_group_by_weekday(self):
"""
Test grouping presences by weekday.
"""
test_data = {
datetime.date(2017, 4, 18): {
'start': datetime.time(8, 15, 0),
'end': datetime.time(16, 0, 0),
},
datetime.date(2017, 4, 19): {
'start': datetime.time(13, 21, 30),
'end': datetime.time(15, 4, 2),
},
}
self.assertEqual([[], [27900], [6152], [], [], [], []],
utils.group_by_weekday(test_data))
# more dates for weekday 1 to test if they are counted
test_data[datetime.date(2017, 4, 25)] = {
'start': datetime.time(0, 0, 0),
'end': datetime.time(0, 0, 0),
}
test_data[datetime.date(2017, 4, 11)] = {
'start': datetime.time(8, 0, 0),
'end': datetime.time(16, 0, 0),
}
self.assertEqual(3, len(utils.group_by_weekday(test_data)[1]))
data = utils.get_data()
self.assertEqual([[], [30047], [24465], [23705], [], [], []],
utils.group_by_weekday(data[10]))
self.assertEqual(
[[24123], [16564], [25321], [22969, 22999], [6426], [], []],
utils.group_by_weekday(data[11]))
def test_group_by_weekday(self):
"""
Test groups precence entries by weekday
"""
box = utils.get_data()
data = utils.group_by_weekday(box[10])
self.assertIsInstance(data, dict)
sample_data = {
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: [],
}
self.assertDictEqual(data, sample_data)
data = utils.group_by_weekday(box[11])
self.assertIsInstance(data, dict)
sample_data = {
0: [24123],
1: [16564],
2: [25321],
3: [22969, 22999],
4: [6426],
5: [],
6: [],
}
self.assertDictEqual(data, sample_data)
def test_group_by_weekday(self):
"""
Test groups presence entries by weeekday.
"""
sample_data = utils.get_data()
result = utils.group_by_weekday(sample_data[10])
self.assertDictEqual({
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: [],
}, result)
self.assertIsInstance(utils.group_by_weekday(sample_data[11]), dict)
self.assertDictEqual({
0: [24123],
1: [16564],
2: [25321],
3: [22969, 22999],
4: [6426],
5: [],
6: [],
}, result)
def test_group_by_weekday(self):
"""
Test of group_by_weekday
"""
self.assertDictEqual(
utils.group_by_weekday(utils.get_data()[10]),
{
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: []
}
)
self.assertDictEqual(
utils.group_by_weekday(utils.get_data()[11]),
{
0: [24123],
1: [16564],
2: [25321],
3: [22969, 22999],
4: [6426],
5: [],
6: []
}
)
def test_group_by_weekday(self):
"""
Test groups precence entries by weekday
"""
box = utils.get_data()
data = utils.group_by_weekday(box[10])
self.assertIsInstance(data, dict)
sample_data = {
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: [],
}
self.assertDictEqual(data, sample_data)
data = utils.group_by_weekday(box[11])
self.assertIsInstance(data, dict)
sample_data = {
0: [24123],
1: [16564],
2: [25321],
3: [22969, 22999],
4: [6426],
5: [],
6: [],
}
self.assertDictEqual(data, sample_data)
def test_group_by_weekday(self):
"""
Testing groups presence entries by weekday
"""
import_data = utils.get_data()
# user_10
user_10 = utils.group_by_weekday(import_data[10])
self.assertEqual(user_10.keys(), range(7))
self.assertDictEqual(user_10, {
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: [],
})
# user_11
user_11 = utils.group_by_weekday(import_data[11])
self.assertEqual(user_11.keys(), range(7))
self.assertDictEqual(user_11, {
0: [24123],
1: [16564],
2: [25321],
3: [22969, 22999],
4: [6426],
5: [],
6: [],
})
def test_group_by_weekday(self):
sample_data = utils.get_data()
group_data = utils.group_by_weekday(sample_data[10])
self.assertEqual(group_data,
[[], [30047], [24465], [23705], [], [], []])
group_data = utils.group_by_weekday(sample_data[11])
self.assertEqual(
group_data,
[[24123], [16564], [25321], [22969, 22999], [6426], [], []])
def test_group_by_weekday(self):
sample_data = utils.get_data()
group_data = utils.group_by_weekday(sample_data[10])
self.assertEqual(
group_data, [[], [30047], [24465], [23705], [], [], []]
)
group_data = utils.group_by_weekday(sample_data[11])
self.assertEqual(
group_data,
[[24123], [16564], [25321], [22969, 22999], [6426], [], []]
)
def test_group_by_weekday(self):
"""
Test grouping user time by weekday.
"""
data = utils.get_data()
for user in data.itervalues():
current_user = utils.group_by_weekday(user)
self.assertIsInstance(current_user, dict, msg=str(user))
self.assertItemsEqual(current_user.keys(), range(7),
msg=str(user))
for item in current_user.itervalues():
self.assertIsInstance(item, list, msg=str(user))
sample_user = utils.group_by_weekday(data[10])
self.assertItemsEqual(sample_user[1], [30047])
def test_group_by_weekday(self):
"""
Test if function correctly groups by weekdays.
"""
data = utils.get_data()
test = {0: [], 1: [30047], 2: [24465], 3: [23705], 4: [], 5: [], 6: []}
self.assertDictEqual(utils.group_by_weekday(data[10]), test)
def test_group_by_weekday(self):
"""Test groups entries by weekday"""
data = utils.get_data()
result = utils.group_by_weekday(data[10])
self.assertEqual(len(result), 7)
self.assertIsInstance(result, dict)
self.assertIsInstance(result[2], list)
self.assertDictEqual(result, {
0: [],
1: [utils.interval
(data[10][datetime.date(2013, 9, 10)]['start'],
data[10][datetime.date(2013, 9, 10)]['end']
)
],
2: [utils.interval
(data[10][datetime.date(2013, 9, 11)]['start'],
data[10][datetime.date(2013, 9, 11)]['end']
)
],
3: [utils.interval
(data[10][datetime.date(2013, 9, 12)]['start'],
data[10][datetime.date(2013, 9, 12)]['end']
)
],
4: [],
5: [],
6: [],
}
)
self.assertEqual(len(result[3]), 1)
def test_group_by_weekday(self):
"""
Test if function correctly groups by weekdays.
"""
data = utils.get_data()
li = [[], [30047], [24465], [23705], [], [], []]
self.assertEqual(utils.group_by_weekday(data[10]), li)
def test_group_by_weekday(self):
"""
Test Group by weekday method.
"""
self.assertEqual(
utils.group_by_weekday({
datetime.date(2013, 9, 10): {
'start': datetime.time(9, 39, 5),
'end': datetime.time(17, 59, 52),
},
datetime.date(2013, 9, 12): {
'start': datetime.time(10, 48, 46),
'end': datetime.time(17, 23, 51),
},
datetime.date(2013, 9, 11): {
'start': datetime.time(9, 19, 52),
'end': datetime.time(16, 7, 37),
},
}), [
[],
[30047],
[24465],
[23705],
[],
[],
[],
])
def test_group_by_weekday(self):
"""
Test grouping dates by weekdays.
"""
data = utils.get_data()
weekdays = utils.group_by_weekday(data[10])
self.assertEqual(weekdays[0][0], 30927)
def test_group_by_weekday(self):
"""
Test groups presence entries by weekday.
"""
self.assertEqual(
utils.group_by_weekday(utils.get_data()[10]),
[[], [30047], [24465], [23705], [], [], []]
)
def test_group_by_weekday_list(self):
"""
Test grouping by weekday.
Checks if the result is a list.
"""
data = utils.get_data()
grouped_by_weekday = utils.group_by_weekday(data[10])
self.assertIsInstance(grouped_by_weekday, list)
def test_group_by_weekday(self):
data = utils.get_data()
result = utils.group_by_weekday(data[11])
self.assertEqual(result.keys(), range(7))
self.assertEqual(result[0], [24123])
self.assertEqual(result[1], [16564])
self.assertEqual(result[2], [25321])
self.assertEqual(result[3], [22969, 22999])
def test_group_by_weekday(self):
"""
Test group presence result by weekday
"""
weekdays = utils.group_by_weekday(utils.get_data()[10])
self.assertIsInstance(weekdays, list)
self.assertEqual(len(weekdays), 7)
self.assertEqual(weekdays[3], [23705])
def test_group_by_weekday(self):
"""
Test group by weekday
"""
data = utils.get_data()
weekdays = group_by_weekday(data[11])
self.assertEqual([24123], weekdays[0])
self.assertEqual([22969, 22999], weekdays[3])
def test_group_by_weekday(self):
"""
test if grouping is right
"""
user_id = 11
data = utils.get_data()
groups = [[24123], [16564], [25321], [22969, 22999], [6426], [], []]
self.assertListEqual(groups, utils.group_by_weekday(data[user_id]))
def test_group_by_weekday(self):
"""
Test group_by_weekday.
"""
testData = {
'testUser1': {
datetime.date(2013, 1, 1): {
'start': datetime.time(6, 0, 0),
'end': datetime.time(17, 00, 0),
},
datetime.date(2013, 10, 2): {
'start': datetime.time(8, 30, 0),
'end': datetime.time(16, 00, 0),
}
},
'testUser2': {
datetime.date(2013, 9, 22): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(17, 30, 0),
},
datetime.date(2013, 9, 26): {
'start': datetime.time(8, 30, 0),
'end': datetime.time(16, 30, 0),
},
datetime.date(2012, 9, 26): {
'start': datetime.time(8, 30, 0),
'end': datetime.time(16, 30, 0),
}
},
'testUser3': {}
}
testResult = utils.group_by_weekday(testData['testUser1'])
testResult2 = utils.group_by_weekday(testData['testUser2'])
testResult3 = utils.group_by_weekday(testData['testUser3'])
self.assertListEqual(
testResult, [[], [39600], [27000], [], [], [], []]
)
self.assertListEqual(
testResult2, [[], [], [28800], [28800], [], [], [30600]]
)
self.assertListEqual(
testResult3, [[], [], [], [], [], [], []]
)
def test_group_by_weekday(self):
"""
Test group presence entries by weekday
"""
data = utils.get_data()
result = utils.group_by_weekday(data[10])
self.assertEqual(result[2][0], 24465)
self.assertEqual(result[3][0], 23705)
self.assertIsInstance(result, list)
def test_group_by_weekday(self):
"""
Test grouping results by weekday.
"""
items = utils.get_data()
results = utils.group_by_weekday(items[10])
self.assertIsInstance(results, list)
self.assertEqual(results[0], [])
self.assertEqual(len(results[1]), 1)
def test_group_by_weekday(self):
"""
Test grouping of entries.
"""
data = utils.get_data()
result_from_function = utils.group_by_weekday(data[10])
self.assertEqual(result_from_function,
[[], [30047], [24465], [23705], [], [], []])
def test_mean(self):
"""
Test calculating arithmetic mean.
"""
data = utils.get_data()
weekdays = utils.group_by_weekday(data[10])
self.assertAlmostEqual(utils.mean(weekdays[0]), 29934)
self.assertEqual(utils.mean(weekdays[7]), 0)
self.assertEqual(utils.mean([]), 0)
self.assertEqual(utils.mean([0]), 0)
def test_group_by_weekday(self):
"""
Test grouping presence entries by weekday.
"""
data = utils.get_data()
result = utils.group_by_weekday(data[10])
self.assertIsInstance(result, dict)
self.assertItemsEqual(result.keys(), range(7))
self.assertItemsEqual(result[2], [24465])
self.assertItemsEqual(result[6], [])
def test_group_by_weekend(self):
'''
Test group presence entries by weekday.
'''
data = utils.get_data()
group_data = utils.group_by_weekday(data[10])
self.assertIsInstance(group_data, dict)
self.assertItemsEqual(group_data.keys(), [0, 1, 2, 3, 4, 5, 6])
self.assertListEqual(group_data[5], [])
self.assertIn(30047.0, group_data[1])
def test_group_by_weekday(self):
"""
Groups entries by weekday.
"""
sample_data = utils.get_data()
result = utils.group_by_weekday(sample_data[10])
self.assertListEqual(
result,
[[], [30047], [24465], [23705], [], [], []]
)
def test_group_by_weekday(self):
"""
Test grouping presence entries by weekday.
"""
data = utils.get_data()
weekdays = utils.group_by_weekday(data[10])
self.assertIsInstance(weekdays, dict)
self.assertEqual(len(weekdays), 7)
self.assertItemsEqual(weekdays.keys(), [i for i in range(7)])
self.assertIn([30047], weekdays.values())
def mean_time_weekday_view(user_id):
"""Returns mean presence time of given user grouped by weekday."""
data = get_data()
if user_id not in data:
log.debug('User {0} not found!'.format(user_id))
return []
weekdays = group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], mean(intervals))
for weekday, intervals in weekdays.items()]
return result
def mean_time_weekday_view(user_id):
"""Returns mean presence time of given user grouped by weekday."""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
weekdays = group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], mean(intervals))
for weekday, intervals in enumerate(weekdays)]
return result
def test_group_by_weekday(self):
"""
Test groups presence entris by weekday
"""
sample_data = utils.get_data()
grouped_sample = utils.group_by_weekday(sample_data[10])
expected_result_for_empty_dict = {i: [] for i in range(7)}
expected_result_for_grouped_sample = {
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: []
}
self.assertEqual(len(grouped_sample), 7)
self.assertIsInstance(grouped_sample, dict)
self.assertEqual(
utils.group_by_weekday({}), expected_result_for_empty_dict)
self.assertEqual(grouped_sample, expected_result_for_grouped_sample)
def test_group_by_weekly(self):
"""
Test group_by_weekday function
"""
empty_items = []
items = {
datetime.date(2013, 9, 11): {
'end': datetime.time(16, 15, 27),
'start': datetime.time(9, 13, 26)
},
datetime.date(2013, 9, 12): {
'end': datetime.time(16, 41, 25),
'start': datetime.time(10, 18, 36)
}
}
result_1 = utils.group_by_weekday(items)
result_2 = utils.group_by_weekday(empty_items)
expected_result_1 = {
0: [],
1: [],
2: [25321],
3: [22969],
4: [],
5: [],
6: [],
}
expected_result_2 = {
0: [],
1: [],
2: [],
3: [],
4: [],
5: [],
6: [],
}
self.assertDictEqual(result_1, expected_result_1)
self.assertDictEqual(result_2, expected_result_2)
def presence_weekday_view(user_id):
"""Returns total presence time of given user grouped by weekday."""
data = get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
abort(404)
weekdays = group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], sum(intervals))
for weekday, intervals in enumerate(weekdays)]
result.insert(0, ('Weekday', 'Presence (s)'))
return result
def mean_time_weekday_view(user_id):
"""
Returns mean presence time of given user grouped by weekday.
"""
data = get_data()
if user_id not in data:
log.debug("User %s not found!", user_id)
abort(404)
weekdays = group_by_weekday(data[user_id])
result = [(weekday_abbr(weekday), mean(intervals)) for weekday, intervals in enumerate(weekdays)]
return result
def presence_weekday_view(user_id):
"""Returns total presence time of given user grouped by weekday."""
data = get_data()
if user_id not in data:
log.debug('User {0} not found!'.format(user_id))
return []
weekdays = group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], sum(intervals))
for weekday, intervals in weekdays.items()]
result.insert(0, ('Weekday', 'Presence (s)'))
return result
def test_group_by_weekday(self):
"""
Test group by weekday utility.
"""
test_data = {
datetime.date(2013, 9, 10): {
'start': datetime.time(10, 0, 0),
'end': datetime.time(11, 0, 0)
}
}
data = utils.group_by_weekday(test_data)
self.assertEqual(len(data), 7)
self.assertListEqual(data, [[], [3600], [], [], [], [], []])
def test_group_by_weekly(self):
"""
Test group_by_weekday function
"""
empty_items = []
items = {
datetime.date(2013, 9, 11): {
'end': datetime.time(16, 15, 27),
'start': datetime.time(9, 13, 26)
},
datetime.date(2013, 9, 12): {
'end': datetime.time(16, 41, 25),
'start': datetime.time(10, 18, 36)
}}
result_1 = utils.group_by_weekday(items)
result_2 = utils.group_by_weekday(empty_items)
expected_result_1 = {
0: [],
1: [],
2: [25321],
3: [22969],
4: [],
5: [],
6: [],
}
expected_result_2 = {
0: [],
1: [],
2: [],
3: [],
4: [],
5: [],
6: [],
}
self.assertDictEqual(result_1, expected_result_1)
self.assertDictEqual(result_2, expected_result_2)
def mean_time_weekday_view(user_id):
"""
Returns mean presence time of given user grouped by weekday.
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = utils.group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], utils.mean(intervals))
for weekday, intervals in weekdays.items()]
return result
def test_mean_time_weekday_view(self):
"""
Test json response for user 10.
"""
response = self.client.get('/api/v1/mean_time_weekday/10')
data = json.loads(response.data)
weekdays = utils.group_by_weekday(utils.get_data()[10])
expected_data = [[calendar.day_abbr[weekday],
utils.mean(intervals)]
for weekday, intervals in enumerate(weekdays)]
self.assertEqual(response.status_code, 200)
self.assertEqual(expected_data, data)
def mean_time_weekday_json_view(user_id=None):
"""
Returns mean presence time of given user grouped by weekday.
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return {'success': False, 'data': []}
weekdays = utils.group_by_weekday(data[user_id])
result = [(calendar.day_abbr[weekday], utils.mean(intervals))
for weekday, intervals in enumerate(weekdays)]
return {'success': True, 'data': result}
def presence_weekday_view(user_id):
"""
Returns total presence time of given user grouped by weekday.
"""
data = utils.get_data()
if user_id not in data:
log.debug('User %s not found!', user_id)
return []
weekdays = utils.group_by_weekday(data[user_id]['times'])
result = [(calendar.day_abbr[weekday], sum(intervals))
for weekday, intervals in weekdays.items()]
result.insert(0, ('Weekday', 'Presence (s)'))
return result
def test_group_by_weekday(self):
"""
Test grouping presence entries by weekday.
"""
data = utils.get_data()
grouped_by_weekday = utils.group_by_weekday(data[11])
self.assertEqual(grouped_by_weekday, [
[24123],
[16564],
[25321],
[22969, 22999],
[6426],
[],
[],
])
def test_group_by_weekday(self):
"""
Enter sample data and check whether group serves it correctly.
"""
data = {
datetime.date(2017, 4, 9): {
'start': datetime.time(12, 0, 0),
'end': datetime.time(13, 0, 0)
}
}
expected_data = [[], [], [], [], [], [], [3600]]
data = utils.group_by_weekday(data)
self.assertEqual(data, expected_data)
def test_presence_weekday_view(self):
"""
Test json response for user 10.
"""
response = self.client.get('/api/v1/presence_weekday/10')
data = json.loads(response.data)
weekdays = utils.group_by_weekday(utils.get_data()[10])
expected_data = [[calendar.day_abbr[weekday],
sum(intervals)]
for weekday, intervals in enumerate(weekdays)]
expected_data.insert(0, ['Weekday', 'Presence (s)'])
self.assertEqual(response.status_code, 200)
self.assertEqual(expected_data, data)
def test_group_by_weekday(self):
"""
Test grouping presence entries by weekday.
"""
sample_data = {
datetime.date(2015, 4, 7): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(17, 30, 0),
},
datetime.date(2015, 4, 8): {
'start': datetime.time(8, 30, 0),
'end': datetime.time(9, 0, 0),
},
}
grouping = utils.group_by_weekday(sample_data)
self.assertEqual(grouping, [[], [30600], [1800], [], [], [], []])
def test_group_by_weekday(self):
"""
Test grouping by weekdays
"""
self.assertDictEqual(
utils.group_by_weekday(utils.get_data()[10]),
{
0: [],
1: [30047],
2: [24465],
3: [23705],
4: [],
5: [],
6: [],
},
)
def test_group_by_weekday(self):
"""
Test groups presence entries by weekday.
"""
sample_week = {
datetime.date(2015, 2, 2): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(17, 0, 0)
},
datetime.date(2015, 2, 3): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(17, 0, 0)
},
datetime.date(2015, 2, 4): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(17, 0, 0)
},
datetime.date(2015, 2, 5): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(17, 0, 0)
},
datetime.date(2015, 2, 6): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(17, 0, 0)
},
datetime.date(2015, 2, 7): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(12, 0, 0)
},
datetime.date(2015, 2, 8): {
'start': datetime.time(9, 0, 0),
'end': datetime.time(10, 0, 0)
},
}
result = utils.group_by_weekday(sample_week)
self.assertIsInstance(result, list)
self.assertItemsEqual(
result,
[[28800], [28800], [28800], [28800], [28800], [10800], [3600]])
def test_group_by_weekday(self):
"""
Test grouping working time by weekdays.
"""
data = {
datetime.date(2016, 10, 17): {
'start': datetime.time(8, 0, 0),
'end': datetime.time(16, 0, 0),
},
datetime.date(2016, 10, 20): {
'start': datetime.time(9, 30, 0),
'end': datetime.time(17, 45, 0),
},
datetime.date(2016, 10, 21): {
'start': datetime.time(8, 30, 0),
'end': datetime.time(9, 0, 0),
},
datetime.date(2016, 10, 24): {
'start': datetime.time(8, 30, 0),
'end': datetime.time(9, 30, 0),
},
}
self.assertEqual(utils.group_by_weekday(data),
[[28800, 3600], [], [], [29700], [1800], [], []])
def test_group_by_weekday(self):
"""Test groups presence entries by weekday."""
data = utils.get_data()
proper_data = [[], [30047], [24465], [23705], [], [], []]
self.assertEqual(utils.group_by_weekday(data[10]), proper_data)
