110 lines
3.5 KiB
Python
110 lines
3.5 KiB
Python
from datetime import datetime, timedelta, timezone
|
|
import unittest
|
|
|
|
from coned_rtu import Reading
|
|
|
|
|
|
class TestReading(unittest.TestCase):
|
|
def setUp(self):
|
|
self.sometime = datetime(2010, 12, 25, 14, 30, 0, tzinfo=timezone.utc)
|
|
self.later = datetime(2010, 12, 26, 14, 30, 0, tzinfo=timezone.utc)
|
|
|
|
def test_start_time_must_be_before_end_time(self):
|
|
# start and end time the same
|
|
with self.assertRaises(ValueError):
|
|
Reading(self.sometime, self.sometime, "wh", 1)
|
|
|
|
# start time after end time
|
|
with self.assertRaises(ValueError):
|
|
Reading(self.later, self.sometime, "wh", 1)
|
|
|
|
def test_enforces_units(self):
|
|
# only wh or kwh supported
|
|
with self.assertRaises(ValueError):
|
|
Reading(self.sometime, self.later, "mwh", 1)
|
|
|
|
# incorrect capitalization is okay
|
|
Reading(self.sometime, self.later, "Wh", 1)
|
|
|
|
def test_duration(self):
|
|
r = Reading(self.sometime, self.later, "wh", 1)
|
|
self.assertEqual(r.duration(), timedelta(hours=24))
|
|
|
|
def test_overlaps(self):
|
|
t1 = self.sometime
|
|
t2 = t1 + timedelta(hours=1)
|
|
t3 = t2 + timedelta(hours=1)
|
|
t4 = t3 + timedelta(hours=1)
|
|
|
|
# one within the other
|
|
a = Reading(t1, t4, "wh", 1)
|
|
b = Reading(t2, t3, "wh", 1)
|
|
self.assertTrue(a.overlaps(b))
|
|
self.assertTrue(b.overlaps(a))
|
|
|
|
# one ends during the other
|
|
a = Reading(t1, t3, "wh", 1)
|
|
b = Reading(t2, t4, "wh", 1)
|
|
self.assertTrue(a.overlaps(b))
|
|
self.assertTrue(b.overlaps(a))
|
|
|
|
# same start, one is shorter than the other
|
|
a = Reading(t1, t3, "wh", 1)
|
|
b = Reading(t1, t2, "wh", 1)
|
|
self.assertTrue(a.overlaps(b))
|
|
self.assertTrue(b.overlaps(a))
|
|
|
|
# same end, one is shorter than the other
|
|
a = Reading(t1, t3, "wh", 1)
|
|
b = Reading(t2, t3, "wh", 1)
|
|
self.assertTrue(a.overlaps(b))
|
|
self.assertTrue(b.overlaps(a))
|
|
|
|
# not overlapping
|
|
a = Reading(t1, t2, "wh", 1)
|
|
b = Reading(t2, t3, "wh", 1)
|
|
self.assertFalse(a.overlaps(b))
|
|
self.assertFalse(b.overlaps(a))
|
|
|
|
def test_hash_bucket(self):
|
|
a = Reading(self.sometime, self.later, "wh", 1)
|
|
b = Reading(self.sometime, self.later, "wh", 2)
|
|
c = Reading(
|
|
self.sometime + timedelta(hours=24),
|
|
self.later + timedelta(hours=24),
|
|
"wh",
|
|
1,
|
|
)
|
|
self.assertEqual(a.hash_bucket(), b.hash_bucket())
|
|
self.assertNotEqual(a.hash_bucket(), c.hash_bucket())
|
|
|
|
def test_equality(self):
|
|
r = Reading(self.sometime, self.later, "wh", 1)
|
|
|
|
# times mismatch
|
|
bad_time = self.sometime + timedelta(seconds=10)
|
|
|
|
other = Reading(bad_time, self.later, "wh", 1)
|
|
self.assertNotEqual(r, other)
|
|
|
|
other = Reading(self.sometime, bad_time, "wh", 1)
|
|
self.assertNotEqual(r, other)
|
|
|
|
# energy mismatch
|
|
other = Reading(self.sometime, self.later, "wh", 1.0000001)
|
|
self.assertNotEqual(r, other)
|
|
|
|
# fully equal
|
|
other = Reading(self.sometime, self.later, "wh", 1)
|
|
self.assertEqual(r, other)
|
|
|
|
def test_hashing(self):
|
|
# unequal
|
|
a = Reading(self.sometime, self.later, "wh", 1)
|
|
b = Reading(self.sometime, self.later, "wh", 2)
|
|
self.assertNotEqual(hash(a), hash(b))
|
|
|
|
# equal
|
|
b = Reading(self.sometime, self.later, "wh", 1)
|
|
self.assertEqual(hash(a), hash(b))
|