def setUp(self):
self.logger = logging.getLogger('test')
self.session = Session()
self.adapter = Adapter()
self.session.mount('https://', self.adapter)
response_data = resource_string('parsers.test.mocks', 'SG_ema_gov_sg_solar_map.png')
self.adapter.register_uri('GET', SG.SOLAR_URL, content=response_data)
class Test_IN_AP(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('http://', self.adapter)
response_text = resource_string("parsers.test.mocks", "IN_AP.html")
self.adapter.register_uri(ANY, ANY, text=str(response_text))
def test_fetch_production(self):
try:
data = IN_AP.fetch_production('IN-AP', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['countryCode'], 'IN-AP')
self.assertEqual(data['source'], 'core.ap.gov.in')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['production'])
self.assertIsNotNone(data['storage'])
except Exception as ex:
self.fail("IN_AP.fetch_production() raised Exception: {0}".format(
ex.message))
def test_fetch_consumption(self):
try:
data = IN_AP.fetch_consumption('IN-AP', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['countryCode'], 'IN-AP')
self.assertEqual(data['source'], 'core.ap.gov.in')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['consumption'])
except Exception as ex:
self.fail("IN_AP.fetch_consumption() raised Exception: {0}".format(
ex.message))
def test_propagation_true(self):
# ensure distributed tracing can be enabled manually
cfg = config.get_from(self.session)
cfg['distributed_tracing'] = True
adapter = Adapter()
self.session.mount('mock', adapter)
with self.tracer.trace('root') as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri('GET',
'mock://datadog/foo',
additional_matcher=matcher,
text='bar')
resp = self.session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
spans = self.tracer.writer.spans
root, req = spans
eq_('root', root.name)
eq_('requests.request', req.name)
eq_(root.trace_id, req.trace_id)
eq_(root.span_id, req.parent_id)
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('https://', self.adapter)
response_text = resource_string("parsers.test.mocks", "IN_HP.html")
self.adapter.register_uri(
"GET", IN_HP.DATA_URL, text=str(response_text))
class Test_IN_AP(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount("https://", self.adapter)
response_text = resource_string("parsers.test.mocks", "IN_AP.html")
self.adapter.register_uri(ANY, ANY, text=str(response_text))
def test_fetch_production(self):
try:
data = IN_AP.fetch_production("IN-AP", self.session)
self.assertIsNotNone(data)
self.assertEqual(data["zoneKey"], "IN-AP")
self.assertEqual(data["source"], "core.ap.gov.in")
self.assertIsNotNone(data["datetime"])
self.assertIsNotNone(data["production"])
self.assertIsNotNone(data["storage"])
except Exception as ex:
self.fail("IN_AP.fetch_production() raised Exception: {0}".format(ex))
def test_fetch_consumption(self):
try:
data = IN_AP.fetch_consumption("IN-AP", self.session)
self.assertIsNotNone(data)
self.assertEqual(data["zoneKey"], "IN-AP")
self.assertEqual(data["source"], "core.ap.gov.in")
self.assertIsNotNone(data["datetime"])
self.assertIsNotNone(data["consumption"])
except Exception as ex:
self.fail("IN_AP.fetch_consumption() raised Exception: {0}".format(ex))
class Test_IN_HP(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('https://', self.adapter)
response_text = resource_string("parsers.test.mocks", "IN_HP.html")
self.adapter.register_uri(
"GET", IN_HP.DATA_URL, text=str(response_text))
def test_fetch_production(self):
try:
with LogCapture() as log:
data = IN_HP.fetch_production('IN-HP', self.session)
self.assertEqual(data['zoneKey'], 'IN-HP')
self.assertEqual(data['source'], 'hpsldc.com')
self.assertIsNotNone(data['datetime'])
self.assertEqual(data['production'], {
'hydro': 360.42, 'unknown': 115.4})
# Check rows that failed to parse in each table were logged correctly.
logs = log.actual()
self.assertEqual(len(logs), 2)
self.assertRegex(logs[0][2], re.compile('UNKNOWN HP PLANT'))
self.assertRegex(logs[1][2], re.compile('UNKNOWN ISGS PLANT'))
except Exception as ex:
self.fail(
"IN_HP.fetch_production() raised Exception: {0}".format(ex))
class TestUSHI(unittest.TestCase):
def setUp(self):
"""Make a session containing mocked input data."""
self.logger = logging.getLogger("test")
self.session = Session()
self.adapter = Adapter()
self.session.mount("https://", self.adapter)
realtime_response_data = resource_string("parsers.test.mocks",
"US_HI.htm")
self.adapter.register_uri("GET",
US_HI.BASE_URL + "limit=1",
content=realtime_response_data)
hist_response_data = resource_string("parsers.test.mocks",
"US_HI_hist.htm")
hist_dt = arrow.get("2013/12/04 16:30").format("YYYY-MM-DD")
self.adapter.register_uri("GET",
US_HI.BASE_URL + f"date={hist_dt}",
content=hist_response_data)
@freeze_time("2021-11-16 00:30:00")
def test_fetch_production_realtime(self):
data = US_HI.fetch_production(session=self.session, logger=self.logger)
self.assertIsInstance(data, dict)
self.assertEqual(data["zoneKey"], "US-HI-OA")
self.assertEqual(data["production"]["coal"], 179.2)
expected_dt = arrow.get(datetime(2021, 11, 15, 14, 30),
"US/Hawaii").datetime
self.assertEqual(data["datetime"], expected_dt)
# The production values (MW) should never be negative:
smallest_prod_mw = min(data["production"].values())
self.assertTrue(smallest_prod_mw >= 0)
@freeze_time("2021-11-16 00:30:00")
def test_fetch_production_historical(self):
"""Testing historical data with request for 2013-12-04, 6:30am HST. This is the earliest valid target_datetime for the API."""
test_target_dt = arrow.get("2013/12/04 16:30").datetime
data = US_HI.fetch_production(session=self.session,
logger=self.logger,
target_datetime=test_target_dt)
self.assertIsInstance(data, dict)
self.assertEqual(data["zoneKey"], "US-HI-OA")
self.assertEqual(data["production"]["oil"], 694.3)
# the datetime returned should be within 2 hours after hist_dt (in HST)
expected_dt = arrow.get("2013/12/04 08:30",
tzinfo="US/Hawaii").datetime
self.assertEqual(data["datetime"], expected_dt)
smallest_prod_mw = min(data["production"].values())
self.assertTrue(smallest_prod_mw >= 0)
@freeze_time("2021-11-16 00:30:00")
def test_fetch_production_outdated(self):
"""Testing historical data with request for 2013-12-04, 6:29am HST. The closest data found is > 2 hours later, so
this request returns None."""
test_target_dt = arrow.get("2013/12/04 16:29").datetime
old_data = US_HI.fetch_production(session=self.session,
logger=self.logger,
target_datetime=test_target_dt)
self.assertIsNone(old_data)
def test_list(self):
client = StorageClient("mock://")
adapter = Adapter()
# should probably figure out a better way to do this
client.volumes.session.mount('mock', adapter)
adapter.register_uri('GET',
'mock:///volumes',
text=dumps([{
"export": {},
"id": "thrawn",
"name": "thrawn",
"origin": "",
"path": "/dev/lunr-volume/thrawn",
"size": 12582912
}]))
# List all the volumes on a storage node
volumes = client.volumes.list()
# Asserts
self.assertIn('export', volumes[0])
self.assertIn('id', volumes[0])
self.assertIn('origin', volumes[0])
self.assertIn('path', volumes[0])
self.assertIn('size', volumes[0])
def test_propagation_true_legacy(self):
# [Backward compatibility]: ensure users can switch the distributed
# tracing flag using the `Session` attribute
adapter = Adapter()
self.session.mount("mock", adapter)
self.session.distributed_tracing = True
with self.tracer.trace("root") as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri("GET",
"mock://datadog/foo",
additional_matcher=matcher,
text="bar")
resp = self.session.get("mock://datadog/foo")
assert 200 == resp.status_code
assert "bar" == resp.text
spans = self.tracer.writer.spans
root, req = spans
assert "root" == root.name
assert "requests.request" == req.name
assert root.trace_id == req.trace_id
assert root.span_id == req.parent_id
class TestSolar(unittest.TestCase):
def setUp(self):
self.logger = logging.getLogger('test')
self.session = Session()
self.adapter = Adapter()
self.session.mount('https://', self.adapter)
response_data = resource_string('parsers.test.mocks',
'SG_ema_gov_sg_solar_map.png')
self.adapter.register_uri('GET', SG.SOLAR_URL, content=response_data)
@freeze_time('2021-12-23 03:21:00')
def test_works_when_nonzero(self):
response_data = resource_string('parsers.test.mocks',
'SG_ema_gov_sg_solar_map_nonzero.png')
self.adapter.register_uri('GET', SG.SOLAR_URL, content=response_data)
power = SG.get_solar(self.session, logger=self.logger)
self.assertEqual(power, 69.64)
@freeze_time('2021-12-23 15:12:00')
def test_works_when_zero(self):
power = SG.get_solar(self.session, logger=self.logger)
self.assertEqual(power, 0.0)
@freeze_time('2021-12-24 15:12:00')
def test_ignore_data_older_than_one_hour(self):
with LogCapture() as log:
power = SG.get_solar(self.session, logger=self.logger)
self.assertIsNone(power)
@freeze_time('2021-12-23 15:06:00')
def test_allow_remote_clock_to_be_slightly_ahead(self):
power = SG.get_solar(self.session, logger=self.logger)
self.assertEqual(power, 0.0)
class Test_IN_HP(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount("https://", self.adapter)
response_text = resource_string("parsers.test.mocks", "IN_HP.html")
self.adapter.register_uri("POST", IN_HP.DATA_URL, text=str(response_text))
def test_fetch_production(self):
try:
with LogCapture() as log:
data = IN_HP.fetch_production("IN-HP", self.session)
self.assertEqual(data["zoneKey"], "IN-HP")
self.assertEqual(data["source"], "hpsldc.com")
self.assertIsNotNone(data["datetime"])
self.assertEqual(
data["production"], {"hydro": 4238.05, "unknown": 323.44}
)
# Check rows that failed to parse in each table were logged correctly.
logs = log.actual()
self.assertEqual(len(logs), 2)
self.assertRegex(logs[0][2], re.compile("UNKNOWN HP PLANT"))
self.assertRegex(logs[1][2], re.compile("UNKNOWN ISGS PLANT"))
except Exception as ex:
self.fail("IN_HP.fetch_production() raised Exception: {0}".format(ex))
class Test_IN_AP(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('http://', self.adapter)
response_text = resource_string("parsers.test.mocks", "IN_AP.html")
self.adapter.register_uri(ANY, ANY, text=response_text)
def test_fetch_production(self):
try:
data = IN_AP.fetch_production('IN-AP', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['countryCode'], 'IN-AP')
self.assertEqual(data['source'], 'core.ap.gov.in')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['production'])
self.assertIsNotNone(data['storage'])
except Exception as ex:
self.fail("IN_AP.fetch_production() raised Exception: {0}".format(ex.message))
def test_fetch_consumption(self):
try:
data = IN_AP.fetch_consumption('IN-AP', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['countryCode'], 'IN-AP')
self.assertEqual(data['source'], 'core.ap.gov.in')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['consumption'])
except Exception as ex:
self.fail("IN_AP.fetch_consumption() raised Exception: {0}".format(ex.message))
def test_propagation_true(self):
# ensure distributed tracing can be enabled manually
cfg = config.get_from(self.session)
cfg["distributed_tracing"] = True
adapter = Adapter()
self.session.mount("mock", adapter)
with self.tracer.trace("root") as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri("GET",
"mock://datadog/foo",
additional_matcher=matcher,
text="bar")
resp = self.session.get("mock://datadog/foo")
assert 200 == resp.status_code
assert "bar" == resp.text
spans = self.tracer.writer.spans
root, req = spans
assert "root" == root.name
assert "requests.request" == req.name
assert root.trace_id == req.trace_id
assert root.span_id == req.parent_id
def test_list(self):
client = StorageClient("mock://")
adapter = Adapter()
# should probably figure out a better way to do this
client.volumes.session.mount('mock', adapter)
adapter.register_uri('GET', 'mock:///volumes', text=dumps([{
"export": {},
"id": "thrawn",
"name": "thrawn",
"origin": "",
"path": "/dev/lunr-volume/thrawn",
"size": 12582912
}])
)
# List all the volumes on a storage node
volumes = client.volumes.list()
# Asserts
self.assertIn('export', volumes[0])
self.assertIn('id', volumes[0])
self.assertIn('origin', volumes[0])
self.assertIn('path', volumes[0])
self.assertIn('size', volumes[0])
def test_propagation_true_legacy(self):
# [Backward compatibility]: ensure users can switch the distributed
# tracing flag using the `Session` attribute
adapter = Adapter()
self.session.mount('mock', adapter)
self.session.distributed_tracing = True
with self.tracer.trace('root') as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri('GET',
'mock://datadog/foo',
additional_matcher=matcher,
text='bar')
resp = self.session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
spans = self.tracer.writer.spans
root, req = spans
eq_('root', root.name)
eq_('requests.request', req.name)
eq_(root.trace_id, req.trace_id)
eq_(root.span_id, req.parent_id)
def test_propagation_true(self):
adapter = Adapter()
tracer, session = get_traced_session()
session.mount('mock', adapter)
session.distributed_tracing = True
with tracer.trace('root') as root:
def matcher(request):
return self.headers_here(tracer, request, root)
adapter.register_uri('GET',
'mock://datadog/foo',
additional_matcher=matcher,
text='bar')
resp = session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
spans = tracer.writer.spans
root, req = spans
eq_('root', root.name)
eq_('requests.request', req.name)
eq_(root.trace_id, req.trace_id)
eq_(root.span_id, req.parent_id)
def setUp(self):
self.logger = logging.getLogger("test")
self.session = Session()
self.adapter = Adapter()
self.session.mount("https://", self.adapter)
response_data = resource_string("parsers.test.mocks",
"SG_ema_gov_sg_solar_map.png")
self.adapter.register_uri("GET", SG.SOLAR_URL, content=response_data)
def test_query(self, requests_mock: Adapter) -> None:
requests_mock.register_uri(
'GET', 'http+api://api/spec?q=foo',
complete_qs=True,
text=r'{"value": "bar", "complete": true}',
)
assert Interface(api_url='http://api').get(Dynamic.foo) \
== 'bar'
def test_set(self, requests_mock: Adapter) -> None:
requests_mock.register_uri(
'PUT', 'http+api://api/outputs/foo',
text='OK',
request_headers={'content-type': 'application/json'},
additional_matcher=lambda request: request.text == r'"bar"',
)
Outputs(new_session(api_url='http://api')).set('foo', 'bar')
def test_incomplete(self, requests_mock: Adapter) -> None:
requests_mock.register_uri(
'GET', 'http+api://api/spec',
text=r'''{
"value": {"foo": {"$type": "Secret", "name": "foo"}},
"complete": false}
''',
)
with pytest.raises(UnresolvableException):
Interface(api_url='http://api').get()
def test_propagation_default(self):
# ensure by default, distributed tracing is enabled
adapter = Adapter()
self.session.mount('mock', adapter)
with self.tracer.trace('root') as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri('GET', 'mock://opentelemetry/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://opentelemetry/foo')
assert 200 == resp.status_code
assert 'bar' == resp.text
def test_propagation_default(self):
# ensure by default, distributed tracing is disabled
adapter = Adapter()
self.session.mount('mock', adapter)
with self.tracer.trace('root'):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri('GET', 'mock://datadog/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
def test_emit(self, requests_mock: Adapter) -> None:
requests_mock.register_uri(
'POST',
'http+api://api/events',
text='OK',
request_headers={'content-type': 'application/json'},
additional_matcher=lambda request: request.json() ==
{'data': {
'foo': 'bar'
}},
)
Events(new_session(api_url='http://api')).emit({'foo': 'bar'})
def test_propagation_false_global(self):
# distributed tracing can be disabled globally
adapter = Adapter()
self.session.mount('mock', adapter)
with self.override_config('requests', dict(distributed_tracing=False)):
with self.tracer.trace('root'):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri('GET', 'mock://opentelemetry/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://opentelemetry/foo')
assert 200 == resp.status_code
assert 'bar' == resp.text
def test_propagation_false_legacy(self):
# [Backward compatibility]: ensure users can switch the distributed
# tracing flag using the `Session` attribute
adapter = Adapter()
self.session.mount('mock', adapter)
self.session.distributed_tracing = False
with self.tracer.trace('root'):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri('GET', 'mock://datadog/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
def test_propagation_false(self):
# ensure distributed tracing can be disabled
cfg = config.get_from(self.session)
cfg['distributed_tracing'] = False
adapter = Adapter()
self.session.mount('mock', adapter)
with self.tracer.trace('root'):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri('GET', 'mock://datadog/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
def test_mocking_client_adapter():
"""Checks that mocking the client adapter is possible"""
url = 'http://mock.com'
adapter = Adapter()
client = Client(url=url, adapter=adapter)
exp = 'success'
adapter.register_uri('GET', url, text=exp)
res = client.request('get')
eq_(200, res.status_code)
eq_(exp, res.text)
def get_mock_adapter() -> Adapter:
"""Get a requests-mock Adapter with some URLs mocked by default"""
adapter = Adapter()
adapter.register_uri(
ANY_METHOD,
MOCKED_URL,
headers={'Content-Type': 'text/plain'},
text='mock response',
status_code=200,
)
adapter.register_uri(
ANY_METHOD,
MOCKED_URL_HTTPS,
headers={'Content-Type': 'text/plain'},
text='mock https response',
status_code=200,
)
adapter.register_uri(
ANY_METHOD,
MOCKED_URL_JSON,
headers={'Content-Type': 'application/json'},
json={'message': 'mock json response'},
status_code=200,
)
return adapter
def test_propagation_false(self):
# ensure distributed tracing can be disabled manually
cfg = config.get_from(self.session)
cfg['distributed_tracing'] = False
adapter = Adapter()
self.session.mount('mock', adapter)
with self.tracer.trace('root'):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri('GET', 'mock://opentelemetry/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://opentelemetry/foo')
assert 200 == resp.status_code
assert 'bar' == resp.text
def test_propagation_default(self):
# ensure by default, distributed tracing is enabled
adapter = Adapter()
self.session.mount("mock", adapter)
with self.tracer.trace("root") as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri("GET", "mock://datadog/foo", additional_matcher=matcher, text="bar")
resp = self.session.get("mock://datadog/foo")
assert 200 == resp.status_code
assert "bar" == resp.text
def test_propagation_false_legacy(self):
# [Backward compatibility]: ensure users can switch the distributed
# tracing flag using the `Session` attribute
adapter = Adapter()
self.session.mount('mock', adapter)
self.session.distributed_tracing = False
with self.tracer.trace('root'):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri('GET', 'mock://opentelemetry/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://opentelemetry/foo')
assert 200 == resp.status_code
assert 'bar' == resp.text
def test_rate_limit():
"""Checks that the rate limit is working"""
url = 'http://mock.com'
adapter = Adapter()
client = Client(url=url, adapter=adapter)
exp = 'success'
adapter.register_uri('GET', url, text=exp)
res = client.request('get')
eq_(200, res.status_code)
eq_(exp, res.text)
def test_propagation_false_global(self):
# distributed tracing can be disabled globally
adapter = Adapter()
self.session.mount("mock", adapter)
with self.override_config("requests", dict(distributed_tracing=False)):
with self.tracer.trace("root"):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri("GET", "mock://datadog/foo", additional_matcher=matcher, text="bar")
resp = self.session.get("mock://datadog/foo")
assert 200 == resp.status_code
assert "bar" == resp.text
def test_propagation_false(self):
# ensure distributed tracing can be disabled manually
cfg = config.get_from(self.session)
cfg["distributed_tracing"] = False
adapter = Adapter()
self.session.mount("mock", adapter)
with self.tracer.trace("root"):
def matcher(request):
return self.headers_not_here(self.tracer, request)
adapter.register_uri("GET", "mock://datadog/foo", additional_matcher=matcher, text="bar")
resp = self.session.get("mock://datadog/foo")
assert 200 == resp.status_code
assert "bar" == resp.text
class TestESIOS(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('https://', self.adapter)
def test_fetch_exchange(self):
json_data = resource_string("parsers.test.mocks", "ESIOS_ES_MA.json")
self.adapter.register_uri(ANY, ANY, json=loads(json_data.decode("utf-8")))
try:
data_list = ESIOS.fetch_exchange('ES', 'MA', self.session, 'ESIOS_MOCK_TOKEN')
self.assertIsNotNone(data_list)
for data in data_list:
self.assertEqual(data['sortedZoneKeys'], 'ES->MA')
self.assertEqual(data['source'], 'api.esios.ree.es')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['netFlow'])
except Exception as ex:
self.fail(ex.message)
def test_propagation_true(self):
# ensure distributed tracing can be enabled
cfg = config.get_from(self.session)
cfg['distributed_tracing'] = True
adapter = Adapter()
self.session.mount('mock', adapter)
with self.tracer.trace('root') as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri('GET', 'mock://datadog/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
spans = self.tracer.writer.spans
root, req = spans
eq_('root', root.name)
eq_('requests.request', req.name)
eq_(root.trace_id, req.trace_id)
eq_(root.span_id, req.parent_id)
def test_propagation_true_legacy(self):
# [Backward compatibility]: ensure users can switch the distributed
# tracing flag using the `Session` attribute
adapter = Adapter()
self.session.mount('mock', adapter)
self.session.distributed_tracing = True
with self.tracer.trace('root') as root:
def matcher(request):
return self.headers_here(self.tracer, request, root)
adapter.register_uri('GET', 'mock://datadog/foo', additional_matcher=matcher, text='bar')
resp = self.session.get('mock://datadog/foo')
eq_(200, resp.status_code)
eq_('bar', resp.text)
spans = self.tracer.writer.spans
root, req = spans
eq_('root', root.name)
eq_('requests.request', req.name)
eq_(root.trace_id, req.trace_id)
eq_(root.span_id, req.parent_id)
class Test_IN_KA(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('http://', self.adapter)
def test_fetch_consumption(self):
response_text = resource_string("parsers.test.mocks", "IN_KA_Default.html")
self.adapter.register_uri("GET", "http://kptclsldc.com/Default.aspx", content=response_text)
try:
data = IN_KA.fetch_consumption('IN-KA', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['countryCode'], 'IN-KA')
self.assertEqual(data['source'], 'kptclsldc.com')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['consumption'])
self.assertEqual(data['consumption'], 7430.0)
except Exception as ex:
self.fail("IN_KA.fetch_consumption() raised Exception: {0}".format(ex.message))
def test_fetch_production(self):
response_text = resource_string("parsers.test.mocks", "IN_KA_StateGen.html")
self.adapter.register_uri("GET", "http://kptclsldc.com/StateGen.aspx", content=response_text)
response_text = resource_string("parsers.test.mocks", "IN_KA_StateNCEP.html")
self.adapter.register_uri("GET", "http://kptclsldc.com/StateNCEP.aspx", content=response_text)
try:
data = IN_KA.fetch_production('IN-KA', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['countryCode'], 'IN-KA')
self.assertEqual(data['source'], 'kptclsldc.com')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['production'])
self.assertEqual(data['production']['hydro'], 1108.0)
self.assertIsNotNone(data['storage'])
except Exception as ex:
self.fail("IN_KA.fetch_production() raised Exception: {0}".format(ex.message))
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('http://', self.adapter)
response_text = resource_string("parsers.test.mocks", "IN_AP.html")
self.adapter.register_uri(ANY, ANY, text=response_text)
class TestINPB(unittest.TestCase):
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('http://', self.adapter)
def test_fetch_consumption(self):
response_text = resource_string("parsers.test.mocks", "IN_PB_nrGenReal.html")
self.adapter.register_uri("GET", "http://www.punjabsldc.org/nrrealw.asp?pg=nrGenReal",
content=response_text)
try:
data = IN_PB.fetch_consumption('IN-PB', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['zoneKey'], 'IN-PB')
self.assertEqual(data['source'], 'punjasldc.org')
self.assertIsNotNone(data['datetime'])
expected = get(datetime(2017, 9, 6, 14, 38, 29), 'Asia/Kolkata').datetime
date_time = data['datetime']
self.assertEqual(date_time, expected)
self.assertIsNotNone(data['consumption'])
self.assertEqual(data['consumption'], 7451.0)
except Exception as ex:
self.fail("IN_KA.fetch_consumption() raised Exception: {0}".format(ex.message))
def test_fetch_production(self):
response_text = resource_string("parsers.test.mocks", "IN_PB_pbGenReal.html")
self.adapter.register_uri("GET", "http://www.punjabsldc.org/pungenrealw.asp?pg=pbGenReal",
content=response_text)
try:
data = IN_PB.fetch_production('IN-PB', self.session)
self.assertIsNotNone(data)
self.assertEqual(data['zoneKey'], 'IN-PB')
self.assertEqual(data['source'], 'punjasldc.org')
self.assertIsNotNone(data['datetime'])
self.assertIsNotNone(data['production'])
self.assertEqual(data['production']['hydro'], 554.0)
self.assertIsNotNone(data['storage'])
except Exception as ex:
self.fail("IN_KA.fetch_production() raised Exception: {0}".format(ex.message))
def test_read_text_by_regex(self):
text ='<b><font size="4"> 09/06/2017</b></font>'
date_text = IN_PB.read_text_by_regex('(\d+/\d+/\d+)', text)
expected = "09/06/2017"
self.assertEqual(date_text, expected)
text = '<b>Time : 14:38:29</b>'
date_text = IN_PB.read_text_by_regex('(\d+:\d+:\d+)', text)
expected = "14:38:29"
self.assertEqual(date_text, expected)
text = '<b> Last Updated at 13:33:59</b><br>'
date_text = IN_PB.read_text_by_regex('(\d+:\d+:\d+)', text)
expected = "13:33:59"
self.assertEqual(date_text, expected)
def test_read_punjab_consumption_date(self):
current = get(datetime(2018, 5, 5, 14, 38, 29), 'Asia/Kolkata')
date_text = "02/04/2018"
time_text = "14:38:29"
expected = get(datetime(2018, 4, 2, 14, 38, 29), 'Asia/Kolkata').datetime
date_time = IN_PB.read_punjab_consumption_date(date_text, time_text, current)
self.assertEqual(date_time, expected)
def setUp(self):
self.session = Session()
self.adapter = Adapter()
self.session.mount('http://', self.adapter)
