class LogicGetTest(unittest.TestCase):
def setUp(self):
self.since = Mock()
self.until = Mock()
state_mock = Mock()
state_mock.get_electric_meters.return_value = {}
self.db_mock = Mock()
self.plugin_loader_mock = Mock()
data_per_hour = 3600
self.logic = Logic(state_mock, self.db_mock, self.plugin_loader_mock,
data_per_hour)
self.meter_id = 10
self.meter = Mock()
self.meter_dict = {
'name': 'Name',
'type': 'TEST_PLUGIN',
'custom': {
'key1': 'val1',
'key2': 100
}
}
state_mock.get_electric_meters.return_value = {
self.meter_id: self.meter
}
state_mock.get_electric_meters_dict.return_value = {
self.meter_id: self.meter_dict
}
def test_get_electric_meters_dict(self):
# Setup
test_meter1 = MagicMock()
test_meter2 = MagicMock()
self.logic.state.get_electric_meters_dict.return_value = {
10: test_meter1,
11: test_meter2
}
# Test
meters = self.logic.get_electric_meters_dict()
# Assertion
self.assertIn((10, test_meter1), meters)
self.assertIn((11, test_meter2), meters)
def test_get_raw(self):
self.db_mock.get_raw.return_value = {
10: [
{
'value': 1,
'timestamp': datetime(2020, 10, 30, 12, 00)
},
{
'value': 1,
'timestamp': datetime(2020, 10, 30, 12, 15)
},
{
'value': 1,
'timestamp': datetime(2020, 10, 30, 12, 30)
},
{
'value': 1,
'timestamp': datetime(2020, 10, 30, 12, 45)
},
{
'value': 2,
'timestamp': datetime(2020, 10, 30, 13, 00)
},
{
'value': 2,
'timestamp': datetime(2020, 10, 30, 13, 15)
},
{
'value': 2,
'timestamp': datetime(2020, 10, 30, 13, 30)
},
{
'value': 2,
'timestamp': datetime(2020, 10, 30, 13, 45)
},
]
}
# Test
electric_meter_data = self.logic.get_raw(since=self.since,
until=self.until)[0]
raw = electric_meter_data.data
# Assertion
self.db_mock.get_raw.assert_called_once_with(since=self.since,
until=self.until)
self.assertEqual(self.meter_id, electric_meter_data.id)
self.assertEqual(self.meter_dict, electric_meter_data.electric_meter)
self.assertEqual(len(self.db_mock.get_raw()[self.meter_id]), len(raw))
for idx, data_point in enumerate(raw):
self.assertEqual(
self.db_mock.get_raw()[self.meter_id][idx]['value'],
data_point['value'])
self.assertEqual(
self.db_mock.get_raw()[
self.meter_id][idx]['timestamp'].replace(microsecond=0),
data_point['timestamp'].replace(microsecond=0))
def test_get_day(self):
self.db_mock.get_day.return_value = {
10: [{
'value': hour * 10,
'timestamp': datetime(2020, 10, hour // 24 + 1, hour % 24, 00)
} for hour in range(48)]
}
# Test
electric_meter_data = self.logic.get_day(since=self.since,
until=self.until)[0]
day = electric_meter_data.data
# Assertion
self.db_mock.get_day.assert_called_once_with(since=self.since,
until=self.until)
self.assertEqual(self.meter_id, electric_meter_data.id)
self.assertEqual(self.meter_dict, electric_meter_data.electric_meter)
self.assertEqual(len(self.db_mock.get_day()[self.meter_id]), len(day))
for idx, data_point in enumerate(day):
self.assertEqual(
self.db_mock.get_day()[self.meter_id][idx]['value'],
data_point['value'])
self.assertEqual(
self.db_mock.get_day()[
self.meter_id][idx]['timestamp'].replace(microsecond=0),
data_point['timestamp'].replace(microsecond=0))
def test_get_month(self):
self.db_mock.get_month.return_value = {
10: [{
'value':
day * 10,
'timestamp':
datetime(2020, day // 30 + 3, day % 30 + 1, 00, 00)
} for day in range(60)]
}
# Test
electric_meter_data = self.logic.get_month(since=self.since,
until=self.until)[0]
month = electric_meter_data.data
# Assertion
self.db_mock.get_month.assert_called_once_with(since=self.since,
until=self.until)
self.assertEqual(self.meter_id, electric_meter_data.id)
self.assertEqual(self.meter_dict, electric_meter_data.electric_meter)
self.assertEqual(len(self.db_mock.get_month()[self.meter_id]),
len(month))
for idx, data_point in enumerate(month):
self.assertEqual(
self.db_mock.get_month()[self.meter_id][idx]['value'],
data_point['value'])
self.assertEqual(
self.db_mock.get_month()[
self.meter_id][idx]['timestamp'].replace(microsecond=0),
data_point['timestamp'].replace(microsecond=0))
def test_get_year(self):
self.db_mock.get_year.return_value = {
10: [{
'value': month * 10,
'timestamp': datetime(2020, month + 1, 1, 00, 00)
} for month in range(12)]
}
# Test
electric_meter_data = self.logic.get_year(since=self.since,
until=self.until)[0]
year = electric_meter_data.data
# Assertion
self.db_mock.get_year.assert_called_once_with(since=self.since,
until=self.until)
self.assertEqual(self.meter_id, electric_meter_data.id)
self.assertEqual(self.meter_dict, electric_meter_data.electric_meter)
self.assertEqual(len(self.db_mock.get_year()[self.meter_id]),
len(year))
for idx, data_point in enumerate(year):
self.assertEqual(
self.db_mock.get_year()[self.meter_id][idx]['value'],
data_point['value'])
self.assertEqual(
self.db_mock.get_year()[
self.meter_id][idx]['timestamp'].replace(microsecond=0),
data_point['timestamp'].replace(microsecond=0))
def test_get_years(self):
self.db_mock.get_years.return_value = {
10: [{
'value': year * 10,
'timestamp': datetime(year + 1, 1, 1, 00, 00)
} for year in range(3)]
}
# Test
electric_meter_data = self.logic.get_years(since=self.since,
until=self.until)[0]
years = electric_meter_data.data
# Assertion
self.db_mock.get_years.assert_called_once_with(since=self.since,
until=self.until)
self.assertEqual(self.meter_id, electric_meter_data.id)
self.assertEqual(self.meter_dict, electric_meter_data.electric_meter)
self.assertEqual(len(self.db_mock.get_years()[self.meter_id]),
len(years))
for idx, data_point in enumerate(years):
self.assertEqual(
self.db_mock.get_years()[self.meter_id][idx]['value'],
data_point['value'])
self.assertEqual(
self.db_mock.get_years()[self.meter_id][idx]['timestamp'],
data_point['timestamp'])
