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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 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_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_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_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_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 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_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_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_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 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_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_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_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_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_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 test_awareness_check(self):
"""work the duck typing failover in the awareness check."""
dtime = datetime.datetime.now()
with self.assertRaises(TimeRangeException):
TimeRange.awareness_check(dtime)
def test_awareness_check(self):
"""work the duck typing failover in the awareness check."""
dtime = datetime.datetime.now()
with self.assertRaises(TimeRangeException):
TimeRange.awareness_check(dtime)
def _create_time_range(self, arg1, arg2=None): # pylint: disable=no-self-use
"""create a time range object"""
return TimeRange(arg1, arg2)
