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