refactor: Use the proper UT assertions in Fargate tests

Signed-off-by: Ferenc Géczi <[email protected]>

Author: Ferenc-

tests/platforms/test_fargate.py

@@ -84,7 +84,7 @@ def test_default_secrets(self):
         self.assertTrue(hasattr(self.agent.options, 'secrets_matcher'))
         self.assertEqual(self.agent.options.secrets_matcher, 'contains-ignore-case')
         self.assertTrue(hasattr(self.agent.options, 'secrets_list'))
-        self.assertEqual(self.agent.options.secrets_list, ['key', 'pass', 'secret'])
+        self.assertListEqual(self.agent.options.secrets_list, ['key', 'pass', 'secret'])
 
     def test_custom_secrets(self):
         os.environ["INSTANA_SECRETS"] = "equals:love,war,games"
@@ -93,7 +93,7 @@ def test_custom_secrets(self):
         self.assertTrue(hasattr(self.agent.options, 'secrets_matcher'))
         self.assertEqual(self.agent.options.secrets_matcher, 'equals')
         self.assertTrue(hasattr(self.agent.options, 'secrets_list'))
-        self.assertEqual(self.agent.options.secrets_list, ['love', 'war', 'games'])
+        self.assertListEqual(self.agent.options.secrets_list, ['love', 'war', 'games'])
 
     def test_default_tags(self):
         self.create_agent_and_setup_tracer()
@@ -110,18 +110,18 @@ def test_agent_extra_http_headers(self):
         self.create_agent_and_setup_tracer()
         self.assertIsNotNone(self.agent.options.extra_http_headers)
         should_headers = ['x-test-header', 'x-another-header', 'x-and-another-header']
-        self.assertEqual(should_headers, self.agent.options.extra_http_headers)
+        self.assertListEqual(should_headers, self.agent.options.extra_http_headers)
 
     def test_agent_default_log_level(self):
         self.create_agent_and_setup_tracer()
-        assert self.agent.options.log_level == logging.WARNING
+        self.assertEqual(self.agent.options.log_level, logging.WARNING)
 
     def test_agent_custom_log_level(self):
         os.environ['INSTANA_LOG_LEVEL'] = "eRror"
         self.create_agent_and_setup_tracer()
-        assert self.agent.options.log_level == logging.ERROR
+        self.assertEqual(self.agent.options.log_level, logging.ERROR)
 
     def test_custom_proxy(self):
         os.environ["INSTANA_ENDPOINT_PROXY"] = "http://myproxy.123"
         self.create_agent_and_setup_tracer()
-        assert self.agent.options.endpoint_proxy == {'https': "http://myproxy.123"}
+        self.assertDictEqual(self.agent.options.endpoint_proxy, {'https': "http://myproxy.123"})

tests/platforms/test_fargate_collector.py

@@ -84,161 +84,161 @@ def test_prepare_payload_basics(self):
         self.create_agent_and_setup_tracer()
 
         payload = self.agent.collector.prepare_payload()
-        assert(payload)
-
-        assert(len(payload.keys()) == 2)
-        assert('spans' in payload)
-        assert(isinstance(payload['spans'], list))
-        assert(len(payload['spans']) == 0)
-        assert('metrics' in payload)
-        assert(len(payload['metrics'].keys()) == 1)
-        assert('plugins' in payload['metrics'])
-        assert(isinstance(payload['metrics']['plugins'], list))
-        assert(len(payload['metrics']['plugins']) == 7)
+        self.assertTrue(payload)
+
+        self.assertEqual(2, len(payload.keys()))
+        self.assertIn('spans',payload)
+        self.assertIsInstance(payload['spans'], list)
+        self.assertEqual(0, len(payload['spans']))
+        self.assertIn('metrics', payload)
+        self.assertEqual(1, len(payload['metrics'].keys()))
+        self.assertIn('plugins', payload['metrics'])
+        self.assertIsInstance(payload['metrics']['plugins'], list)
+        self.assertEqual(7, len(payload['metrics']['plugins']))
 
         plugins = payload['metrics']['plugins']
         for plugin in plugins:
             # print("%s - %s" % (plugin["name"], plugin["entityId"]))
-            assert('name' in plugin)
-            assert('entityId' in plugin)
-            assert('data' in plugin)
+            self.assertIn('name', plugin)
+            self.assertIn('entityId', plugin)
+            self.assertIn('data', plugin)
 
     def test_docker_plugin_snapshot_data(self):
         self.create_agent_and_setup_tracer()
 
         first_payload = self.agent.collector.prepare_payload()
         second_payload = self.agent.collector.prepare_payload()
 
-        assert(first_payload)
-        assert(second_payload)
+        self.assertTrue(first_payload)
+        self.assertTrue(second_payload)
 
         plugin_first_report = get_docker_plugin(first_payload['metrics']['plugins'])
         plugin_second_report = get_docker_plugin(second_payload['metrics']['plugins'])
 
-        assert(plugin_first_report)
-        assert("data" in plugin_first_report)
+        self.assertTrue(plugin_first_report)
+        self.assertIn("data", plugin_first_report)
 
         # First report should have snapshot data
         data = plugin_first_report["data"]
-        assert(data["Id"] == "63dc7ac9f3130bba35c785ed90ff12aad82087b5c5a0a45a922c45a64128eb45")
-        assert(data["Created"] == "2020-07-27T12:14:12.583114444Z")
-        assert(data["Started"] == "2020-07-27T12:14:13.545410186Z")
-        assert(data["Image"] == "410797082306.dkr.ecr.us-east-2.amazonaws.com/fargate-docker-ssh:latest")
-        assert(data["Labels"] == {'com.amazonaws.ecs.cluster': 'arn:aws:ecs:us-east-2:410797082306:cluster/lombardo-ssh-cluster', 'com.amazonaws.ecs.container-name': 'docker-ssh-aws-fargate', 'com.amazonaws.ecs.task-arn': 'arn:aws:ecs:us-east-2:410797082306:task/2d60afb1-e7fd-4761-9430-a375293a9b82', 'com.amazonaws.ecs.task-definition-family': 'docker-ssh-aws-fargate', 'com.amazonaws.ecs.task-definition-version': '1'})
-        assert(data["Ports"] is None)
+        self.assertEqual(data["Id"], "63dc7ac9f3130bba35c785ed90ff12aad82087b5c5a0a45a922c45a64128eb45")
+        self.assertEqual(data["Created"], "2020-07-27T12:14:12.583114444Z")
+        self.assertEqual(data["Started"], "2020-07-27T12:14:13.545410186Z")
+        self.assertEqual(data["Image"], "410797082306.dkr.ecr.us-east-2.amazonaws.com/fargate-docker-ssh:latest")
+        self.assertEqual(data["Labels"], {'com.amazonaws.ecs.cluster': 'arn:aws:ecs:us-east-2:410797082306:cluster/lombardo-ssh-cluster', 'com.amazonaws.ecs.container-name': 'docker-ssh-aws-fargate', 'com.amazonaws.ecs.task-arn': 'arn:aws:ecs:us-east-2:410797082306:task/2d60afb1-e7fd-4761-9430-a375293a9b82', 'com.amazonaws.ecs.task-definition-family': 'docker-ssh-aws-fargate', 'com.amazonaws.ecs.task-definition-version': '1'})
+        self.assertIsNone(data["Ports"])
 
         # Second report should have no snapshot data
-        assert(plugin_second_report)
-        assert("data" in plugin_second_report)
+        self.assertTrue(plugin_second_report)
+        self.assertIn("data", plugin_second_report)
         data = plugin_second_report["data"]
-        assert("Id" in data)
-        assert("Created" not in data)
-        assert("Started" not in data)
-        assert("Image" not in data)
-        assert("Labels" not in data)
-        assert("Ports" not in data)
+        self.assertIn("Id", data)
+        self.assertNotIn("Created", data)
+        self.assertNotIn("Started", data)
+        self.assertNotIn("Image", data)
+        self.assertNotIn("Labels", data)
+        self.assertNotIn("Ports", data)
 
     def test_docker_plugin_metrics(self):
         self.create_agent_and_setup_tracer()
 
         first_payload = self.agent.collector.prepare_payload()
         second_payload = self.agent.collector.prepare_payload()
 
-        assert(first_payload)
-        assert(second_payload)
+        self.assertTrue(first_payload)
+        self.assertTrue(second_payload)
 
         plugin_first_report = get_docker_plugin(first_payload['metrics']['plugins'])
-        assert(plugin_first_report)
-        assert("data" in plugin_first_report)
+        self.assertTrue(plugin_first_report)
+        self.assertIn("data", plugin_first_report)
 
         plugin_second_report = get_docker_plugin(second_payload['metrics']['plugins'])
-        assert(plugin_second_report)
-        assert("data" in plugin_second_report)
+        self.assertTrue(plugin_second_report)
+        self.assertIn("data", plugin_second_report)
 
         # First report should report all metrics
         data = plugin_first_report.get("data", None)
-        assert(data)
-        assert "network" not in data
+        self.assertTrue(data)
+        self.assertNotIn("network", data)
 
         cpu = data.get("cpu", None)
-        assert(cpu)
-        assert(cpu["total_usage"] == 0.011033)
-        assert(cpu["user_usage"] == 0.009918)
-        assert(cpu["system_usage"] == 0.00089)
-        assert(cpu["throttling_count"] == 0)
-        assert(cpu["throttling_time"] == 0)
+        self.assertTrue(cpu)
+        self.assertEqual(cpu["total_usage"], 0.011033)
+        self.assertEqual(cpu["user_usage"], 0.009918)
+        self.assertEqual(cpu["system_usage"], 0.00089)
+        self.assertEqual(cpu["throttling_count"], 0)
+        self.assertEqual(cpu["throttling_time"], 0)
 
         memory = data.get("memory", None)
-        assert(memory)
-        assert(memory["active_anon"] == 78721024)
-        assert(memory["active_file"] == 18501632)
-        assert(memory["inactive_anon"] == 0)
-        assert(memory["inactive_file"] == 71684096)
-        assert(memory["total_cache"] == 90185728)
-        assert(memory["total_rss"] == 78721024)
-        assert(memory["usage"] == 193769472)
-        assert(memory["max_usage"] == 195305472)
-        assert(memory["limit"] == 536870912)
+        self.assertTrue(memory)
+        self.assertEqual(memory["active_anon"], 78721024)
+        self.assertEqual(memory["active_file"], 18501632)
+        self.assertEqual(memory["inactive_anon"], 0)
+        self.assertEqual(memory["inactive_file"], 71684096)
+        self.assertEqual(memory["total_cache"], 90185728)
+        self.assertEqual(memory["total_rss"], 78721024)
+        self.assertEqual(memory["usage"], 193769472)
+        self.assertEqual(memory["max_usage"], 195305472)
+        self.assertEqual(memory["limit"], 536870912)
 
         blkio = data.get("blkio", None)
-        assert(blkio)
-        assert(blkio["blk_read"] == 0)
-        assert(blkio["blk_write"] == 128352256)
+        self.assertTrue(blkio)
+        self.assertEqual(blkio["blk_read"], 0)
+        self.assertEqual(blkio["blk_write"], 128352256)
 
         # Second report should report the delta (in the test case, nothing)
         data = plugin_second_report["data"]
-        assert("cpu" in data)
-        assert(len(data["cpu"]) == 0)
-        assert("memory" in data)
-        assert(len(data["memory"]) == 0)
-        assert("blkio" in data)
-        assert(len(data["blkio"]) == 1)
-        assert(data["blkio"]['blk_write'] == 0)
-        assert('blk_read' not in data["blkio"])
+        self.assertIn("cpu", data)
+        self.assertEqual(len(data["cpu"]), 0)
+        self.assertIn("memory", data)
+        self.assertEqual(len(data["memory"]), 0)
+        self.assertIn("blkio", data)
+        self.assertEqual(len(data["blkio"]), 1)
+        self.assertEqual(data["blkio"]['blk_write'], 0)
+        self.assertNotIn('blk_read', data["blkio"])
 
     def test_no_instana_zone(self):
         self.create_agent_and_setup_tracer()
-        assert(self.agent.options.zone is None)
+        self.assertIsNone(self.agent.options.zone)
 
     def test_instana_zone(self):
         os.environ["INSTANA_ZONE"] = "YellowDog"
         self.create_agent_and_setup_tracer()
 
-        assert(self.agent.options.zone == "YellowDog")
+        self.assertEqual(self.agent.options.zone, "YellowDog")
 
         payload = self.agent.collector.prepare_payload()
-        assert(payload)
+        self.assertTrue(payload)
 
         plugins = payload['metrics']['plugins']
-        assert(isinstance(plugins, list))
+        self.assertIsInstance(plugins, list)
 
         task_plugin = None
         for plugin in plugins:
             if plugin["name"] == "com.instana.plugin.aws.ecs.task":
                 task_plugin = plugin
 
-        assert(task_plugin)
-        assert("data" in task_plugin)
-        assert("instanaZone" in task_plugin["data"])
-        assert(task_plugin["data"]["instanaZone"] == "YellowDog")
+        self.assertTrue(task_plugin)
+        self.assertIn("data", task_plugin)
+        self.assertIn("instanaZone", task_plugin["data"])
+        self.assertEqual(task_plugin["data"]["instanaZone"], "YellowDog")
 
     def test_custom_tags(self):
         os.environ["INSTANA_TAGS"] = "love,war=1,games"
         self.create_agent_and_setup_tracer()
         self.assertTrue(hasattr(self.agent.options, 'tags'))
-        self.assertEqual(self.agent.options.tags, {"love": None, "war": "1", "games": None})
+        self.assertDictEqual(self.agent.options.tags, {"love": None, "war": "1", "games": None})
 
         payload = self.agent.collector.prepare_payload()
 
-        assert payload
+        self.assertTrue(payload)
         task_plugin = None
         plugins = payload['metrics']['plugins']
         for plugin in plugins:
             if plugin["name"] == "com.instana.plugin.aws.ecs.task":
                 task_plugin = plugin
-        assert task_plugin
-        assert "tags" in task_plugin["data"]
+        self.assertTrue(task_plugin)
+        self.assertIn("tags", task_plugin["data"])
         tags = task_plugin["data"]["tags"]
-        assert tags["war"] == "1"
-        assert tags["love"] is None
-        assert tags["games"] is None
+        self.assertEqual(tags["war"], "1")
+        self.assertIsNone(tags["love"])
+        self.assertIsNone(tags["games"])