def test__get_monsol_meter_readings__two_hours(self):
self.maxDiff = None
date_from = todtaware('2021-11-01 13:00:00')
date_to = todtaware('2021-11-01 15:00:00')
granularity = '60'
device = None
status, token = self.api.reuse_token()
self.assertEqual(status, 200)
status, readings = self.api.get_monsol_meter_readings(
date_from, date_to, granularity, device)
# TODO remove this when monsol fix the one second rate limit
if status == 401:
time.sleep(1)
status, readings = self.api.get_monsol_meter_readings(
date_from, date_to, granularity, device)
expected = self.sample_historic_reading()
self.assertEqual(status, 200)
self.assertTrue('data' in readings)
self.assertGreater(len(readings['data']), 0)
self.assertListEqual(list(readings['data'][0].keys()),
list(expected['data'][0].keys()))
self.assertDictEqual(readings['data'][0], expected['data'][0])
def test__getMeterReadingsFromLastUpload__OneReading(self):
plant = self.pony.db.Plant(
name=self.mainFacility(),
codename='SomEnergia_{}'.format(self.mainFacility()),
)
time = todtaware('2020-01-01 00:00:00')
meter = self.pony.db.Meter(plant=plant, name='1234')
export_energy_wh = 210
meter.insertRegistry(time=time,
export_energy_wh=export_energy_wh,
import_energy_wh=0,
r1_VArh=0,
r2_VArh=0,
r3_VArh=0,
r4_VArh=0)
orm.flush()
expected = [
(todtaware('2020-01-01 00:00:00'), 210),
]
with orm.db_session:
result = getMeterReadings(self.pony.db, plant.codename)
self.assertEqual(expected, result)
def test_uploadProduction_singleData(self):
facility = self.mainFacility()
api = self.createApi()
response = api.uploadProduction(facility, [
(todtaware("2040-01-01 00:00:00"), 10),
])
self.assertEqual(response, 'OK')
self.assertEqual(api.lastDateUploaded(facility),
todtaware("2040-01-01 00:00:00"))
def test_irradiation_oneDay(self):
self.setupPlant()
self.importData(self.sensor,
'b2bdata/irradiance-2021-07-21-Alcolea.csv')
query = Path('queries/view_irradiation.sql').read_text(encoding='utf8')
result = [
r for r in self.pony.db.select(query)
if todtaware('2021-06-01 00:00:00') <= r.time
and r.time < todtaware('2021-06-02 00:00:00') and r.sensor == 1
]
self.assertOutputB2B(result)
def test_irradiation_halfHourWithReadings(self):
self.setupPlant()
self.importData(
self.sensor,
'b2bdata/irradiance-2021-07-21-Alcolea_test_cases.csv')
query = Path('queries/view_irradiation.sql').read_text(encoding='utf8')
result = [
r.irradiation_w_m2_h for r in self.pony.db.select(query)
if todtaware('2021-07-14 8:00:00') <= r.time
and r.time < todtaware('2021-07-14 9:00:00')
][0]
self.assertAlmostEqual(result, 415.2791252777778, places=5)
def test_irradiation_incompleteLastDay(self):
self.setupPlant()
self.importData(
self.sensor,
'b2bdata/irradiance-2021-07-21-Alcolea_test_cases.csv')
query = Path('queries/view_irradiation.sql').read_text(encoding='utf8')
result = [
r.irradiation_w_m2_h for r in self.pony.db.select(query)
if todtaware('2021-07-14 9:00:00') <= r.time
and r.time < todtaware('2021-07-14 10:00:00') and r.sensor == 1
][0]
self.assertAlmostEqual(result, 551.254630277778, places=5)
def test_getLastDateDownloaded(self):
with self.createPlantmonitorDB() as db:
data = {
self.mainFacility(): [
(todtaware("2020-01-02 00:00:00"), 10),
(todtaware("2020-01-02 01:00:00"), 20),
],
}
forecastDate = todtaware("2020-01-01 00:00:00")
db.addForecast(data, forecastDate)
result = db.lastDateDownloaded(self.mainFacility())
self.assertEqual(result, todtaware("2020-01-02 01:00:00"))
def test__uploadMeterReadings__checkResponses(self):
plant = self.pony.db.Plant(
name=self.mainFacility(),
codename='SomEnergia_{}'.format(self.mainFacility()),
)
time = todtaware('2020-01-01 00:00:00')
meter = self.pony.db.Meter(plant=plant, name='1234')
export_energy_wh = 210
meter.insertRegistry(time=time,
export_energy_wh=export_energy_wh,
import_energy_wh=0,
r1_VArh=0,
r2_VArh=0,
r3_VArh=0,
r4_VArh=0)
orm.flush()
with self.createApi() as api:
responses = uploadMeterReadings(self.pony.db, self.createConfig())
expectedResponse = 'OK'
self.assertEqual(responses[plant.codename], expectedResponse)
def test_addForecast_overwrite(self):
self.maxDiff = None
with self.createPlantmonitorDB() as db:
data = {
self.mainFacility(): [
(todtaware("2020-01-02 00:00:00"), 10),
(todtaware("2020-01-02 01:00:00"), 20),
],
}
forecastDate = todt("2020-01-01 00:00:00")
db.addForecast(data, forecastDate)
data2 = {
self.mainFacility(): [
(todtaware("2020-01-02 01:00:00"), 30),
(todtaware("2020-01-02 02:00:00"), 40),
],
}
forecastDate = todt("2020-01-01 00:00:00")
db.addForecast(data2, forecastDate)
dataResult = {
self.mainFacility(): [
(todtaware("2020-01-02 00:00:00"), 10),
(todtaware("2020-01-02 01:00:00"), 30),
(todtaware("2020-01-02 02:00:00"), 40),
],
}
result = db.getForecast()
self.assertEqual(dataResult, result)
def test_addForecast(self):
with self.createPlantmonitorDB() as db:
self.maxDiff = None
data = {
self.mainFacility(): [
(todtaware("2020-01-02 00:00:00"), 10),
(todtaware("2020-01-02 01:00:00"), 20),
],
self.secondaryFacility(): [
(todtaware("2020-01-02 00:00:00"), 210),
(todtaware("2020-01-02 01:00:00"), 340),
],
}
forecastDate = todtaware("2020-01-01 00:00:00")
db.addForecast(data, forecastDate)
result = db.getForecast()
self.assertEqual(data, result)
def __test_downloadForecast_setup(self):
forecastMeta = self.sampleForecastMeta(self.mainFacility(), time)
status = 'OK'
forecastDate = time
forecastMetadata = self.pony.db.ForecastMetadata.create(
plant=alcolea, forecastdate=forecastDate, errorcode=status)
forecastMetadata.addForecasts(data[self.mainFacility()])
orm.flush()
expected = [
(todtaware('2020-01-01 00:00:00'), 210),
(todtaware('2020-01-01 01:00:00'), 320),
(todtaware('2020-01-01 02:00:00'), 230),
(todtaware('2020-01-01 03:00:00'), 340),
]
def test_downloadForecast(self):
data = {
self.mainFacility(): [
(todt("2040-01-02 00:00:00"), 10),
(todt("2040-01-02 01:00:00"), 20),
],
}
fromDate = todt("{}-01-01 00:00:00".format(dt.datetime.now().year))
toDate = todt("{}-01-03 00:00:00".format(dt.datetime.now().year))
with self.createApi() as api:
for facility, values in data.items():
resultForecast = api.getForecast(facility, fromDate, toDate)
self.assertEqual(resultForecast[0][0], todtaware("{}-01-01 00:00:00".format(dt.datetime.now().year)))
def test__getMeterReadingsFromLastUpload__noMeter(self):
plant = self.pony.db.Plant(
name=self.mainFacility(),
codename='SomEnergia_{}'.format(self.mainFacility()),
)
time = todtaware('2020-01-01 00:00:00')
orm.flush()
with orm.db_session:
result = getMeterReadings(self.pony.db, plant.codename)
self.assertIsNone(result)
def test_getForecastFormatCheck(self):
api = self.createApi()
facility = self.mainFacility()
api.uploadProduction(facility, [
(todt("{}-01-01 00:00:00".format(
datetime.datetime.now().year)), 10),
])
result = api.getForecast(
facility,
todt("{}-01-01 00:00:00".format(datetime.datetime.now().year)),
todt("{}-01-01 00:00:00".format(datetime.datetime.now().year)),
)
#expected [("2020-01-01 00:00:00", _)] since we don't know meteologica's algorithm
logger.debug(result)
self.assertEqual(len(result), 1)
self.assertEqual(len(result[0]), 2)
self.assertEqual(
result[0][0],
todtaware("{}-01-01 00:00:00".format(
datetime.datetime.now().year)))
def mockMeterReadingsSideEffects(self, meterName, beyond, upto):
if not beyond:
return [r for r in self.readingsDB[meterName] if todtaware(r[0]) < upto]
else:
return [r for r in self.readingsDB[meterName] if beyond < todtaware(r[0]) and todtaware(r[0]) < upto]
def test__createForecast__OnePlant(self):
alcolea = self.pony.db.Plant(
name=self.mainFacility(),
codename='SomEnergia_{}'.format(self.mainFacility()),
)
time = datetime.datetime(2020,
12,
10,
15,
5,
10,
588861,
tzinfo=datetime.timezone.utc)
forecastMeta = {
'variable': 'prod',
'predictor': 'aggregated',
'granularity': '60',
'forecastdate': time,
'errorcode': '',
}
forecastData = {
self.mainFacility(): [
(todtaware("2040-01-02 00:00:00"), 10),
(todtaware("2040-01-02 01:00:00"), 20),
],
}
forecastMetadata = self.pony.db.ForecastMetadata.create(plant=alcolea,
**forecastMeta)
self.assertIsNotNone(forecastMetadata)
for f in forecastData[self.mainFacility()]:
forecastMetadata.insertForecast(
time=f[0],
percentil10=None,
percentil50=f[1],
percentil90=None,
)
orm.flush()
expected = [{
'forecastMetadata':
1,
'percentil10':
None,
'percentil50':
10,
'percentil90':
None,
'time':
datetime.datetime(2040, 1, 2, 0, 0, tzinfo=datetime.timezone.utc)
}, {
'forecastMetadata':
1,
'percentil10':
None,
'percentil50':
20,
'percentil90':
None,
'time':
datetime.datetime(2040, 1, 2, 1, 0, tzinfo=datetime.timezone.utc)
}]
forecasts = [f.to_dict() for f in self.pony.db.Forecast.select()]
self.assertListEqual(forecasts, expected)