Esempio n. 1
0
 def test_weekday_filter(self):
     records = [
         Record("test_itr", "in", "1", datetime.datetime(2014, 8, 22), 1, Position()),
         Record("test_itr", "in", "1", datetime.datetime(2014, 8, 31), 1, Position()),
         Record("test_itr", "in", "1", datetime.datetime(2014, 10, 18), 1, Position())
     ]
     user = bc.User()
     user.records = records
     filtered_records = bc.helper.group.filter_user(user, part_of_week='weekday')
     self.assertEqual(filtered_records, [records[0]])
Esempio n. 2
0
 def test_weekend_filter(self):
     records = [
         Record("test_itr", "in", "1", dt(2014, 8, 22), 1, Position()),
         Record("test_itr", "in", "1", dt(2014, 8, 31), 1, Position()),
         Record("test_itr", "in", "1", dt(2014, 10, 18), 1, Position())
     ]
     user = bc.User()
     user.records = records
     rv = bc.helper.group.filter_user(user, part_of_week='weekend')
     self.assertEqual(rv, [records[1], records[2]])
Esempio n. 3
0
    def test_weekend_group(self):
        records = [
            Record("test_itr", "in", "1", datetime.datetime(2014, 8, 23), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 8, 31), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 10, 18), 1, Position())
        ]
        user = bc.User()
        user.records = records

        grouping = bc.helper.group.group_records(user, groupby='week', part_of_week='weekend')
        groups = [[r for r in l] for l in grouping]
        self.assertEqual(groups, [[records[0]], [records[1]], [records[2]]])
Esempio n. 4
0
    def test_weekly_group(self):
        records = [
            Record("test_itr", "in", "1", dt(2014, 8, 24), 1, Position()),
            Record("test_itr", "in", "1", dt(2014, 9, 4), 1, Position()),
            Record("test_itr", "in", "1", dt(2014, 9, 11), 1, Position())
        ]
        user = bc.User()
        user.records = records

        grouping = bc.helper.group.group_records(user.records, groupby='week')
        groups = [[r for r in l] for l in grouping]
        self.assertEqual(groups, [[records[0]], [records[1]], [records[2]]])
Esempio n. 5
0
    def test_none_group(self):
        records = [
            Record("call", "in", "1", datetime.datetime(2014, 9, 4), 1, Position()),
            Record("call", "in", "1", datetime.datetime(2014, 9, 5), 1, Position()),
            Record("call", "in", "1", datetime.datetime(2014, 9, 11), 1, Position()),
            Record("call", "in", "1", datetime.datetime(2014, 9, 12), 1, Position())
        ]
        user = bc.User()
        user.records = records

        grouping = bc.helper.group.group_records(user, groupby=None)
        self.assertEqual(records, list(next(grouping)))
        self.assertRaises(StopIteration, grouping.next)
Esempio n. 6
0
    def test_daily_filter(self):
        records = [
            Record("test_itr", "in", "1", datetime.datetime(2014, 8, 22, 10, 00), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 8, 23, 10, 00), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 9, 7, 11, 00), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 10, 18, 2, 00), 1, Position())
        ]
        user = bc.User()
        user.records = records

        filtered_records = bc.helper.group.filter_user(user, part_of_day='night')
        self.assertEqual(filtered_records, [records[3]])

        filtered_records = bc.helper.group.filter_user(user, part_of_day='day')
        self.assertEqual(filtered_records, [records[0], records[1], records[2]])
Esempio n. 7
0
    def test_daily_group(self):
        records = [
            Record("test_itr", "in", "1", datetime.datetime(2014, 8, 22, 10, 00), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 8, 23, 10, 00), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 9, 7, 11, 00), 1, Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 10, 18, 2, 00), 1, Position())
        ]
        user = bc.User()
        user.records = records

        grouping = bc.helper.group.group_records(user, groupby='week', part_of_day='night')
        groups = [[r for r in l] for l in grouping]
        self.assertEqual(groups, [[records[3]]])

        grouping = bc.helper.group.group_records(user, groupby='week', part_of_day='day')
        groups = [[r for r in l] for l in grouping]
        self.assertEqual(groups, [[records[0], records[1]], [records[2]]])
Esempio n. 8
0
    def setUp(self):
        if not getattr(TestRegressions, '_dir_changed', False):
            abspath = os.path.abspath(__file__)
            name = abspath.index(os.path.basename(__file__))
            abspath = abspath[:name]
            os.chdir(abspath)
            TestRegressions._dir_changed = True

        self.empty_user = bc.User()
        self.empty_user.attributes['empty'] = True
        self.sample_user = bc.tests.generate_user.sample_user()
        self.network_ego = bc.read_csv('ego',
                                       'samples/network',
                                       'samples/towers.csv',
                                       attributes_path='samples/attributes',
                                       network=True,
                                       warnings=False,
                                       describe=False)

        # Manual users
        self.user_a = bc.read_csv('A',
                                  'samples/manual',
                                  'samples/towers.csv',
                                  network=False,
                                  warnings=False,
                                  describe=False)
        self.user_a_network = bc.read_csv('A',
                                          'samples/manual',
                                          'samples/towers.csv',
                                          attributes_path='samples/attributes',
                                          network=True,
                                          warnings=False,
                                          describe=False)
        self.user_a_orange = bc.io.read_orange('A_orange',
                                               'samples/manual',
                                               network=False,
                                               warnings=False,
                                               describe=False)
        self.user_a_orange_network = bc.io.read_orange(
            'A_orange',
            'samples/manual',
            network=True,
            attributes_path='samples/attributes',
            warnings=False,
            describe=False)
Esempio n. 9
0
    def setUp(self):
        if not TestCore._dir_changed:
            abspath = os.path.abspath(__file__)
            name = abspath.index(os.path.basename(__file__))
            abspath = abspath[:name]
            os.chdir(abspath)
            TestCore._dir_changed = True

        self.user = bc.io.read_orange("samples/u_test.csv", describe=False)

        self.empty_user = bc.User()
        self.empty_user.attributes['empty'] = True

        self.user_nocturnal = bc.io.read_orange("samples/u_test.csv", describe=False)
        self.user_nocturnal.night_start = datetime.time(7, 0)
        self.user_nocturnal.night_end = datetime.time(19, 0)

        self.maxDiff = None
Esempio n. 10
0
    def test_weekly_group(self):
        records = [
            Record("test_itr", "in", "1", datetime.datetime(2014, 8, 24), 1,
                   Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 9, 4), 1,
                   Position()),
            Record("test_itr", "in", "1", datetime.datetime(2014, 9, 11), 1,
                   Position())
        ]
        user = bc.User()
        user.records = records

        grouping = bc.helper.group.group_records(user, groupby='week')
        record = grouping.next()
        self.assertTrue(record.next().datetime, records[0].datetime)
        record = grouping.next()
        self.assertTrue(record.next().datetime, records[1].datetime)
        record = grouping.next()
        self.assertTrue(record.next().datetime, records[2].datetime)
Esempio n. 11
0
    def test_none_group(self):
        records = [
            Record("call", "in", "1", datetime.datetime(2014, 9, 5), 1,
                   Position()),
            Record("call", "in", "1", datetime.datetime(2014, 9, 4), 1,
                   Position()),
            Record("call", "in", "1", datetime.datetime(2014, 9, 11), 1,
                   Position()),
            Record("call", "in", "1", datetime.datetime(2014, 9, 12), 1,
                   Position())
        ]
        user = bc.User()
        user.records = records

        grouping = bc.helper.group.group_records(user, groupby=None)
        record = grouping.next()
        self.assertTrue(record.next().datetime, records[0].datetime)
        self.assertTrue(record.next().datetime, records[1].datetime)
        self.assertTrue(record.next().datetime, records[2].datetime)
        self.assertTrue(record.next().datetime, records[3].datetime)
        self.assertRaises(StopIteration, record.next)
        self.assertRaises(StopIteration, grouping.next)
Esempio n. 12
0
 def setUp(self):
     self.user = bc.User()
     self.user.records = random_burst(100, delta=timedelta(days=2))
Esempio n. 13
0
 def setUp(self):
     self.user = bc.User()