def test_containment_to_overlap(self): """compare for containment to an overlapping range.""" taa = self._strp("2010-01-01 12:00") tbb = self._strp("2010-09-01 12:00") range1 = TimeRange(taa, tbb) tcc = self._strp("2010-06-01 12:00") tdd = self._strp("2010-12-01 12:00") range2 = TimeRange(tcc, tdd) self.assertFalse(range1.contains(range2))
def test_contain_complete_contain(self): """compare for containment to a completely contained range.""" taa = self._strp("2010-01-01 12:00") tbb = self._strp("2010-09-01 12:00") range1 = TimeRange(taa, tbb) tcc = self._strp("2010-03-01 12:00") tdd = self._strp("2010-06-01 12:00") range2 = TimeRange(tcc, tdd) self.assertTrue(range1.contains(range2))
def test_non_intersection(self): """compare if the ranges don't intersect.""" # Two non-overlapping ranges: intersect() returns undefined begin_time = self._strp("2010-01-01 12:00") end_time = self._strp("2010-06-01 12:00") range1 = TimeRange(begin_time, end_time) begin_time_outside = self._strp("2010-07-15 12:00") end_time_outside = self._strp("2010-08-15 12:00") range_outside = TimeRange(begin_time_outside, end_time_outside) self.assertIsNone(range1.intersection(range_outside))
def test_overlap_non_overlap(self): """compare overlap to a non-overlapping range""" taa = self._strp("2010-01-01 12:00") tbb = self._strp("2010-02-01 12:00") range1 = TimeRange(taa, tbb) tcc = self._strp("2010-03-01 12:00") tdd = self._strp("2010-04-01 12:00") range2 = TimeRange(tcc, tdd) self.assertFalse(range1.overlaps(range2)) self.assertFalse(range2.overlaps(range1))
def test_within(self): """test within() test.""" taa = self._strp("2010-06-01 12:00") tbb = self._strp("2010-07-01 12:00") range1 = TimeRange(taa, tbb) tcc = self._strp("2010-05-01 12:00") tdd = self._strp("2010-08-01 12:00") range2 = TimeRange(tcc, tdd) self.assertTrue(range1.within(range2)) self.assertFalse(range2.within(range1))
def test_overlap_overlap(self): """compare overlap to an overlapping range""" taa = self._strp("2010-01-01 12:00") tbb = self._strp("2010-09-01 12:00") range1 = TimeRange(taa, tbb) tcc = self._strp("2010-08-01 12:00") tdd = self._strp("2010-11-01 12:00") range2 = TimeRange(tcc, tdd) self.assertTrue(range1.overlaps(range2)) self.assertTrue(range2.overlaps(range1))
def test_extents(self): """test extents() factory.""" taa = self._strp("2010-05-01 12:00") tbb = self._strp("2010-07-01 12:00") range1 = TimeRange(taa, tbb) tcc = self._strp("2010-06-01 12:00") tdd = self._strp("2010-08-01 12:00") range2 = TimeRange(tcc, tdd) range_ext = range1.extents(range2) self.assertTrue(range_ext.begin(), taa) self.assertTrue(range_ext.end(), tdd)
def test_human_friendly_strings(self): """test human friendly outputs.""" rang = TimeRange(EPOCH, EPOCH + datetime.timedelta(hours=24)) # Hmmm, this is going to vary depending on where it is run. # self.assertEqual(rang.humanize(), 'Dec 31, 1969 04:00:00 PM to Jan 1, 1970 04:00:00 PM') rang = TimeRange.last_day() self.assertEqual(rang.relative_string(), 'a day ago to now') rang = TimeRange.last_seven_days() # due to the using UTC offsets, this date can appear to be either 6, 7, or 8 days ago # 6 for negative offsets, 7 for UTC, 8 for positive offsets # unless the local machine clock _happens_ to be set to UTC. self.assertTrue(rang.relative_string( ) in ['7 days ago to now', '6 days ago to now', '8 days ago to now']) rang = TimeRange.last_thirty_days() # this can return ambiguous results # self.assertEqual(rang.relative_string(), '30 days ago to now') rang = TimeRange.last_month() # this can return ambiguous results - might be 30 days ago, or a month ago # self.assertEqual(rang.relative_string(), 'a month ago to now') rang = TimeRange.last_ninety_days() self.assertEqual(rang.relative_string(), '2 months ago to now')
def test_new_from_surround(self): """new range if one range surrounds another.""" # One range fully inside the other intersect() returns the smaller range # 01 -------06 range # 02--04 rangeInside # 02--04 intersection begin_time = self._strp("2010-01-01 12:00") end_time = self._strp("2010-06-01 12:00") range1 = TimeRange(begin_time, end_time) begin_time_inside = self._strp("2010-02-01 12:00") end_time_inside = self._strp("2010-04-01 12:00") range_inside = TimeRange(begin_time_inside, end_time_inside) self.assertTrue(range1.intersection(range_inside).equals(range_inside)) self.assertTrue(range_inside.intersection(range1).equals(range_inside))
def test_equality(self): """compare time ranges to check equality.""" taa = self._strp("2010-01-01 12:00") tbb = self._strp("2010-02-01 12:00") range1 = TimeRange(taa, tbb) tcc = self._strp("2010-01-01 12:00") tdd = self._strp("2010-02-01 12:00") range2 = TimeRange(tcc, tdd) tee = self._strp("2012-03-01 12:00") tff = self._strp("2012-04-02 12:00") range3 = TimeRange(tee, tff) self.assertTrue(range1.equals(range2)) self.assertFalse(range1.equals(range3))
def test_copy_ctor(self): """test using the copy constructor.""" orig = self.canned_range new_range = TimeRange(orig) self.assertTrue(orig.equals(new_range)) # tests all timestamps
def setUp(self): super(TestConverter, self).setUp() self._event = Event(dt_from_ms(1426316400000), 3) self._tre = TimeRangeEvent(TimeRange([1426316400000, 1426320000000]), 3) self._idxe = IndexedEvent("1h-396199", 3)
def test_get_index_string_list(self): """ test get_index_string_list - 2 dt-> timerange -> idx_list Used to be: const d1 = Date.UTC(2015, 2, 14, 7, 30, 0); const d2 = Date.UTC(2015, 2, 14, 8, 29, 59); it("should have the correct index list for a date range", done => { const bucketList = generator.bucketList(d1, d2); const expectedBegin = "5m-4754394"; const expectedEnd = "5m-4754405"; // _.each(bucketList, (b) => { // console.log(" -", b.index().asString(), b.index().asTimerange().humanize()) // }) expect(bucketList.length).to.equal(12); Zero based month in play again. """ dtime_1 = aware_dt_from_args( dict(year=2015, month=3, day=14, hour=7, minute=30, second=0)) dtime_2 = aware_dt_from_args( dict(year=2015, month=3, day=14, hour=8, minute=29, second=59)) idx_list = Index.get_index_string_list('5m', TimeRange(dtime_1, dtime_2)) self.assertEqual(len(idx_list), 12) self.assertEqual(idx_list[0], '5m-4754394') self.assertEqual(idx_list[-1], '5m-4754405')
def test_new_from_intersection(self): """new range if the ranges intersect.""" # Two overlapping ranges: intersect() returns # 01 -------06 range # 05-----07 rangeOverlap # 05-06 intersection begin_time = self._strp("2010-01-01 12:00") end_time = self._strp("2010-06-01 12:00") range1 = TimeRange(begin_time, end_time) begin_time_overlap = self._strp("2010-05-01 12:00") end_time_overlap = self._strp("2010-07-01 12:00") range_overlap = TimeRange(begin_time_overlap, end_time_overlap) expected = TimeRange(begin_time_overlap, end_time) self.assertTrue(range1.intersection(range_overlap).equals(expected))
def test_compare_before_time(self): """compare to a time before the range.""" taa = self._strp("2010-06-01 12:00") tbb = self._strp("2010-08-01 12:00") range1 = TimeRange(taa, tbb) before = self._strp("2010-01-15 12:00") self.assertFalse(range1.contains(before))
def test_compare_during_range(self): """compare to a time during the time.""" taa = self._strp("2010-06-01 12:00") tbb = self._strp("2010-08-01 12:00") range1 = TimeRange(taa, tbb) during = self._strp("2010-07-15 12:00") self.assertTrue(range1.contains(during))
def test_compare_after_range(self): """compare to a time after the range.""" taa = self._strp("2010-06-01 12:00") tbb = self._strp("2010-08-01 12:00") range1 = TimeRange(taa, tbb) after = self._strp("2010-12-15 12:00") self.assertFalse(range1.contains(after))
def test_invalid_constructor_args(self): """test invalid constructor args""" # test both (two, args) and ([list, arg]) inputs to work different logic # unaware datetime input u_begin = datetime.datetime.utcnow() - datetime.timedelta(hours=12) u_end = datetime.datetime.utcnow() with self.assertRaises(TimeRangeException): self._create_time_range(u_begin, u_end) with self.assertRaises(TimeRangeException): self._create_time_range([u_begin, u_end]) # invalid types - pass in floats end = time.time() * 1000 begin = end - 10000 with self.assertRaises(TimeRangeException): self._create_time_range(begin, end) with self.assertRaises(TimeRangeException): self._create_time_range([begin, end]) # type mismatch with self.assertRaises(TimeRangeException): self._create_time_range((int(begin), aware_utcnow())) with self.assertRaises(TimeRangeException): self._create_time_range(int(begin), aware_utcnow()) with self.assertRaises(TimeRangeException): self._create_time_range( [aware_utcnow() - datetime.timedelta(hours=12), int(end)]) with self.assertRaises(TimeRangeException): self._create_time_range( aware_utcnow() - datetime.timedelta(hours=12), int(end)) # end time before begin time bad_begin = aware_utcnow() bad_end = aware_utcnow() - datetime.timedelta(hours=12) with self.assertRaises(TimeRangeException): self._create_time_range(bad_begin, bad_end) with self.assertRaises(TimeRangeException): self._create_time_range([bad_begin, bad_end]) with self.assertRaises(TimeRangeException): self._create_time_range(ms_from_dt(bad_begin), ms_from_dt(bad_end)) with self.assertRaises(TimeRangeException): self._create_time_range( (ms_from_dt(bad_begin), ms_from_dt(bad_end))) # wrong number of args with self.assertRaises(TimeRangeException): TimeRange((begin, end, end))
def test_time_range_event_merge(self): """Test merging.""" t_range = TimeRange(self.test_begin_ts, self.test_end_ts) tr1 = TimeRangeEvent(t_range, dict(a=5, b=6)) tr2 = TimeRangeEvent(t_range, dict(c=2)) merged = Event.merge([tr1, tr2]) self.assertEqual(merged[0].get('a'), 5) self.assertEqual(merged[0].get('b'), 6) self.assertEqual(merged[0].get('c'), 2)
def test_at_key_and_dedup(self): """test Collection.at_key() and dedup()""" # events coll = Collection(EVENT_LIST_DUP) key_time = dt_from_ms(1429673460000) find = coll.at_key(key_time) self.assertEqual(len(find), 2) self.assertEqual(find[0].get('in'), 3) self.assertEqual(find[1].get('in'), 4) ddcoll = coll.dedup() self.assertEqual(ddcoll.size(), 3) self.assertEqual(ddcoll.at(1).get('in'), 4) # the second dup event # indexed events coll = Collection(IDX_EVENT_DUP) find = coll.at_key('1d-12355') self.assertEqual(len(find), 2) self.assertEqual(find[0].get('value'), 43) self.assertEqual(find[1].get('value'), 44) ddcoll = coll.dedup() self.assertEqual(ddcoll.size(), 3) self.assertEqual(ddcoll.at(1).get('value'), 44) # the second dup event # time range events test_end_ts = aware_utcnow() test_begin_ts = test_end_ts - datetime.timedelta(hours=12) test_end_ms = ms_from_dt(test_end_ts) test_begin_ms = ms_from_dt(test_begin_ts) dup_tre = [ TimeRangeEvent((test_begin_ms, test_end_ms), 11), TimeRangeEvent((test_begin_ms + 60000, test_end_ms + 60000), 12), TimeRangeEvent((test_begin_ms + 60000, test_end_ms + 60000), 13), TimeRangeEvent((test_begin_ms + 120000, test_end_ms + 120000), 14), ] coll = Collection(dup_tre) search = TimeRange(test_begin_ms + 60000, test_end_ms + 60000) find = coll.at_key(search) self.assertEqual(len(find), 2) self.assertEqual(find[0].get('value'), 12) self.assertEqual(find[1].get('value'), 13) ddcoll = coll.dedup() self.assertEqual(ddcoll.size(), 3) self.assertEqual(ddcoll.at(1).get('value'), 13) # the second dup event
def test_cropping(self): """test TimeSeries.crop()""" crop_data = dict(name="star-cr5:to_anl_ip-a_v4", columns=["time", "in"], points=[ [1400425947000, 52], [1400425948000, 18], [1400425949000, 26], [1400425950000, 93], [1400425951000, 99], [1400425952000, 100], ]) series = TimeSeries(crop_data) new_range = TimeRange(1400425948000, 1400425951000) new_series = series.crop(new_range) self.assertEqual(new_series.size(), 3) self.assertEqual(new_series.at(0).data().get('in'), 18) self.assertEqual(new_series.at(2).data().get('in'), 93)
def test_human_friendly_strings(self): """test human friendly outputs.""" rang = TimeRange(EPOCH, EPOCH + datetime.timedelta(hours=24)) # Hmmm, this is going to vary depending on where it is run. # self.assertEqual(rang.humanize(), 'Dec 31, 1969 04:00:00 PM to Jan 1, 1970 04:00:00 PM') rang = TimeRange.last_day() self.assertEqual(rang.relative_string(), 'a day ago to now') rang = TimeRange.last_seven_days() self.assertEqual(rang.relative_string(), '7 days ago to now') rang = TimeRange.last_thirty_days() # this can return ambiguous results # self.assertEqual(rang.relative_string(), '30 days ago to now') rang = TimeRange.last_month() # this can return ambiguous results - might be 30 days ago, or a month ago # self.assertEqual(rang.relative_string(), 'a month ago to now') rang = TimeRange.last_ninety_days() self.assertEqual(rang.relative_string(), '2 months ago to now')
def test_unrounded_dt_sanitize(self): """datetime w/ microsecond accuracy being rounded to milliseconds internally""" def get_unrounded_dt(): """make sure the dt object is at microsecond accuracy.""" dtime = datetime.datetime.utcnow().replace(tzinfo=pytz.UTC) if dtime.microsecond % 1000 != 0: return dtime else: # this is unlikely return get_unrounded_dt() unrounded_start = get_unrounded_dt() - datetime.timedelta(hours=1) unrounded_end = get_unrounded_dt() internal_round = TimeRange(unrounded_start, unrounded_end) # will not be equal due to internal rounding to ms self.assertNotEqual(internal_round.begin(), unrounded_start) self.assertNotEqual(internal_round.end(), unrounded_end) # use utility rounding function self.assertEqual(internal_round.begin(), to_milliseconds(unrounded_start)) self.assertEqual(internal_round.end(), to_milliseconds(unrounded_end))
def _create_time_range(self, arg1, arg2=None): # pylint: disable=no-self-use """create a time range object""" return TimeRange(arg1, arg2)