def test_write_transfers_local_convext_over_global_context(self):
mock_sender = MockTelemetrySender()
queue = channel.SynchronousQueue(mock_sender)
context_global = channel.TelemetryContext()
context_global.device.id = "global"
context_local = channel.TelemetryContext()
context_local.device.id = "local"
actual = channel.TelemetryChannel(context_global, queue)
actual.write(channel.contracts.MessageData(), context_local)
actual.flush()
self.assertIsNotNone(mock_sender.data)
self.assertEqual("local", mock_sender.data.tags["ai.device.id"])
def test_context_works_as_expected(self):
context_global = channel.TelemetryContext()
context_global.device.id = "global"
actual = channel.TelemetryChannel()
self.assertIsNotNone(actual.context)
actual = channel.TelemetryChannel(None)
self.assertIsNotNone(actual.context)
actual = channel.TelemetryChannel(context_global)
self.assertEqual(context_global, actual.context)
def test_construct_with_context_and_sender(self):
mock_sender = MockTelemetrySender()
queue = channel.SynchronousQueue(mock_sender)
context_global = channel.TelemetryContext()
context_global.device.id = "global"
actual = channel.TelemetryChannel(context_global, queue)
actual.write(channel.contracts.MessageData())
actual.flush()
self.assertIsNotNone(mock_sender.data)
self.assertEqual("global", mock_sender.data.tags["ai.device.id"])
def test_location_attribute_works_as_expected(self):
context = channel.TelemetryContext()
self.assertIsNotNone(context.location)
context.location = None
self.assertIsNone(context.location)
context.location = Exception()
self.assertIsNotNone(context.location)
self.assertIsInstance(context.location, Exception)
context.location = channel.contracts.Location()
self.assertIsNotNone(context.location)
self.assertIsInstance(context.location, channel.contracts.Location)
def test_user_attribute_works_as_expected(self):
context = channel.TelemetryContext()
self.assertIsNotNone(context.user)
context.user = None
self.assertIsNone(context.user)
context.user = Exception()
self.assertIsNotNone(context.user)
self.assertIsInstance(context.user, Exception)
context.user = channel.contracts.User()
self.assertIsNotNone(context.user)
self.assertIsInstance(context.user, channel.contracts.User)
def test_cloud_attribute_works_as_expected(self):
context = channel.TelemetryContext()
self.assertIsNotNone(context.cloud)
context.cloud = None
self.assertIsNone(context.cloud)
context.cloud = Exception()
self.assertIsNotNone(context.cloud)
self.assertIsInstance(context.cloud, Exception)
context.cloud = channel.contracts.Cloud()
self.assertIsNotNone(context.cloud)
self.assertIsInstance(context.cloud, channel.contracts.Cloud)
def test_device_attribute_works_as_expected(self):
context = channel.TelemetryContext()
self.assertIsNotNone(context.device)
context.device = None
self.assertIsNone(context.device)
context.device = Exception()
self.assertIsNotNone(context.device)
self.assertIsInstance(context.device, Exception)
context.device = channel.contracts.Device()
self.assertIsNotNone(context.device)
self.assertIsInstance(context.device, channel.contracts.Device)
def test_construct(self):
context = channel.TelemetryContext()
self.assertIsNone(context.instrumentation_key)
self.assertIsNotNone(context.device)
self.assertEqual("Other", context.device.type)
self.assertEqual(platform.node(), context.device.id)
self.assertEqual(platform.version(), context.device.os_version)
self.assertEqual(locale.getdefaultlocale()[0], context.device.locale)
self.assertIsNotNone(context.application)
self.assertIsNotNone(context.user)
self.assertIsNotNone(context.session)
self.assertIsNotNone(context.operation)
self.assertIsNotNone(context.location)
self.assertIsNotNone(context.properties)
def __init__(self, instrumentation_key, telemetry_channel=None):
"""Initializes a new instance of the class.
Args:
instrumentation_key (str). the instrumentation key to use for this telemetry client.\n
telemetry_channel (:class:`channel.TelemetryChannel`). the optional telemetry channel to be used instead of
constructing a default one.
"""
if instrumentation_key:
if isinstance(instrumentation_key, channel.TelemetryChannel):
telemetry_channel = instrumentation_key
instrumentation_key = None
else:
raise Exception('Instrumentation key was required but not provided')
self._context = channel.TelemetryContext()
self._context.instrumentation_key = instrumentation_key
self._channel = telemetry_channel or channel.TelemetryChannel()
def test_write_constructs_valid_envelope(self):
mock_sender = MockTelemetrySender()
queue = channel.SynchronousQueue(mock_sender)
context_global = channel.TelemetryContext()
context_global.instrumentation_key = "42"
actual = channel.TelemetryChannel(context_global, queue)
cases = [
channel.contracts.EventData(),
channel.contracts.MetricData(),
channel.contracts.MessageData(),
channel.contracts.PageViewData(),
channel.contracts.ExceptionData(),
]
for item in cases:
actual.write(item)
actual.flush()
self.assertIsNotNone(mock_sender.data)
self.assertTrue(
isinstance(mock_sender.data, channel.contracts.Envelope))
self.assertEqual(item.ENVELOPE_TYPE_NAME, mock_sender.data.name)
self.assertIsNotNone(mock_sender.data.time)
self.assertEqual("42", mock_sender.data.ikey)
for key, value in context_global.device.write().items():
self.assertEqual(value, mock_sender.data.tags[key])
for key, value in context_global.application.write().items():
self.assertEqual(value, mock_sender.data.tags[key])
for key, value in context_global.user.write().items():
self.assertEqual(value, mock_sender.data.tags[key])
for key, value in context_global.session.write().items():
self.assertEqual(value, mock_sender.data.tags[key])
for key, value in context_global.location.write().items():
self.assertEqual(value, mock_sender.data.tags[key])
for key, value in context_global.operation.write().items():
self.assertEqual(value, mock_sender.data.tags[key])
self.assertIsNotNone(mock_sender.data.data)
self.assertEqual(item.DATA_TYPE_NAME,
mock_sender.data.data.base_type)
self.assertEqual(item, mock_sender.data.data.base_data)
def test_instrumentation_key_attribute_works_as_expected(self):
context = channel.TelemetryContext()
self.assertIsNone(context.instrumentation_key)
context.instrumentation_key = "foo"
self.assertEqual("foo", context.instrumentation_key)
def test_properties_property_works_as_expected(self):
context = channel.TelemetryContext()
self.assertIsNotNone(context.properties)
