Example #1
0
    def from_api_repr(cls, response):
        """Factory: construct representation of operation metadata.

        :type response: dict
        :param response: Dictionary containing operation metadata.

        :rtype: :class:`~google.cloud.speech.metadata.Metadata`
        :returns: Instance of operation Metadata.
        """
        last_update = _rfc3339_to_datetime(response['lastUpdateTime'])
        start_time = _rfc3339_to_datetime(response['startTime'])
        progress_percent = response['progressPercent']

        return cls(last_update, start_time, progress_percent)
    def test_from_api_repr(self):
        import datetime
        from google.cloud._helpers import _rfc3339_to_datetime
        from unit_tests._fixtures import OPERATION_INCOMPLETE_RESPONSE as DATA
        METADATA = DATA['metadata']

        start_time = _rfc3339_to_datetime(METADATA['startTime'])
        last_update = _rfc3339_to_datetime(METADATA['lastUpdateTime'])
        metadata = self._getTargetClass().from_api_repr(METADATA)
        self.assertIsInstance(metadata.last_update, datetime.datetime)
        self.assertEqual(last_update, metadata.last_update)
        self.assertIsInstance(metadata.start_time, datetime.datetime)
        self.assertEqual(start_time, metadata.start_time)
        self.assertEqual(27, metadata.progress_percent)
Example #3
0
    def test_get_variable_w_bound_client(self):
        VARIABLE_NAME = 'my-variable/abcd'
        VARIABLE_PATH = '%s/variables/%s' % (self.CONFIG_PATH, VARIABLE_NAME)
        RESOURCE = {
            'name': VARIABLE_PATH,
            'value': 'bXktdmFyaWFibGUtdmFsdWU=',  # base64 my-variable-value
            'updateTime': '2016-04-14T21:21:54.5000Z',
            'state': 'VARIABLE_STATE_UNSPECIFIED',
        }
        conn = _Connection(RESOURCE)
        client = _Client(project=self.PROJECT, connection=conn)
        config = self._makeOne(name=self.CONFIG_NAME, client=client)

        variable = config.get_variable(VARIABLE_NAME)

        self.assertEqual(variable.name, VARIABLE_NAME)
        self.assertEqual(variable.full_name, VARIABLE_PATH)
        self.assertEqual(variable.update_time,
                         _rfc3339_to_datetime(RESOURCE['updateTime']))
        self.assertEqual(variable.state, RESOURCE['state'])

        self.assertEqual(len(conn._requested), 1)
        req = conn._requested[0]
        self.assertEqual(req['method'], 'GET')
        self.assertEqual(req['path'], '/%s' % (VARIABLE_PATH, ))
Example #4
0
    def _verifyResourceProperties(self, changes, resource, zone):
        from google.cloud._helpers import _rfc3339_to_datetime

        self.assertEqual(changes.name, resource["id"])
        started = _rfc3339_to_datetime(resource["startTime"])
        self.assertEqual(changes.started, started)
        self.assertEqual(changes.status, resource["status"])

        r_additions = resource.get("additions", ())
        self.assertEqual(len(changes.additions), len(r_additions))
        for found, expected in zip(changes.additions, r_additions):
            self.assertEqual(found.name, expected["name"])
            self.assertEqual(found.record_type, expected["type"])
            self.assertEqual(found.ttl, int(expected["ttl"]))
            self.assertEqual(found.rrdatas, expected["rrdatas"])
            self.assertIs(found.zone, zone)

        r_deletions = resource.get("deletions", ())
        self.assertEqual(len(changes.deletions), len(r_deletions))
        for found, expected in zip(changes.deletions, r_deletions):
            self.assertEqual(found.name, expected["name"])
            self.assertEqual(found.record_type, expected["type"])
            self.assertEqual(found.ttl, int(expected["ttl"]))
            self.assertEqual(found.rrdatas, expected["rrdatas"])
            self.assertIs(found.zone, zone)
    def test_get_variable_w_alternate_client(self):
        from google.cloud._helpers import _rfc3339_to_datetime

        VARIABLE_NAME = "my-variable/abcd"
        VARIABLE_PATH = "%s/variables/%s" % (self.CONFIG_PATH, VARIABLE_NAME)
        RESOURCE = {
            "name": VARIABLE_PATH,
            "value": "bXktdmFyaWFibGUtdmFsdWU=",  # base64 my-variable-value
            "updateTime": "2016-04-14T21:21:54.5000Z",
            "state": "VARIABLE_STATE_UNSPECIFIED",
        }
        conn1 = _Connection()
        CLIENT1 = _Client(project=self.PROJECT, connection=conn1)
        conn2 = _Connection(RESOURCE)
        CLIENT2 = _Client(project=self.PROJECT, connection=conn2)
        config = self._make_one(client=CLIENT1, name=self.CONFIG_NAME)

        variable = config.get_variable(VARIABLE_NAME, client=CLIENT2)

        self.assertEqual(variable.name, VARIABLE_NAME)
        self.assertEqual(variable.full_name, VARIABLE_PATH)
        self.assertEqual(variable.update_time,
                         _rfc3339_to_datetime(RESOURCE["updateTime"]))
        self.assertEqual(variable.state, RESOURCE["state"])

        self.assertEqual(len(conn1._requested), 0)
        self.assertEqual(len(conn2._requested), 1)
        req = conn2._requested[0]
        self.assertEqual(req["method"], "GET")
        self.assertEqual(req["path"], "/%s" % (VARIABLE_PATH, ))
    def test_get_variable_w_alternate_client(self):
        from google.cloud._helpers import _rfc3339_to_datetime

        VARIABLE_NAME = 'my-variable/abcd'
        VARIABLE_PATH = '%s/variables/%s' % (self.CONFIG_PATH, VARIABLE_NAME)
        RESOURCE = {
            'name': VARIABLE_PATH,
            'value': 'bXktdmFyaWFibGUtdmFsdWU=',  # base64 my-variable-value
            'updateTime': '2016-04-14T21:21:54.5000Z',
            'state': 'VARIABLE_STATE_UNSPECIFIED',
        }
        conn1 = _Connection()
        CLIENT1 = _Client(project=self.PROJECT, connection=conn1)
        conn2 = _Connection(RESOURCE)
        CLIENT2 = _Client(project=self.PROJECT, connection=conn2)
        config = self._make_one(client=CLIENT1, name=self.CONFIG_NAME)

        variable = config.get_variable(VARIABLE_NAME, client=CLIENT2)

        self.assertEqual(variable.name, VARIABLE_NAME)
        self.assertEqual(variable.full_name, VARIABLE_PATH)
        self.assertEqual(
            variable.update_time,
            _rfc3339_to_datetime(RESOURCE['updateTime']))
        self.assertEqual(variable.state, RESOURCE['state'])

        self.assertEqual(len(conn1._requested), 0)
        self.assertEqual(len(conn2._requested), 1)
        req = conn2._requested[0]
        self.assertEqual(req['method'], 'GET')
        self.assertEqual(req['path'], '/%s' % (VARIABLE_PATH,))
    def test_get_variable_w_alternate_client(self):
        from google.cloud._helpers import _rfc3339_to_datetime

        VARIABLE_NAME = "my-variable/abcd"
        VARIABLE_PATH = "%s/variables/%s" % (self.CONFIG_PATH, VARIABLE_NAME)
        RESOURCE = {
            "name": VARIABLE_PATH,
            "value": "bXktdmFyaWFibGUtdmFsdWU=",  # base64 my-variable-value
            "updateTime": "2016-04-14T21:21:54.5000Z",
            "state": "VARIABLE_STATE_UNSPECIFIED",
        }
        conn1 = _Connection()
        CLIENT1 = _Client(project=self.PROJECT, connection=conn1)
        conn2 = _Connection(RESOURCE)
        CLIENT2 = _Client(project=self.PROJECT, connection=conn2)
        config = self._make_one(client=CLIENT1, name=self.CONFIG_NAME)

        variable = config.get_variable(VARIABLE_NAME, client=CLIENT2)

        self.assertEqual(variable.name, VARIABLE_NAME)
        self.assertEqual(variable.full_name, VARIABLE_PATH)
        self.assertEqual(
            variable.update_time, _rfc3339_to_datetime(RESOURCE["updateTime"])
        )
        self.assertEqual(variable.state, RESOURCE["state"])

        self.assertEqual(len(conn1._requested), 0)
        self.assertEqual(len(conn2._requested), 1)
        req = conn2._requested[0]
        self.assertEqual(req["method"], "GET")
        self.assertEqual(req["path"], "/%s" % (VARIABLE_PATH,))
Example #8
0
    def test_get_variable_w_bound_client(self):
        VARIABLE_NAME = 'my-variable/abcd'
        VARIABLE_PATH = '%s/variables/%s' % (self.CONFIG_PATH, VARIABLE_NAME)
        RESOURCE = {
            'name': VARIABLE_PATH,
            'value': 'bXktdmFyaWFibGUtdmFsdWU=',  # base64 my-variable-value
            'updateTime': '2016-04-14T21:21:54.5000Z',
            'state': 'VARIABLE_STATE_UNSPECIFIED',
        }
        conn = _Connection(RESOURCE)
        client = _Client(project=self.PROJECT, connection=conn)
        config = self._makeOne(name=self.CONFIG_NAME, client=client)

        variable = config.get_variable(VARIABLE_NAME)

        self.assertEqual(variable.name, VARIABLE_NAME)
        self.assertEqual(variable.full_name, VARIABLE_PATH)
        self.assertEqual(
            variable.update_time,
            _rfc3339_to_datetime(RESOURCE['updateTime']))
        self.assertEqual(variable.state, RESOURCE['state'])

        self.assertEqual(len(conn._requested), 1)
        req = conn._requested[0]
        self.assertEqual(req['method'], 'GET')
        self.assertEqual(req['path'], '/%s' % (VARIABLE_PATH,))
Example #9
0
    def started(self):
        """Time when the change set was started.

        :rtype: ``datetime.datetime`` or ``NoneType``
        :returns: Time, as set by the back-end, or None.
        """
        stamp = self._properties.get("startTime")
        if stamp is not None:
            return _rfc3339_to_datetime(stamp)
    def started(self):
        """Time when the change set was started.

        :rtype: ``datetime.datetime`` or ``NoneType``
        :returns: Time, as set by the back-end, or None.
        """
        stamp = self._properties.get('startTime')
        if stamp is not None:
            return _rfc3339_to_datetime(stamp)
Example #11
0
    def updated(self):
        """Retrieve the timestamp at which the HMAC key was created.

        :rtype: :class:`datetime.datetime` or ``NoneType``
        :returns: Datetime object parsed from RFC3339 valid timestamp, or
                  ``None`` if the bucket's resource has not been loaded
                  from the server.
        """
        value = self._properties.get("updated")
        if value is not None:
            return _rfc3339_to_datetime(value)
Example #12
0
    def time_created(self):
        """Retrieve the timestamp at which the bucket was created.

        See: https://cloud.google.com/storage/docs/json_api/v1/buckets

        :rtype: :class:`datetime.datetime` or ``NoneType``
        :returns: Datetime object parsed from RFC3339 valid timestamp, or
                  ``None`` if the property is not set locally.
        """
        value = self._properties.get('timeCreated')
        if value is not None:
            return _rfc3339_to_datetime(value)
Example #13
0
    def _set_properties(self, api_response):
        """Update properties from resource in body of ``api_response``

        :type api_response: dict
        :param api_response: response returned from an API call
        """
        self._properties.clear()
        cleaned = api_response.copy()
        self.dns_name = cleaned.pop("dnsName", None)
        if "creationTime" in cleaned:
            cleaned["creationTime"] = _rfc3339_to_datetime(cleaned["creationTime"])
        self._properties.update(cleaned)
Example #14
0
 def create_zone(_client: Client, _zone: ManagedZone):
     path = f'/projects/{_zone.project}/managedZones'
     data = {'name': _zone.name, 'dnsName': _zone.dns_name + '.', 'description': _zone.description,
             'visibility': 'private'}
     api_response = _client._connection.api_request(method="POST", path=path, data=data)
     _zone._properties.clear()
     cleaned = api_response.copy()
     _zone.dns_name = cleaned.pop("dnsName", None)
     if "creationTime" in cleaned:
         cleaned["creationTime"] = _rfc3339_to_datetime(cleaned["creationTime"])
     _zone._properties.update(cleaned)
     logger.info(f'Created DNS zone: {_zone._properties}')
Example #15
0
    def time_created(self):
        """Retrieve the timestamp at which the bucket was created.

        See: https://cloud.google.com/storage/docs/json_api/v1/buckets

        :rtype: :class:`datetime.datetime` or ``NoneType``
        :returns: Datetime object parsed from RFC3339 valid timestamp, or
                  ``None`` if the property is not set locally.
        """
        value = self._properties.get('timeCreated')
        if value is not None:
            return _rfc3339_to_datetime(value)
Example #16
0
    def _set_properties(self, api_response):
        """Update properties from resource in body of ``api_response``

        :type api_response: httplib2.Response
        :param api_response: response returned from an API call
        """
        self._properties.clear()
        cleaned = api_response.copy()
        self.dns_name = cleaned.pop("dnsName", None)
        if "creationTime" in cleaned:
            cleaned["creationTime"] = _rfc3339_to_datetime(cleaned["creationTime"])
        self._properties.update(cleaned)
Example #17
0
    def time_deleted(self):
        """Retrieve the timestamp at which the object was deleted.

        See: https://cloud.google.com/storage/docs/json_api/v1/objects

        :rtype: :class:`datetime.datetime` or ``NoneType``
        :returns: Datetime object parsed from RFC3339 valid timestamp, or
                  ``None`` if the property is not set locally. If the blob has
                  not been deleted, this will never be set.
        """
        value = self._properties.get('timeDeleted')
        if value is not None:
            return _rfc3339_to_datetime(value)
Example #18
0
    def time_deleted(self):
        """Retrieve the timestamp at which the object was deleted.

        See: https://cloud.google.com/storage/docs/json_api/v1/objects

        :rtype: :class:`datetime.datetime` or ``NoneType``
        :returns: Datetime object parsed from RFC3339 valid timestamp, or
                  ``None`` if the property is not set locally. If the blob has
                  not been deleted, this will never be set.
        """
        value = self._properties.get('timeDeleted')
        if value is not None:
            return _rfc3339_to_datetime(value)
    def test_list_variables_explicit(self):
        import six
        from google.cloud._helpers import _rfc3339_to_datetime
        from google.cloud.runtimeconfig.variable import Variable

        VARIABLE_1 = "variable-one"
        VARIABLE_2 = "variable/two"
        PATH = "projects/%s/configs/%s/variables" % (self.PROJECT,
                                                     self.CONFIG_NAME)
        TOKEN = "TOKEN"
        DATA = {
            "variables": [
                {
                    "name": "%s/%s" % (PATH, VARIABLE_1),
                    "updateTime": "2016-04-14T21:21:54.5000Z",
                },
                {
                    "name": "%s/%s" % (PATH, VARIABLE_2),
                    "updateTime": "2016-04-21T21:21:54.6000Z",
                },
            ]
        }

        conn = _Connection(DATA)
        client = _Client(project=self.PROJECT, connection=conn)
        config = self._make_one(name=self.CONFIG_NAME, client=client)

        iterator = config.list_variables(page_size=3,
                                         page_token=TOKEN,
                                         client=client)
        page = six.next(iterator.pages)
        variables = list(page)
        token = iterator.next_page_token

        self.assertEqual(len(variables), len(DATA["variables"]))
        for found, expected in zip(variables, DATA["variables"]):
            self.assertIsInstance(found, Variable)
            self.assertEqual(found.full_name, expected["name"])
            self.assertEqual(found.update_time,
                             _rfc3339_to_datetime(expected["updateTime"]))
        self.assertIsNone(token)

        self.assertEqual(len(conn._requested), 1)
        req = conn._requested[0]
        self.assertEqual(req["method"], "GET")
        self.assertEqual(req["path"], "/%s" % (PATH, ))
        self.assertEqual(req["query_params"], {
            "pageSize": 3,
            "pageToken": TOKEN
        })
    def test_list_variables_explicit(self):
        import six
        from google.cloud._helpers import _rfc3339_to_datetime
        from google.cloud.runtimeconfig.variable import Variable

        VARIABLE_1 = 'variable-one'
        VARIABLE_2 = 'variable/two'
        PATH = 'projects/%s/configs/%s/variables' % (
            self.PROJECT, self.CONFIG_NAME)
        TOKEN = 'TOKEN'
        DATA = {
            'variables': [
                {'name': '%s/%s' % (PATH, VARIABLE_1),
                 'updateTime': '2016-04-14T21:21:54.5000Z'},
                {'name': '%s/%s' % (PATH, VARIABLE_2),
                 'updateTime': '2016-04-21T21:21:54.6000Z'},
            ]
        }

        conn = _Connection(DATA)
        client = _Client(project=self.PROJECT, connection=conn)
        config = self._make_one(name=self.CONFIG_NAME, client=client)

        iterator = config.list_variables(
            page_size=3,
            page_token=TOKEN,
            client=client)
        page = six.next(iterator.pages)
        variables = list(page)
        token = iterator.next_page_token

        self.assertEqual(len(variables), len(DATA['variables']))
        for found, expected in zip(variables, DATA['variables']):
            self.assertIsInstance(found, Variable)
            self.assertEqual(found.full_name, expected['name'])
            self.assertEqual(
                found.update_time,
                _rfc3339_to_datetime(expected['updateTime']))
        self.assertIsNone(token)

        self.assertEqual(len(conn._requested), 1)
        req = conn._requested[0]
        self.assertEqual(req['method'], 'GET')
        self.assertEqual(req['path'], '/%s' % (PATH,))
        self.assertEqual(
            req['query_params'],
            {
                'pageSize': 3,
                'pageToken': TOKEN,
            })
Example #21
0
    def update_time(self):
        """Retrieve the timestamp at which the variable was updated.

        See:
        https://cloud.google.com/deployment-manager/runtime-configurator/reference/rest/v1beta1/projects.configs.variables

        :rtype: :class:`datetime.datetime` or ``NoneType``
        :returns: Datetime object parsed from RFC3339 valid timestamp, or
                  ``None`` if the property is not set locally.
        """
        value = self._properties.get('updateTime')
        if value is not None:
            value = _rfc3339_to_datetime(value)
        return value
Example #22
0
    def update_time(self):
        """Retrieve the timestamp at which the variable was updated.

        See
        https://cloud.google.com/deployment-manager/runtime-configurator/reference/rest/v1beta1/projects.configs.variables

        :rtype: :class:`datetime.datetime` or ``NoneType``
        :returns: Datetime object parsed from RFC3339 valid timestamp, or
                  ``None`` if the property is not set locally.
        """
        value = self._properties.get('updateTime')
        if value is not None:
            value = _rfc3339_to_datetime(value)
        return value
Example #23
0
    def timestamp(self):
        """Return sortable timestamp from attributes, if passed.

        Allows sorting messages in publication order (assuming consistent
        clocks across all publishers).

        :rtype: :class:`datetime.datetime`
        :returns: timestamp (in UTC timezone) parsed from RFC 3339 timestamp
        :raises: ValueError if timestamp not in ``attributes``, or if it does
                 not match the RFC 3339 format.
        """
        stamp = self.attributes.get('timestamp')
        if stamp is None:
            raise ValueError('No timestamp')
        return _rfc3339_to_datetime(stamp)
    def timestamp(self):
        """Return sortable timestamp from attributes, if passed.

        Allows sorting messages in publication order (assuming consistent
        clocks across all publishers).

        :rtype: :class:`datetime.datetime`
        :returns: timestamp (in UTC timezone) parsed from RFC 3339 timestamp
        :raises: ValueError if timestamp not in ``attributes``, or if it does
                 not match the RFC 3339 format.
        """
        stamp = self.attributes.get('timestamp')
        if stamp is None:
            raise ValueError('No timestamp')
        return _rfc3339_to_datetime(stamp)
    def test_list_variables_defaults(self):
        import six
        from google.cloud._helpers import _rfc3339_to_datetime
        from google.cloud.runtimeconfig.variable import Variable

        VARIABLE_1 = "variable-one"
        VARIABLE_2 = "variable/two"
        PATH = "projects/%s/configs/%s/variables" % (self.PROJECT, self.CONFIG_NAME)
        TOKEN = "TOKEN"
        DATA = {
            "nextPageToken": TOKEN,
            "variables": [
                {
                    "name": "%s/%s" % (PATH, VARIABLE_1),
                    "updateTime": "2016-04-14T21:21:54.5000Z",
                },
                {
                    "name": "%s/%s" % (PATH, VARIABLE_2),
                    "updateTime": "2016-04-21T21:21:54.6000Z",
                },
            ],
        }

        conn = _Connection(DATA)
        client = _Client(project=self.PROJECT, connection=conn)
        config = self._make_one(name=self.CONFIG_NAME, client=client)

        iterator = config.list_variables()
        page = six.next(iterator.pages)
        variables = list(page)
        token = iterator.next_page_token

        self.assertEqual(len(variables), len(DATA["variables"]))
        for found, expected in zip(variables, DATA["variables"]):
            self.assertIsInstance(found, Variable)
            self.assertEqual(found.full_name, expected["name"])
            self.assertEqual(
                found.update_time, _rfc3339_to_datetime(expected["updateTime"])
            )
        self.assertEqual(token, TOKEN)

        self.assertEqual(len(conn._requested), 1)
        req = conn._requested[0]
        self.assertEqual(req["method"], "GET")
        self.assertEqual(req["path"], "/%s" % (PATH,))
        self.assertNotIn("filter", req["query_params"])
Example #26
0
    def _verifyResourceProperties(self, variable, resource):
        if 'name' in resource:
            self.assertEqual(variable.full_name, resource['name'])

        if 'value' in resource:
            self.assertEqual(
                variable.value, base64.b64decode(resource['value']))
        else:
            self.assertIsNone(variable.value)

        if 'state' in resource:
            self.assertEqual(variable.state, resource['state'])

        if 'updateTime' in resource:
            self.assertEqual(
                variable.update_time,
                _rfc3339_to_datetime(resource['updateTime']))
        else:
            self.assertIsNone(variable.update_time)
Example #27
0
    def _verifyResourceProperties(self, variable, resource):
        import base64
        from google.cloud._helpers import _rfc3339_to_datetime

        if "name" in resource:
            self.assertEqual(variable.full_name, resource["name"])

        if "value" in resource:
            self.assertEqual(variable.value, base64.b64decode(resource["value"]))
        else:
            self.assertIsNone(variable.value)

        if "state" in resource:
            self.assertEqual(variable.state, resource["state"])

        if "updateTime" in resource:
            self.assertEqual(variable.update_time, _rfc3339_to_datetime(resource["updateTime"]))
        else:
            self.assertIsNone(variable.update_time)
Example #28
0
    def _verifyResourceProperties(self, variable, resource):
        import base64
        from google.cloud._helpers import _rfc3339_to_datetime

        if 'name' in resource:
            self.assertEqual(variable.full_name, resource['name'])

        if 'value' in resource:
            self.assertEqual(variable.value,
                             base64.b64decode(resource['value']))
        else:
            self.assertIsNone(variable.value)

        if 'state' in resource:
            self.assertEqual(variable.state, resource['state'])

        if 'updateTime' in resource:
            self.assertEqual(variable.update_time,
                             _rfc3339_to_datetime(resource['updateTime']))
        else:
            self.assertIsNone(variable.update_time)
Example #29
0
    def _verifyResourceProperties(self, changes, resource, zone):
        from google.cloud._helpers import _rfc3339_to_datetime
        self.assertEqual(changes.name, resource['id'])
        started = _rfc3339_to_datetime(resource['startTime'])
        self.assertEqual(changes.started, started)
        self.assertEqual(changes.status, resource['status'])

        r_additions = resource.get('additions', ())
        self.assertEqual(len(changes.additions), len(r_additions))
        for found, expected in zip(changes.additions, r_additions):
            self.assertEqual(found.name, expected['name'])
            self.assertEqual(found.record_type, expected['type'])
            self.assertEqual(found.ttl, int(expected['ttl']))
            self.assertEqual(found.rrdatas, expected['rrdatas'])
            self.assertTrue(found.zone is zone)

        r_deletions = resource.get('deletions', ())
        self.assertEqual(len(changes.deletions), len(r_deletions))
        for found, expected in zip(changes.deletions, r_deletions):
            self.assertEqual(found.name, expected['name'])
            self.assertEqual(found.record_type, expected['type'])
            self.assertEqual(found.ttl, int(expected['ttl']))
            self.assertEqual(found.rrdatas, expected['rrdatas'])
            self.assertTrue(found.zone is zone)
Example #30
0
    def _call_fut(self, dt_str):
        from google.cloud._helpers import _rfc3339_to_datetime

        return _rfc3339_to_datetime(dt_str)
    def test_list_traces(self):
        from google.cloud._helpers import _rfc3339_to_datetime
        from google.cloud._helpers import UTC
        from google.cloud.trace_v1.gapic import trace_service_client
        from google.cloud.trace_v1.gapic.enums import ListTracesRequest as Enum
        from google.cloud.trace_v1.proto import trace_pb2

        trace_id = "test_trace_id"
        span_id = 1234
        span_name = "test_span_name"
        span_kind = "RPC_CLIENT"
        parent_span_id = 123
        start_ts = datetime.datetime.utcnow()
        end_ts = datetime.datetime.utcnow()
        labels = {
            "/http/status_code": "200",
            "/component": "HTTP load balancer"
        }
        size = 10
        view_type = Enum.ViewType.COMPLETE
        token = "TOKEN"

        trace_pb = self._make_trace_pb(
            self.project,
            trace_id,
            span_id,
            span_name,
            start_ts.isoformat() + "Z",
            end_ts.isoformat() + "Z",
            parent_span_id,
            labels,
        )

        gapic_api = mock.Mock(spec=trace_service_client.TraceServiceClient)
        gapic_api.list_traces = mock.create_autospec(gapic_api.list_traces)
        channel, api = self._make_one()

        channel.ListTraces.response = trace_pb2.ListTracesResponse(
            traces=[trace_pb[0]])
        iterator = api.list_traces(project_id=self.project,
                                   view=view_type,
                                   page_size=size,
                                   page_token=token)

        traces = list(iterator)

        self.assertEqual(len(traces), 1)
        trace = traces[0]

        self.assertEqual(len(trace["spans"]), 1)
        span = trace["spans"][0]

        self.assertEqual(trace["projectId"], self.project)
        self.assertEqual(trace["traceId"], trace_id)

        self.assertEqual(span["spanId"], str(span_id))
        self.assertEqual(span["name"], span_name)

        self.assertEqual(_rfc3339_to_datetime(span["startTime"]),
                         start_ts.replace(tzinfo=UTC))
        self.assertEqual(_rfc3339_to_datetime(span["endTime"]),
                         end_ts.replace(tzinfo=UTC))
        self.assertEqual(span["kind"], span_kind)
        self.assertEqual(span["parentSpanId"], str(parent_span_id))
        self.assertEqual(span["labels"], labels)

        self.assertEqual(len(channel.ListTraces.requests), 1)
        request = channel.ListTraces.requests[0]

        self.assertEqual(request.project_id, self.project)
        self.assertEqual(request.view, view_type)
        self.assertEqual(request.page_size, size)
        self.assertEqual(request.start_time.ToDatetime(),
                         datetime.datetime(1970, 1, 1, 0, 0))
        self.assertEqual(request.end_time.ToDatetime(),
                         datetime.datetime(1970, 1, 1, 0, 0))
        self.assertEqual(request.filter, "")
        self.assertEqual(request.order_by, "")
    def test_list_traces(self):
        from google.cloud._helpers import _rfc3339_to_datetime
        from google.cloud._helpers import UTC
        from google.cloud.trace_v1.gapic import trace_service_client
        from google.cloud.trace_v1.gapic.enums import ListTracesRequest as Enum
        from google.cloud.trace_v1.proto import trace_pb2

        trace_id = 'test_trace_id'
        span_id = 1234
        span_name = 'test_span_name'
        span_kind = 'RPC_CLIENT'
        parent_span_id = 123
        start_ts = datetime.datetime.utcnow()
        end_ts = datetime.datetime.utcnow()
        labels = {
            '/http/status_code': '200',
            '/component': 'HTTP load balancer',
        }
        size = 10
        view_type = Enum.ViewType.COMPLETE
        token = 'TOKEN'

        trace_pb = self._make_trace_pb(
            self.project,
            trace_id,
            span_id,
            span_name,
            start_ts.isoformat() + 'Z',
            end_ts.isoformat() + 'Z',
            parent_span_id,
            labels)

        gapic_api = mock.Mock(spec=trace_service_client.TraceServiceClient)
        gapic_api.list_traces = mock.create_autospec(gapic_api.list_traces)
        channel, api = self._make_one()

        channel.ListTraces.response = trace_pb2.ListTracesResponse(
            traces=[trace_pb[0]])
        iterator = api.list_traces(
            project_id=self.project,
            view=view_type,
            page_size=size,
            page_token=token)

        traces = list(iterator)

        self.assertEqual(len(traces), 1)
        trace = traces[0]

        self.assertEqual(len(trace['spans']), 1)
        span = trace['spans'][0]

        self.assertEqual(trace['projectId'], self.project)
        self.assertEqual(trace['traceId'], trace_id)

        self.assertEqual(span['spanId'], str(span_id))
        self.assertEqual(span['name'], span_name)

        self.assertEqual(
            _rfc3339_to_datetime(span['startTime']),
            start_ts.replace(tzinfo=UTC))
        self.assertEqual(
            _rfc3339_to_datetime(span['endTime']),
            end_ts.replace(tzinfo=UTC))
        self.assertEqual(span['kind'], span_kind)
        self.assertEqual(span['parentSpanId'], str(parent_span_id))
        self.assertEqual(span['labels'], labels)

        self.assertEqual(len(channel.ListTraces.requests), 1)
        request = channel.ListTraces.requests[0]

        self.assertEqual(request.project_id, self.project)
        self.assertEqual(request.view, view_type)
        self.assertEqual(request.page_size, size)
        self.assertEqual(
            request.start_time.ToDatetime(),
            datetime.datetime(1970, 1, 1, 0, 0))
        self.assertEqual(
            request.end_time.ToDatetime(),
            datetime.datetime(1970, 1, 1, 0, 0))
        self.assertEqual(request.filter, '')
        self.assertEqual(request.order_by, '')
    def _call_fut(self, dt_str):
        from google.cloud._helpers import _rfc3339_to_datetime

        return _rfc3339_to_datetime(dt_str)
Example #34
0
    def test_list_traces_with_paging(self):
        from google.cloud._helpers import _rfc3339_to_datetime
        from google.cloud._helpers import UTC
        from google.cloud._testing import _GAXPageIterator
        from google.cloud.gapic.trace.v1 import trace_service_client
        from google.cloud.gapic.trace.v1.enums import ListTracesRequest as Enum

        trace_id = 'test_trace_id'
        span_id = 1234
        span_name = 'test_span_name'
        span_kind = 'RPC_CLIENT'
        parent_span_id = 123
        start_ts = datetime.datetime.utcnow()
        end_ts = datetime.datetime.utcnow()
        labels = {
            '/http/status_code': '200',
            '/component': 'HTTP load balancer',
        }
        size = 10
        view_type = Enum.ViewType.COMPLETE
        token = 'TOKEN'

        trace_pb = self._make_trace_pb(self.project, trace_id, span_id,
                                       span_name,
                                       start_ts.isoformat() + 'Z',
                                       end_ts.isoformat() + 'Z',
                                       parent_span_id, labels)

        response = _GAXPageIterator(trace_pb)
        gax_api = mock.Mock(spec=trace_service_client.TraceServiceClient)
        gax_api.list_traces.return_value = response
        api = self._make_one(gax_api, None)

        iterator = api.list_traces(project_id=self.project,
                                   view=view_type,
                                   page_size=size,
                                   page_token=token)

        traces = list(iterator)

        self.assertEqual(len(traces), 1)
        trace = traces[0]

        self.assertEqual(len(trace['spans']), 1)
        span = trace['spans'][0]

        self.assertEqual(trace['projectId'], self.project)
        self.assertEqual(trace['traceId'], trace_id)

        self.assertEqual(span['spanId'], str(span_id))
        self.assertEqual(span['name'], span_name)

        self.assertEqual(_rfc3339_to_datetime(span['startTime']),
                         start_ts.replace(tzinfo=UTC))
        self.assertEqual(_rfc3339_to_datetime(span['endTime']),
                         end_ts.replace(tzinfo=UTC))
        self.assertEqual(span['kind'], span_kind)
        self.assertEqual(span['parentSpanId'], str(parent_span_id))
        self.assertEqual(span['labels'], labels)

        call_args = gax_api.list_traces.call_args[1]

        self.assertEqual(call_args['project_id'], self.project)
        self.assertEqual(call_args['view'], view_type)
        self.assertEqual(call_args['page_size'], size)
        self.assertIsNone(call_args['start_time'])
        self.assertIsNone(call_args['end_time'])
        self.assertIsNone(call_args['filter_'])
        self.assertIsNone(call_args['order_by'])
        self.assertEqual(call_args['options'].page_token, token)
    def test_list_traces(self):
        from google.api_core.page_iterator import GRPCIterator
        from google.cloud._helpers import _rfc3339_to_datetime
        from google.cloud._helpers import UTC
        from google.cloud.trace_v1.gapic import trace_service_client
        from google.cloud.trace_v1.gapic.enums import ListTracesRequest as Enum
        from google.cloud.trace_v1.proto import trace_pb2

        trace_id = 'test_trace_id'
        span_id = 1234
        span_name = 'test_span_name'
        span_kind = 'RPC_CLIENT'
        parent_span_id = 123
        start_ts = datetime.datetime.utcnow()
        end_ts = datetime.datetime.utcnow()
        labels = {
            '/http/status_code': '200',
            '/component': 'HTTP load balancer',
        }
        size = 10
        view_type = Enum.ViewType.COMPLETE
        token = 'TOKEN'

        trace_pb = self._make_trace_pb(self.project, trace_id, span_id,
                                       span_name,
                                       start_ts.isoformat() + 'Z',
                                       end_ts.isoformat() + 'Z',
                                       parent_span_id, labels)

        gapic_api = mock.Mock(spec=trace_service_client.TraceServiceClient)
        gapic_api.list_traces = mock.create_autospec(gapic_api.list_traces)
        channel, api = self._make_one()

        channel.ListTraces.response = trace_pb2.ListTracesResponse(
            traces=[trace_pb[0]])
        iterator = api.list_traces(project_id=self.project,
                                   view=view_type,
                                   page_size=size,
                                   page_token=token)

        traces = list(iterator)

        self.assertEqual(len(traces), 1)
        trace = traces[0]

        self.assertEqual(len(trace['spans']), 1)
        span = trace['spans'][0]

        self.assertEqual(trace['projectId'], self.project)
        self.assertEqual(trace['traceId'], trace_id)

        self.assertEqual(span['spanId'], str(span_id))
        self.assertEqual(span['name'], span_name)

        self.assertEqual(_rfc3339_to_datetime(span['startTime']),
                         start_ts.replace(tzinfo=UTC))
        self.assertEqual(_rfc3339_to_datetime(span['endTime']),
                         end_ts.replace(tzinfo=UTC))
        self.assertEqual(span['kind'], span_kind)
        self.assertEqual(span['parentSpanId'], str(parent_span_id))
        self.assertEqual(span['labels'], labels)

        self.assertEqual(len(channel.ListTraces.requests), 1)
        request = channel.ListTraces.requests[0]

        self.assertEqual(request.project_id, self.project)
        self.assertEqual(request.view, view_type)
        self.assertEqual(request.page_size, size)
        self.assertEqual(request.start_time.ToDatetime(),
                         datetime.datetime(1970, 1, 1, 0, 0))
        self.assertEqual(request.end_time.ToDatetime(),
                         datetime.datetime(1970, 1, 1, 0, 0))
        self.assertEqual(request.filter, '')
        self.assertEqual(request.order_by, '')