def _read(stub): """Probe to test Read and StreamingRead grpc call from Spanner stub. Args: stub: An object of SpannerStub. Raises: ValueError: An error occurred when read result is not as expected. """ _read_tracer = initialize_tracer() with _read_tracer.span(name='_read'): session = None try: # Create session with _read_tracer.span(name='stub.CreateSession'): session = stub.CreateSession( spanner_pb2.CreateSessionRequest(database=_DATABASE)) # Probing Read call with _read_tracer.span(name='stub.Read'): result_set = stub.Read( spanner_pb2.ReadRequest( session=session.name, table='users', columns=['username', 'firstname', 'lastname'], key_set=keys_pb2.KeySet(all=True))) if result_set is None: raise ValueError('result_set is None') if len(result_set.rows) != 1: raise ValueError('incorrect result_set rows %d' % len(result_set.rows)) if result_set.rows[0].values[0].string_value != _TEST_USERNAME: raise ValueError('incorrect sql result %s' % result_set.rows[0].values[0].string_value) # Probing StreamingRead call with _read_tracer.span(name='stub.StreamingRead'): partial_result_set = stub.StreamingRead( spanner_pb2.ReadRequest( session=session.name, table='users', columns=['username', 'firstname', 'lastname'], key_set=keys_pb2.KeySet(all=True))) if partial_result_set is None: raise ValueError('streaming_result_set is None') with _read_tracer.span(name='partial_result_set.next'): first_result = partial_result_set.next() if first_result.values[0].string_value != _TEST_USERNAME: raise ValueError('incorrect streaming sql first result %s' % first_result.values[0].string_value) finally: if session is not None: with _read_tracer.span(name='stub.DeleteSession'): stub.DeleteSession( spanner_pb2.DeleteSessionRequest(name=session.name))
def test_create_session(self, mock_create_stub): # Mock gRPC layer grpc_stub = mock.Mock() mock_create_stub.return_value = grpc_stub client = spanner_v1.SpannerClient() # Mock request database = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') # Mock response name = 'name3373707' expected_response = {'name': name} expected_response = spanner_pb2.Session(**expected_response) grpc_stub.CreateSession.return_value = expected_response response = client.create_session(database) self.assertEqual(expected_response, response) grpc_stub.CreateSession.assert_called_once() args, kwargs = grpc_stub.CreateSession.call_args self.assertEqual(len(args), 2) self.assertEqual(len(kwargs), 1) self.assertIn('metadata', kwargs) actual_request = args[0] expected_request = spanner_pb2.CreateSessionRequest(database=database) self.assertEqual(expected_request, actual_request)
def _session_management(stub): """Probes to test session related grpc call from Spanner stub. Includes tests against CreateSession, GetSession, ListSessions, and DeleteSession of Spanner stub. Args: stub: An object of SpannerStub. Raises: TypeError: An error occurred when result type is not as expected. ValueError: An error occurred when session name is not as expected. """ _session_management_tracer = initialize_tracer() with _session_management_tracer.span(name='_session_management'): session = None try: # Create session with _session_management_tracer.span(name='stub.CreateSession'): session = stub.CreateSession( spanner_pb2.CreateSessionRequest(database=_DATABASE)) if not isinstance(session, spanner_pb2.Session): raise TypeError( 'response is of type %s, not spanner_pb2.Session!' % type(session)) # Get session with _session_management_tracer.span(name='stub.GetSession'): response = stub.GetSession( spanner_pb2.GetSessionRequest(name=session.name)) if not isinstance(response, spanner_pb2.Session): raise TypeError( 'response is of type %s, not spanner_pb2.Session!' % type(response)) if response.name != session.name: raise ValueError('incorrect session name %s' % response.name) # List session with _session_management_tracer.span(name='stub.ListSessions'): response = stub.ListSessions( spanner_pb2.ListSessionsRequest(database=_DATABASE)) session_list = response.sessions if session.name not in (s.name for s in session_list): raise ValueError( 'session name %s is not in the result session list!' % session.name) finally: if session is not None: # Delete session with _session_management_tracer.span( name='stub.DeleteSession'): stub.DeleteSession( spanner_pb2.DeleteSessionRequest(name=session.name))
def _execute_sql(stub): """Probes to test ExecuteSql and ExecuteStreamingSql call from Spanner stub. Args: stub: An object of SpannerStub. Raises: ValueError: An error occurred when sql result is not as expected. """ _execute_sql_tracer = initialize_tracer() with _execute_sql_tracer.span(name='_execute_sql') as root_span: root_span.add_annotation('endpoint info available', endpoint=_SPANNER_TARGET) session = None try: # Create session with _execute_sql_tracer.span(name='stub.CreateSession'): session = stub.CreateSession( spanner_pb2.CreateSessionRequest(database=_DATABASE)) # Probing ExecuteSql call with _execute_sql_tracer.span(name='stub.ExecuteSql'): result_set = stub.ExecuteSql( spanner_pb2.ExecuteSqlRequest(session=session.name, sql='select * FROM users')) if result_set is None: raise ValueError('result_set is None') if len(result_set.rows) != 1: raise ValueError('incorrect result_set rows %d' % len(result_set.rows)) if result_set.rows[0].values[0].string_value != _TEST_USERNAME: raise ValueError('incorrect sql result %s' % result_set.rows[0].values[0].string_value) # Probing ExecuteStreamingSql call with _execute_sql_tracer.span(name='stub.ExecuteStreamingSql'): partial_result_set = stub.ExecuteStreamingSql( spanner_pb2.ExecuteSqlRequest(session=session.name, sql='select * FROM users')) if partial_result_set is None: raise ValueError('streaming_result_set is None') with _execute_sql_tracer.span(name='partial_result_set.next'): first_result = partial_result_set.next() if first_result.values[0].string_value != _TEST_USERNAME: raise ValueError('incorrect streaming sql first result %s' % first_result.values[0].string_value) finally: if session is not None: with _execute_sql_tracer.span(name='stub.DeleteSession'): stub.DeleteSession( spanner_pb2.DeleteSessionRequest(name=session.name))
def _partition(stub): """Probe to test PartitionQuery and PartitionRead grpc call from Spanner stub. Args: stub: An object of SpannerStub. """ _partition_tracer = initialize_tracer() with _partition_tracer.span(name='_partition') as root_span: root_span.add_annotation('endpoint info available', endpoint=_SPANNER_TARGET) session = None try: with _partition_tracer.span(name='stub.CreateSession'): session = stub.CreateSession( spanner_pb2.CreateSessionRequest(database=_DATABASE)) txn_options = transaction_pb2.TransactionOptions( read_only=transaction_pb2.TransactionOptions.ReadOnly()) txn_selector = transaction_pb2.TransactionSelector( begin=txn_options) # Probing PartitionQuery call ptn_query_request = spanner_pb2.PartitionQueryRequest( session=session.name, sql='select * FROM users', transaction=txn_selector, ) with _partition_tracer.span(name='stub.PartitionQuery'): stub.PartitionQuery(ptn_query_request) # Probing PartitionRead call ptn_read_request = spanner_pb2.PartitionReadRequest( session=session.name, table='users', transaction=txn_selector, key_set=keys_pb2.KeySet(all=True), columns=['username', 'firstname', 'lastname']) with _partition_tracer.span(name='stub.PartitionRead'): stub.PartitionRead(ptn_read_request) finally: if session is not None: with _partition_tracer.span(name='stub.DeleteSession'): stub.DeleteSession( spanner_pb2.DeleteSessionRequest(name=session.name))
def _transaction(stub): """Probe to test BeginTransaction, Commit and Rollback grpc from Spanner stub. Args: stub: An object of SpannerStub. """ _transaction_tracer = initialize_tracer() with _transaction_tracer.span(name='_transaction') as root_span: root_span.add_annotation('endpoint info available', endpoint=_SPANNER_TARGET) session = None try: with _transaction_tracer.span(name='stub.CreateSession'): session = stub.CreateSession( spanner_pb2.CreateSessionRequest(database=_DATABASE)) txn_options = transaction_pb2.TransactionOptions( read_write=transaction_pb2.TransactionOptions.ReadWrite()) txn_request = spanner_pb2.BeginTransactionRequest( session=session.name, options=txn_options, ) # Probing BeginTransaction call with _transaction_tracer.span(name='stub.BeginTransaction'): txn = stub.BeginTransaction(txn_request) # Probing Commit call commit_request = spanner_pb2.CommitRequest(session=session.name, transaction_id=txn.id) with _transaction_tracer.span(name='stub.Commit'): stub.Commit(commit_request) # Probing Rollback call txn = stub.BeginTransaction(txn_request) rollback_request = spanner_pb2.RollbackRequest( session=session.name, transaction_id=txn.id) with _transaction_tracer.span(name='stub.Rollback'): stub.Rollback(rollback_request) finally: if session is not None: with _transaction_tracer.span(name='stub.DeleteSession'): stub.DeleteSession( spanner_pb2.DeleteSessionRequest(name=session.name))
def create_session(self, database, options=None): """ Creates a new session. A session can be used to perform transactions that read and/or modify data in a Cloud Spanner database. Sessions are meant to be reused for many consecutive transactions. Sessions can only execute one transaction at a time. To execute multiple concurrent read-write/write-only transactions, create multiple sessions. Note that standalone reads and queries use a transaction internally, and count toward the one transaction limit. Cloud Spanner limits the number of sessions that can exist at any given time; thus, it is a good idea to delete idle and/or unneeded sessions. Aside from explicit deletes, Cloud Spanner can delete sessions for which no operations are sent for more than an hour. If a session is deleted, requests to it return ``NOT_FOUND``. Idle sessions can be kept alive by sending a trivial SQL query periodically, e.g., ``\"SELECT 1\"``. Example: >>> from google.cloud import spanner_v1 >>> >>> client = spanner_v1.SpannerClient() >>> >>> database = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') >>> >>> response = client.create_session(database) Args: database (str): Required. The database in which the new session is created. options (~google.gax.CallOptions): Overrides the default settings for this call, e.g, timeout, retries etc. Returns: A :class:`~google.cloud.spanner_v1.types.Session` instance. Raises: :exc:`google.gax.errors.GaxError` if the RPC is aborted. :exc:`ValueError` if the parameters are invalid. """ request = spanner_pb2.CreateSessionRequest(database=database) return self._create_session(request, options)
def test_create_session(self): # Setup Expected Response name = 'name3373707' expected_response = {'name': name} expected_response = spanner_pb2.Session(**expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) client = spanner_v1.SpannerClient(channel=channel) # Setup Request database = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') response = client.create_session(database) assert expected_response == response assert len(channel.requests) == 1 expected_request = spanner_pb2.CreateSessionRequest(database=database) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_create_session(self): # Setup Expected Response name = "name3373707" expected_response = {"name": name} expected_response = spanner_pb2.Session(**expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = spanner_v1.SpannerClient() # Setup Request database = client.database_path("[PROJECT]", "[INSTANCE]", "[DATABASE]") response = client.create_session(database) assert expected_response == response assert len(channel.requests) == 1 expected_request = spanner_pb2.CreateSessionRequest(database=database) actual_request = channel.requests[0][1] assert expected_request == actual_request
def create_session(self, database, session=None, retry=google.api_core.gapic_v1.method.DEFAULT, timeout=google.api_core.gapic_v1.method.DEFAULT, metadata=None): """ Creates a new session. A session can be used to perform transactions that read and/or modify data in a Cloud Spanner database. Sessions are meant to be reused for many consecutive transactions. Sessions can only execute one transaction at a time. To execute multiple concurrent read-write/write-only transactions, create multiple sessions. Note that standalone reads and queries use a transaction internally, and count toward the one transaction limit. Cloud Spanner limits the number of sessions that can exist at any given time; thus, it is a good idea to delete idle and/or unneeded sessions. Aside from explicit deletes, Cloud Spanner can delete sessions for which no operations are sent for more than an hour. If a session is deleted, requests to it return ``NOT_FOUND``. Idle sessions can be kept alive by sending a trivial SQL query periodically, e.g., ``\"SELECT 1\"``. Example: >>> from google.cloud import spanner_v1 >>> >>> client = spanner_v1.SpannerClient() >>> >>> database = client.database_path('[PROJECT]', '[INSTANCE]', '[DATABASE]') >>> >>> response = client.create_session(database) Args: database (str): Required. The database in which the new session is created. session (Union[dict, ~google.cloud.spanner_v1.types.Session]): The session to create. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.spanner_v1.types.Session` retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will not be retried. timeout (Optional[float]): The amount of time, in seconds, to wait for the request to complete. Note that if ``retry`` is specified, the timeout applies to each individual attempt. Returns: A :class:`~google.cloud.spanner_v1.types.Session` instance. Raises: google.api_core.exceptions.GoogleAPICallError: If the request failed for any reason. google.api_core.exceptions.RetryError: If the request failed due to a retryable error and retry attempts failed. ValueError: If the parameters are invalid. """ request = spanner_pb2.CreateSessionRequest( database=database, session=session, ) return self._create_session( request, retry=retry, timeout=timeout, metadata=metadata)