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)