diff --git a/.circleci/config.yml b/.circleci/config.yml index 6adf4d3d..51e99dff 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -37,6 +37,9 @@ commands: run-tests-with-coverage-report: parameters: + googlecloud: + default: "" + type: string cassandra: default: "" type: string @@ -57,6 +60,7 @@ commands: CASSANDRA_TEST: "<>" COUCHBASE_TEST: "<>" GEVENT_STARLETTE_TEST: "<>" + GOOGLE_CLOUD_TEST: "<>" command: | . venv/bin/activate coverage run --source=instana -m pytest -v --junitxml=test-results <> @@ -210,6 +214,21 @@ jobs: - store-pytest-results - store-coverage-report + py311googlecloud: + docker: + - image: cimg/python:3.11.4 + - image: vanmoof/pubsub-emulator + working_directory: ~/repo + steps: + - checkout + - pip-install-deps: + requirements: "tests/requirements-googlecloud.txt" + - run-tests-with-coverage-report: + googlecloud: "true" + tests: "tests/clients/test_google-cloud-*.py" + - store-pytest-results + - store-coverage-report + python312: docker: - image: cimg/python:3.12.0 @@ -235,6 +254,21 @@ jobs: - store-pytest-results - store-coverage-report + py312googlecloud: + docker: + - image: cimg/python:3.12.0 + - image: vanmoof/pubsub-emulator + working_directory: ~/repo + steps: + - checkout + - pip-install-deps: + requirements: "tests/requirements-googlecloud.txt" + - run-tests-with-coverage-report: + googlecloud: "true" + tests: "tests/clients/test_google-cloud-*.py" + - store-pytest-results + - store-coverage-report + python313: docker: - image: python:3.13.0rc1-bookworm @@ -332,6 +366,8 @@ workflows: - py39cassandra - py39couchbase - py39gevent_starlette + - py311googlecloud + - py312googlecloud - final_job: requires: - python38 @@ -343,3 +379,5 @@ workflows: - py39cassandra - py39couchbase - py39gevent_starlette + - py311googlecloud + - py312googlecloud diff --git a/.tekton/github-pr-pipeline.yaml.part b/.tekton/github-pr-pipeline.yaml.part index b400a3c7..1b4d5313 100644 --- a/.tekton/github-pr-pipeline.yaml.part +++ b/.tekton/github-pr-pipeline.yaml.part @@ -29,6 +29,7 @@ spec: - unittest-cassandra - unittest-couchbase - unittest-gevent-starlette + - unittest-googlecloud taskRef: kind: Task name: github-set-status diff --git a/.tekton/pipeline.yaml b/.tekton/pipeline.yaml index b99b35b3..f0eee35c 100644 --- a/.tekton/pipeline.yaml +++ b/.tekton/pipeline.yaml @@ -84,3 +84,19 @@ spec: workspaces: - name: task-pvc workspace: python-tracer-ci-pipeline-pvc + - name: unittest-googlecloud + runAfter: + - clone + matrix: + params: + - name: imageDigest + value: + # 3.11.9-bookworm + - "sha256:0c2928128a96e544a1ee248e50ee8ecbe840bf48ef5a49065812e3d06b6e1bcc" + # 3.12.4-bookworm + - "sha256:83f5f8714b6881d3e0e91023d9fe9e43aa6ad5a04e9f9a94ee180b18b021c72a" + taskRef: + name: python-tracer-unittest-googlecloud-task + workspaces: + - name: task-pvc + workspace: python-tracer-ci-pipeline-pvc diff --git a/.tekton/run_unittests.sh b/.tekton/run_unittests.sh index 9e1ecd37..dfcc79eb 100755 --- a/.tekton/run_unittests.sh +++ b/.tekton/run_unittests.sh @@ -40,9 +40,13 @@ gevent_starlette) export REQUIREMENTS='requirements-gevent-starlette.txt' export TESTS=('tests/frameworks/test_gevent.py' 'tests/frameworks/test_starlette.py') export GEVENT_STARLETTE_TEST='true' ;; +googlecloud) + export REQUIREMENTS='requirements-googlecloud.txt' + export TESTS=('tests/clients/test_google-cloud-storage.py' 'tests/clients/test_google-cloud-pubsub.py') + export GOOGLE_CLOUD_TEST='true' ;; *) echo "ERROR \$TEST_CONFIGURATION='${TEST_CONFIGURATION}' is unsupported " \ - "not in (default|cassandra|couchbase|gevent_starlette)" >&2 + "not in (default|cassandra|couchbase|gevent_starlette|googlecloud)" >&2 exit 3 ;; esac diff --git a/.tekton/task.yaml b/.tekton/task.yaml index 1d823976..6caa0229 100644 --- a/.tekton/task.yaml +++ b/.tekton/task.yaml @@ -115,12 +115,40 @@ spec: apiVersion: tekton.dev/v1 kind: Task metadata: - name: python-tracer-unittest-default-task + name: python-tracer-unittest-googlecloud-task spec: sidecars: - name: google-cloud-pubsub # vanmoof/pubsub-emulator:latest image: vanmoof/pubsub-emulator@sha256:ff71206d65589b58a8b6928c35349a58dbfd7f20eb2dc7822e0f32e5c40791c8 + env: + - name: PUBSUB_EMULATOR_HOST + value: 0.0.0.0:8085 + ports: + - containerPort: 8085 + hostPort: 8085 + params: + - name: imageDigest + type: string + workspaces: + - name: task-pvc + mountPath: /workspace + steps: + - name: unittest + image: python@$(params.imageDigest) + env: + - name: TEST_CONFIGURATION + value: googlecloud + workingDir: /workspace/python-sensor/ + command: + - /workspace/python-sensor/.tekton/run_unittests.sh +--- +apiVersion: tekton.dev/v1 +kind: Task +metadata: + name: python-tracer-unittest-default-task +spec: + sidecars: - name: mariadb # mariadb:11.3.2 image: mariadb@sha256:851f05fe1e4cb290442c1b12b7108436a33fd8f6a733d4989950322d06d45c65 diff --git a/tests/clients/test_google-cloud-storage.py b/tests/clients/test_google-cloud-storage.py index 3cd59c48..d8762584 100644 --- a/tests/clients/test_google-cloud-storage.py +++ b/tests/clients/test_google-cloud-storage.py @@ -8,13 +8,15 @@ import io from instana.singletons import agent, tracer -from ..test_utils import _TraceContextMixin +from tests.test_utils import _TraceContextMixin from mock import patch, Mock from six.moves import http_client from google.cloud import storage from google.api_core import iam +from google.auth.credentials import AnonymousCredentials + class TestGoogleCloudStorage(unittest.TestCase, _TraceContextMixin): def setUp(self): @@ -22,22 +24,30 @@ def setUp(self): self.recorder.clear_spans() def tearDown(self): - """ Ensure that allow_exit_as_root has the default value """ + """Ensure that allow_exit_as_root has the default value""" agent.options.allow_exit_as_root = False - @unittest.skipIf(sys.platform == "darwin", reason="Raises not Implemented exception in OSX") - @patch('requests.Session.request') + @unittest.skipIf( + sys.platform == "darwin", reason="Raises not Implemented exception in OSX" + ) + @patch("requests.Session.request") def test_buckets_list(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#buckets", "items": []}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): + with tracer.start_active_span("test"): buckets = client.list_buckets() - self.assertEqual(0, self.recorder.queue_size(), msg='span has been created before the actual request') + self.assertEqual( + 0, + self.recorder.queue_size(), + msg="span has been created before the actual request", + ) # trigger the iterator for b in buckets: @@ -53,27 +63,34 @@ def test_buckets_list(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.list', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) + self.assertEqual("buckets.list", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) - - @unittest.skipIf(sys.platform == "darwin", reason="Raises not Implemented exception in OSX") - @patch('requests.Session.request') + @unittest.skipIf( + sys.platform == "darwin", reason="Raises not Implemented exception in OSX" + ) + @patch("requests.Session.request") def test_buckets_list_as_root_exit_span(self, mock_requests): agent.options.allow_exit_as_root = True mock_requests.return_value = self._mock_response( json_content={"kind": "storage#buckets", "items": []}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) buckets = client.list_buckets() - self.assertEqual(0, self.recorder.queue_size(), msg='span has been created before the actual request') + self.assertEqual( + 0, + self.recorder.queue_size(), + msg="span has been created before the actual request", + ) # trigger the iterator for b in buckets: @@ -86,24 +103,25 @@ def test_buckets_list_as_root_exit_span(self, mock_requests): gcs_span = spans[0] - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.list', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) + self.assertEqual("buckets.list", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_insert(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#bucket"}, - status_code=http_client.OK + json_content={"kind": "storage#bucket"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.create_bucket('test bucket') + with tracer.start_active_span("test"): + client.create_bucket("test bucket") spans = self.recorder.queued_spans() @@ -115,25 +133,26 @@ def test_buckets_insert(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.insert', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.insert", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_get(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#bucket"}, - status_code=http_client.OK + json_content={"kind": "storage#bucket"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.get_bucket('test bucket') + with tracer.start_active_span("test"): + client.get_bucket("test bucket") spans = self.recorder.queued_spans() @@ -146,24 +165,25 @@ def test_buckets_get(self, mock_requests): self.assertEqual(test_span.t, gcs_span.t) self.assertEqual(test_span.s, gcs_span.p) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.get', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.get", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_patch(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#bucket"}, - status_code=http_client.OK + json_content={"kind": "storage#bucket"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').patch() + with tracer.start_active_span("test"): + client.bucket("test bucket").patch() spans = self.recorder.queued_spans() @@ -175,24 +195,25 @@ def test_buckets_patch(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.patch', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.patch", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_update(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#bucket"}, - status_code=http_client.OK + json_content={"kind": "storage#bucket"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').update() + with tracer.start_active_span("test"): + client.bucket("test bucket").update() spans = self.recorder.queued_spans() @@ -204,24 +225,25 @@ def test_buckets_update(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.update', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.update", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_get_iam_policy(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#policy"}, - status_code=http_client.OK + json_content={"kind": "storage#policy"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').get_iam_policy() + with tracer.start_active_span("test"): + client.bucket("test bucket").get_iam_policy() spans = self.recorder.queued_spans() @@ -233,24 +255,25 @@ def test_buckets_get_iam_policy(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.getIamPolicy', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.getIamPolicy", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_set_iam_policy(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#policy"}, - status_code=http_client.OK + json_content={"kind": "storage#policy"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').set_iam_policy(iam.Policy()) + with tracer.start_active_span("test"): + client.bucket("test bucket").set_iam_policy(iam.Policy()) spans = self.recorder.queued_spans() @@ -262,24 +285,26 @@ def test_buckets_set_iam_policy(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.setIamPolicy', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.setIamPolicy", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_test_iam_permissions(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#testIamPermissionsResponse"}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').test_iam_permissions('test-permission') + with tracer.start_active_span("test"): + client.bucket("test bucket").test_iam_permissions("test-permission") spans = self.recorder.queued_spans() @@ -291,26 +316,32 @@ def test_buckets_test_iam_permissions(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.testIamPermissions', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.testIamPermissions", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_lock_retention_policy(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#bucket", "metageneration": 1, "retentionPolicy": {"isLocked": False}}, - status_code=http_client.OK + json_content={ + "kind": "storage#bucket", + "metageneration": 1, + "retentionPolicy": {"isLocked": False}, + }, + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - bucket = client.bucket('test bucket') + bucket = client.bucket("test bucket") bucket.reload() - with tracer.start_active_span('test'): + with tracer.start_active_span("test"): bucket.lock_retention_policy() spans = self.recorder.queued_spans() @@ -323,21 +354,23 @@ def test_buckets_lock_retention_policy(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.lockRetentionPolicy', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.lockRetentionPolicy", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_buckets_delete(self, mock_requests): mock_requests.return_value = self._mock_response() - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').delete() + with tracer.start_active_span("test"): + client.bucket("test bucket").delete() spans = self.recorder.queued_spans() @@ -349,27 +382,30 @@ def test_buckets_delete(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('buckets.delete', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("buckets.delete", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_compose(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#object"}, - status_code=http_client.OK + json_content={"kind": "storage#object"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('dest object').compose([ - storage.blob.Blob('object 1', 'test bucket'), - storage.blob.Blob('object 2', 'test bucket') - ]) + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("dest object").compose( + [ + storage.blob.Blob("object 1", "test bucket"), + storage.blob.Blob("object 2", "test bucket"), + ] + ) spans = self.recorder.queued_spans() @@ -381,30 +417,34 @@ def test_objects_compose(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.compose', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["destinationBucket"]) - self.assertEqual('dest object', gcs_span.data["gcs"]["destinationObject"]) - self.assertEqual('test bucket/object 1,test bucket/object 2', gcs_span.data["gcs"]["sourceObjects"]) + self.assertEqual("objects.compose", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["destinationBucket"]) + self.assertEqual("dest object", gcs_span.data["gcs"]["destinationObject"]) + self.assertEqual( + "test bucket/object 1,test bucket/object 2", + gcs_span.data["gcs"]["sourceObjects"], + ) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_copy(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#object"}, - status_code=http_client.OK + json_content={"kind": "storage#object"}, status_code=http_client.OK ) - client = self._client(project='test-project') - bucket = client.bucket('src bucket') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) + bucket = client.bucket("src bucket") - with tracer.start_active_span('test'): + with tracer.start_active_span("test"): bucket.copy_blob( - bucket.blob('src object'), - client.bucket('dest bucket'), - new_name='dest object' + bucket.blob("src object"), + client.bucket("dest bucket"), + new_name="dest object", ) spans = self.recorder.queued_spans() @@ -417,24 +457,26 @@ def test_objects_copy(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.copy', gcs_span.data["gcs"]["op"]) - self.assertEqual('dest bucket', gcs_span.data["gcs"]["destinationBucket"]) - self.assertEqual('dest object', gcs_span.data["gcs"]["destinationObject"]) - self.assertEqual('src bucket', gcs_span.data["gcs"]["sourceBucket"]) - self.assertEqual('src object', gcs_span.data["gcs"]["sourceObject"]) + self.assertEqual("objects.copy", gcs_span.data["gcs"]["op"]) + self.assertEqual("dest bucket", gcs_span.data["gcs"]["destinationBucket"]) + self.assertEqual("dest object", gcs_span.data["gcs"]["destinationObject"]) + self.assertEqual("src bucket", gcs_span.data["gcs"]["sourceBucket"]) + self.assertEqual("src object", gcs_span.data["gcs"]["sourceObject"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_delete(self, mock_requests): mock_requests.return_value = self._mock_response() - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('test object').delete() + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("test object").delete() spans = self.recorder.queued_spans() @@ -446,25 +488,26 @@ def test_objects_delete(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.delete', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) - self.assertEqual('test object', gcs_span.data["gcs"]["object"]) + self.assertEqual("objects.delete", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) + self.assertEqual("test object", gcs_span.data["gcs"]["object"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_attrs(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#object"}, - status_code=http_client.OK + json_content={"kind": "storage#object"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('test object').exists() + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("test object").exists() spans = self.recorder.queued_spans() @@ -476,27 +519,27 @@ def test_objects_attrs(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.attrs', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) - self.assertEqual('test object', gcs_span.data["gcs"]["object"]) + self.assertEqual("objects.attrs", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) + self.assertEqual("test object", gcs_span.data["gcs"]["object"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_get(self, mock_requests): mock_requests.return_value = self._mock_response( - content=b'CONTENT', - status_code=http_client.OK + content=b"CONTENT", status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('test object').download_to_file( - io.BytesIO(), - raw_download=True + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("test object").download_to_file( + io.BytesIO(), raw_download=True ) spans = self.recorder.queued_spans() @@ -509,25 +552,28 @@ def test_objects_get(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.get', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) - self.assertEqual('test object', gcs_span.data["gcs"]["object"]) + self.assertEqual("objects.get", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) + self.assertEqual("test object", gcs_span.data["gcs"]["object"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_insert(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#object"}, - status_code=http_client.OK + json_content={"kind": "storage#object"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('test object').upload_from_string('CONTENT') + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("test object").upload_from_string( + "CONTENT" + ) spans = self.recorder.queued_spans() @@ -539,29 +585,37 @@ def test_objects_insert(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.insert', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) - self.assertEqual('test object', gcs_span.data["gcs"]["object"]) + self.assertEqual("objects.insert", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) + self.assertEqual("test object", gcs_span.data["gcs"]["object"]) - @unittest.skipIf(sys.platform == "darwin", reason="Raises not Implemented exception in OSX") - @patch('requests.Session.request') + @unittest.skipIf( + sys.platform == "darwin", reason="Raises not Implemented exception in OSX" + ) + @patch("requests.Session.request") def test_objects_list(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#object"}, - status_code=http_client.OK + json_content={"kind": "storage#object"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - blobs = client.bucket('test bucket').list_blobs() - self.assertEqual(0, self.recorder.queue_size(), msg='span has been created before the actual request') + with tracer.start_active_span("test"): + blobs = client.bucket("test bucket").list_blobs() + self.assertEqual( + 0, + self.recorder.queue_size(), + msg="span has been created before the actual request", + ) - for b in blobs: pass + for b in blobs: + pass spans = self.recorder.queued_spans() @@ -573,24 +627,25 @@ def test_objects_list(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.list', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("objects.list", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_patch(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#object"}, - status_code=http_client.OK + json_content={"kind": "storage#object"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('test object').patch() + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("test object").patch() spans = self.recorder.queued_spans() @@ -602,26 +657,34 @@ def test_objects_patch(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.patch', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) - self.assertEqual('test object', gcs_span.data["gcs"]["object"]) + self.assertEqual("objects.patch", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) + self.assertEqual("test object", gcs_span.data["gcs"]["object"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_rewrite(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#rewriteResponse", "totalBytesRewritten": 0, "objectSize": 0, "done": True, "resource": {}}, - status_code=http_client.OK + json_content={ + "kind": "storage#rewriteResponse", + "totalBytesRewritten": 0, + "objectSize": 0, + "done": True, + "resource": {}, + }, + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('dest bucket').blob('dest object').rewrite( - client.bucket('src bucket').blob('src object') + with tracer.start_active_span("test"): + client.bucket("dest bucket").blob("dest object").rewrite( + client.bucket("src bucket").blob("src object") ) spans = self.recorder.queued_spans() @@ -634,27 +697,28 @@ def test_objects_rewrite(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.rewrite', gcs_span.data["gcs"]["op"]) - self.assertEqual('dest bucket', gcs_span.data["gcs"]["destinationBucket"]) - self.assertEqual('dest object', gcs_span.data["gcs"]["destinationObject"]) - self.assertEqual('src bucket', gcs_span.data["gcs"]["sourceBucket"]) - self.assertEqual('src object', gcs_span.data["gcs"]["sourceObject"]) + self.assertEqual("objects.rewrite", gcs_span.data["gcs"]["op"]) + self.assertEqual("dest bucket", gcs_span.data["gcs"]["destinationBucket"]) + self.assertEqual("dest object", gcs_span.data["gcs"]["destinationObject"]) + self.assertEqual("src bucket", gcs_span.data["gcs"]["sourceBucket"]) + self.assertEqual("src object", gcs_span.data["gcs"]["sourceObject"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_objects_update(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"kind": "storage#object"}, - status_code=http_client.OK + json_content={"kind": "storage#object"}, status_code=http_client.OK ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('test object').update() + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("test object").update() spans = self.recorder.queued_spans() @@ -666,25 +730,27 @@ def test_objects_update(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objects.update', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) - self.assertEqual('test object', gcs_span.data["gcs"]["object"]) + self.assertEqual("objects.update", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) + self.assertEqual("test object", gcs_span.data["gcs"]["object"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_default_acls_list(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#objectAccessControls", "items": []}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').default_object_acl.get_entities() + with tracer.start_active_span("test"): + client.bucket("test bucket").default_object_acl.get_entities() spans = self.recorder.queued_spans() @@ -696,24 +762,26 @@ def test_default_acls_list(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('defaultAcls.list', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) + self.assertEqual("defaultAcls.list", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_object_acls_list(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#objectAccessControls", "items": []}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.bucket('test bucket').blob('test object').acl.get_entities() + with tracer.start_active_span("test"): + client.bucket("test bucket").blob("test object").acl.get_entities() spans = self.recorder.queued_spans() @@ -725,25 +793,27 @@ def test_object_acls_list(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('objectAcls.list', gcs_span.data["gcs"]["op"]) - self.assertEqual('test bucket', gcs_span.data["gcs"]["bucket"]) - self.assertEqual('test object', gcs_span.data["gcs"]["object"]) + self.assertEqual("objectAcls.list", gcs_span.data["gcs"]["op"]) + self.assertEqual("test bucket", gcs_span.data["gcs"]["bucket"]) + self.assertEqual("test object", gcs_span.data["gcs"]["object"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_object_hmac_keys_create(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#hmacKey", "metadata": {}, "secret": ""}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - client.create_hmac_key('test@example.com') + with tracer.start_active_span("test"): + client.create_hmac_key("test@example.com") spans = self.recorder.queued_spans() @@ -755,21 +825,23 @@ def test_object_hmac_keys_create(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('hmacKeys.create', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) + self.assertEqual("hmacKeys.create", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_object_hmac_keys_delete(self, mock_requests): mock_requests.return_value = self._mock_response() - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - key = storage.hmac_key.HMACKeyMetadata(client, access_id='test key') + with tracer.start_active_span("test"): + key = storage.hmac_key.HMACKeyMetadata(client, access_id="test key") key.state = storage.hmac_key.HMACKeyMetadata.INACTIVE_STATE key.delete() @@ -783,25 +855,27 @@ def test_object_hmac_keys_delete(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('hmacKeys.delete', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) - self.assertEqual('test key', gcs_span.data["gcs"]["accessId"]) + self.assertEqual("hmacKeys.delete", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) + self.assertEqual("test key", gcs_span.data["gcs"]["accessId"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_object_hmac_keys_get(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#hmacKey", "metadata": {}, "secret": ""}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - storage.hmac_key.HMACKeyMetadata(client, access_id='test key').exists() + with tracer.start_active_span("test"): + storage.hmac_key.HMACKeyMetadata(client, access_id="test key").exists() spans = self.recorder.queued_spans() @@ -813,29 +887,38 @@ def test_object_hmac_keys_get(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('hmacKeys.get', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) - self.assertEqual('test key', gcs_span.data["gcs"]["accessId"]) + self.assertEqual("hmacKeys.get", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) + self.assertEqual("test key", gcs_span.data["gcs"]["accessId"]) - @unittest.skipIf(sys.platform == "darwin", reason="Raises not Implemented exception in OSX") - @patch('requests.Session.request') + @unittest.skipIf( + sys.platform == "darwin", reason="Raises not Implemented exception in OSX" + ) + @patch("requests.Session.request") def test_object_hmac_keys_list(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#hmacKeysMetadata", "items": []}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): + with tracer.start_active_span("test"): keys = client.list_hmac_keys() - self.assertEqual(0, self.recorder.queue_size(), msg='span has been created before the actual request') + self.assertEqual( + 0, + self.recorder.queue_size(), + msg="span has been created before the actual request", + ) - for k in keys: pass + for k in keys: + pass spans = self.recorder.queued_spans() @@ -847,24 +930,26 @@ def test_object_hmac_keys_list(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('hmacKeys.list', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) + self.assertEqual("hmacKeys.list", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_object_hmac_keys_update(self, mock_requests): mock_requests.return_value = self._mock_response( json_content={"kind": "storage#hmacKey", "metadata": {}, "secret": ""}, - status_code=http_client.OK + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): - storage.hmac_key.HMACKeyMetadata(client, access_id='test key').update() + with tracer.start_active_span("test"): + storage.hmac_key.HMACKeyMetadata(client, access_id="test key").update() spans = self.recorder.queued_spans() @@ -876,24 +961,29 @@ def test_object_hmac_keys_update(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('hmacKeys.update', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) - self.assertEqual('test key', gcs_span.data["gcs"]["accessId"]) + self.assertEqual("hmacKeys.update", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) + self.assertEqual("test key", gcs_span.data["gcs"]["accessId"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_object_hmac_keys_update(self, mock_requests): mock_requests.return_value = self._mock_response( - json_content={"email_address": "test@example.com", "kind": "storage#serviceAccount"}, - status_code=http_client.OK + json_content={ + "email_address": "test@example.com", + "kind": "storage#serviceAccount", + }, + status_code=http_client.OK, ) - client = self._client(project='test-project') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) - with tracer.start_active_span('test'): + with tracer.start_active_span("test"): client.get_service_account_email() spans = self.recorder.queued_spans() @@ -906,27 +996,29 @@ def test_object_hmac_keys_update(self, mock_requests): self.assertTraceContextPropagated(test_span, gcs_span) - self.assertEqual('gcs',gcs_span.n) + self.assertEqual("gcs", gcs_span.n) self.assertEqual(2, gcs_span.k) self.assertIsNone(gcs_span.ec) - self.assertEqual('serviceAccount.get', gcs_span.data["gcs"]["op"]) - self.assertEqual('test-project', gcs_span.data["gcs"]["projectId"]) + self.assertEqual("serviceAccount.get", gcs_span.data["gcs"]["op"]) + self.assertEqual("test-project", gcs_span.data["gcs"]["projectId"]) - @patch('requests.Session.request') + @patch("requests.Session.request") def test_batch_operation(self, mock_requests): mock_requests.return_value = self._mock_response( _TWO_PART_BATCH_RESPONSE, status_code=http_client.OK, - headers={"content-type": 'multipart/mixed; boundary="DEADBEEF="'} + headers={"content-type": 'multipart/mixed; boundary="DEADBEEF="'}, ) - client = self._client(project='test-project') - bucket = client.bucket('test-bucket') + client = self._client( + credentials=AnonymousCredentials(), project="test-project" + ) + bucket = client.bucket("test-bucket") - with tracer.start_active_span('test'): + with tracer.start_active_span("test"): with client.batch(): - for obj in ['obj1', 'obj2']: + for obj in ["obj1", "obj2"]: bucket.delete_blob(obj) spans = self.recorder.queued_spans() @@ -935,12 +1027,18 @@ def test_batch_operation(self, mock_requests): def _client(self, *args, **kwargs): # override the HTTP client to bypass the authorization - kwargs['_http'] = kwargs.get('_http', requests.Session()) - kwargs['_http'].is_mtls = False + kwargs["_http"] = kwargs.get("_http", requests.Session()) + kwargs["_http"].is_mtls = False return storage.Client(*args, **kwargs) - def _mock_response(self, content=b'', status_code=http_client.NO_CONTENT, json_content=None, headers={}): + def _mock_response( + self, + content=b"", + status_code=http_client.NO_CONTENT, + json_content=None, + headers={}, + ): resp = Mock() resp.status_code = status_code resp.headers = headers @@ -949,13 +1047,14 @@ def _mock_response(self, content=b'', status_code=http_client.NO_CONTENT, json_c resp.__exit__ = Mock() if json_content is not None: - if resp.content == b'': + if resp.content == b"": resp.content = json.dumps(json_content) resp.json = Mock(return_value=json_content) return resp + _TWO_PART_BATCH_RESPONSE = b"""\ --DEADBEEF= Content-Type: application/json diff --git a/tests/conftest.py b/tests/conftest.py index 4e4baa59..d63dea98 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -6,8 +6,8 @@ import sys import pytest -if importlib.util.find_spec('celery'): - pytest_plugins = ("celery.contrib.pytest", ) +if importlib.util.find_spec("celery"): + pytest_plugins = ("celery.contrib.pytest",) # Set our testing flags os.environ["INSTANA_TEST"] = "true" @@ -20,7 +20,7 @@ # Cassandra and gevent tests are run in dedicated jobs on CircleCI and will # be run explicitly. (So always exclude them here) -if not os.environ.get("CASSANDRA_TEST" ): +if not os.environ.get("CASSANDRA_TEST"): collect_ignore_glob.append("*test_cassandra*") if not os.environ.get("COUCHBASE_TEST"): @@ -38,6 +38,10 @@ # tests/opentracing/test_ot_span.py::TestOTSpan::test_stacks # TODO: Remove that once we find a workaround or DROP opentracing! +if sys.version_info >= (3, 11): + if not os.environ.get("GOOGLE_CLOUD_TEST"): + collect_ignore_glob.append("*test_google-cloud*") + if sys.version_info >= (3, 13): # TODO: Test Case failures for unknown reason: collect_ignore_glob.append("*test_aiohttp_server*") @@ -64,22 +68,21 @@ collect_ignore_glob.append("*test_grpcio*") collect_ignore_glob.append("*test_sanic*") -@pytest.fixture(scope='session') + +@pytest.fixture(scope="session") def celery_config(): return { - 'broker_connection_retry_on_startup': True, - 'broker_url': 'redis://localhost:6379', - 'result_backend': 'redis://localhost:6379' + "broker_connection_retry_on_startup": True, + "broker_url": "redis://localhost:6379", + "result_backend": "redis://localhost:6379", } -@pytest.fixture(scope='session') +@pytest.fixture(scope="session") def celery_enable_logging(): return True -@pytest.fixture(scope='session') +@pytest.fixture(scope="session") def celery_includes(): - return { - 'tests.frameworks.test_celery' - } + return {"tests.frameworks.test_celery"} diff --git a/tests/requirements-310.txt b/tests/requirements-310.txt index 13680255..22514153 100644 --- a/tests/requirements-310.txt +++ b/tests/requirements-310.txt @@ -9,7 +9,7 @@ flask>=2.3.2 markupsafe>=2.1.0 grpcio>=1.37.1 google-cloud-pubsub>=2.0.0 -google-cloud-storage<=2.14.0 +google-cloud-storage>=1.24.0 lxml>=4.9.2 mock>=4.0.3 moto>=4.1.2 diff --git a/tests/requirements-312.txt b/tests/requirements-312.txt index 27d7b1f4..8e8aeb34 100644 --- a/tests/requirements-312.txt +++ b/tests/requirements-312.txt @@ -8,8 +8,6 @@ fastapi>=0.92.0 flask>=2.3.2 markupsafe>=2.1.0 grpcio>=1.37.1 -google-cloud-pubsub>=2.0.0 -google-cloud-storage<=2.14.0 lxml>=4.9.2 mock>=4.0.3 moto>=4.1.2 diff --git a/tests/requirements-googlecloud.txt b/tests/requirements-googlecloud.txt new file mode 100644 index 00000000..0ee17b7b --- /dev/null +++ b/tests/requirements-googlecloud.txt @@ -0,0 +1,7 @@ +google-cloud-pubsub>=2.0.0 +google-cloud-storage>=2.15.0 +google-api-core>=2.15.0 +coverage>=5.5 +pytest>=6.2.4 +mock>=4.0.3 +celery>=5.2.7 diff --git a/tests/requirements.txt b/tests/requirements.txt index 1c2597a5..2310401c 100644 --- a/tests/requirements.txt +++ b/tests/requirements.txt @@ -8,7 +8,7 @@ fastapi>=0.92.0 flask>=2.3.2 grpcio>=1.37.1 google-cloud-pubsub>=2.0.0 -google-cloud-storage<=2.14.0 +google-cloud-storage>=1.24.0 lxml>=4.9.2 mock>=4.0.3 moto>=4.1.2