diff --git a/Core/src/Testing/Snippet/SnippetTestCase.php b/Core/src/Testing/Snippet/SnippetTestCase.php
index bda2a03037a3..9b343dc657f6 100644
--- a/Core/src/Testing/Snippet/SnippetTestCase.php
+++ b/Core/src/Testing/Snippet/SnippetTestCase.php
@@ -32,6 +32,8 @@
  */
 class SnippetTestCase extends TestCase
 {
+    const PROJECT = 'my-awesome-project';
+
     use CheckForClassTrait;
 
     private static $coverage;
diff --git a/Core/tests/Unit/Batch/OpisClosureSerializerTest.php b/Core/tests/Unit/Batch/OpisClosureSerializerTest.php
index edf4906cb089..4aadcacc7d9e 100644
--- a/Core/tests/Unit/Batch/OpisClosureSerializerTest.php
+++ b/Core/tests/Unit/Batch/OpisClosureSerializerTest.php
@@ -25,12 +25,13 @@
 /**
  * @group core
  * @group batch
+ * @runTestsInSeparateProcesses
  */
 class OpisClosureSerializerTest extends TestCase
 {
     public function testWrapAndUnwrapClosures()
     {
-        if (!method_exists(SerializableClosure::class, 'enterContext')) {
+        if (!@method_exists(SerializableClosure::class, 'enterContext')) {
             $this->markTestSkipped('Requires ops/serializer:v3');
         }
 
@@ -49,8 +50,8 @@ public function testWrapAndUnwrapClosures()
 
     public function testWrapAndUnwrapClosuresV4()
     {
-        if (!function_exists('Opis\Closure\serialize')) {
-            $this->markTestSkipped('Requires ops/serializer:v3');
+        if (@method_exists(SerializableClosure::class, 'enterContext')) {
+            $this->markTestSkipped('Requires ops/serializer:v4');
         }
 
         $data['closure'] = function () {
diff --git a/Core/tests/Unit/Lock/FlockLockTest.php b/Core/tests/Unit/Lock/FlockLockTest.php
index 621c492fd532..833aa1f65096 100644
--- a/Core/tests/Unit/Lock/FlockLockTest.php
+++ b/Core/tests/Unit/Lock/FlockLockTest.php
@@ -25,6 +25,7 @@
 /**
  * @group core
  * @group lock
+ * @runTestsInSeparateProcesses
  */
 class FlockLockTest extends TestCase
 {
diff --git a/Core/tests/Unit/Lock/SemaphoreLockTest.php b/Core/tests/Unit/Lock/SemaphoreLockTest.php
index 10a988b6b664..8b6a23c7e520 100644
--- a/Core/tests/Unit/Lock/SemaphoreLockTest.php
+++ b/Core/tests/Unit/Lock/SemaphoreLockTest.php
@@ -26,6 +26,7 @@
 /**
  * @group core
  * @group lock
+ * @runTestsInSeparateProcesses
  */
 class SemaphoreLockTest extends TestCase
 {
diff --git a/Datastore/tests/Snippet/FilterTest.php b/Datastore/tests/Snippet/FilterTest.php
index 52642a1627d7..eb1f7a5c3acc 100644
--- a/Datastore/tests/Snippet/FilterTest.php
+++ b/Datastore/tests/Snippet/FilterTest.php
@@ -24,7 +24,7 @@ class FilterTest extends SnippetTestCase
     use ProphecyTrait;
     use ProtoEncodeTrait;
 
-    private const PROJECT = 'alpha-project';
+    const PROJECT = 'alpha-project';
     private $gapicClient;
     private $datastore;
     private $operation;
diff --git a/PubSub/tests/Snippet/PubSubClientTest.php b/PubSub/tests/Snippet/PubSubClientTest.php
index 00dd2ecaff05..1e9d77067217 100644
--- a/PubSub/tests/Snippet/PubSubClientTest.php
+++ b/PubSub/tests/Snippet/PubSubClientTest.php
@@ -43,7 +43,7 @@ class PubSubClientTest extends SnippetTestCase
 {
     use ProphecyTrait;
 
-    private const PROJECT_ID = 'my-awesome-project';
+    const PROJECT_ID = 'my-awesome-project';
     private const TOPIC = 'projects/my-awesome-project/topics/my-new-topic';
     private const SUBSCRIPTION = 'projects/my-awesome-project/subscriptions/my-new-subscription';
     private const SNAPSHOT = 'projects/my-awesome-project/snapshots/my-snapshot';
diff --git a/PubSub/tests/Snippet/SnapshotTest.php b/PubSub/tests/Snippet/SnapshotTest.php
index adc6aab6fa17..edbc93a1aa39 100644
--- a/PubSub/tests/Snippet/SnapshotTest.php
+++ b/PubSub/tests/Snippet/SnapshotTest.php
@@ -38,7 +38,7 @@ class SnapshotTest extends SnippetTestCase
     use ProphecyTrait;
     use ApiHelperTrait;
 
-    private const PROJECT = 'my-awesome-project';
+    const PROJECT = 'my-awesome-project';
     private const SNAPSHOT = 'projects/my-awesome-project/snapshots/my-snapshot';
     private const PROJECT_ID = 'my-awesome-project';
 
diff --git a/Spanner/composer.json b/Spanner/composer.json
index 8d2fdf36d700..0b35c30e955f 100644
--- a/Spanner/composer.json
+++ b/Spanner/composer.json
@@ -10,9 +10,9 @@
         "google/gax": "^1.38.0"
     },
     "require-dev": {
-        "phpunit/phpunit": "^9.0",
-        "phpspec/prophecy-phpunit": "^2.0",
-        "squizlabs/php_codesniffer": "2.*",
+        "phpunit/phpunit": "^9.6",
+        "phpspec/prophecy-phpunit": "^2.1",
+        "squizlabs/php_codesniffer": "3.*",
         "phpdocumentor/reflection": "^5.3.3||^6.0",
         "phpdocumentor/reflection-docblock": "^5.3",
         "erusev/parsedown": "^1.6",
diff --git a/Spanner/src/Backup.php b/Spanner/src/Backup.php
index b9072e409431..5dc51ff50089 100644
--- a/Spanner/src/Backup.php
+++ b/Spanner/src/Backup.php
@@ -21,6 +21,7 @@
 use DateTimeInterface;
 use Google\ApiCore\Options\CallOptions;
 use Google\ApiCore\ValidationException;
+use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\Exception\NotFoundException;
 use Google\Cloud\Core\Iterator\ItemIterator;
 use Google\Cloud\Core\LongRunning\LongRunningClientConnection;
@@ -51,6 +52,7 @@
 class Backup
 {
     use RequestTrait;
+    use ApiHelperTrait;
 
     const STATE_READY = State::READY;
     const STATE_CREATING = State::CREATING;
@@ -372,22 +374,17 @@ public function state(array $options = []): int|null
      */
     public function updateExpireTime(DateTimeInterface $newTimestamp, array $options = []): array
     {
-        $options += [
-            'backup' => [
-                'name' => $this->name(),
-                'expireTime' => $this->formatTimeAsArray($newTimestamp),
-            ],
-            'updateMask' => [
-                'paths' => ['expire_time']
-            ]
-        ];
+        $options['expireTime'] = $this->formatTimeAsArray($newTimestamp);
 
         /**
          * @var UpdateBackupRequest $updateBackup
          * @var array $callOptions
          */
         [$updateBackup, $callOptions] = $this->validateOptions(
-            $options,
+            [
+                'backup' => $options + ['name' => $this->name()],
+                'updateMask' => $this->fieldMask($options),
+            ],
             new UpdateBackupRequest(),
             CallOptions::class,
         );
diff --git a/Spanner/src/Database.php b/Spanner/src/Database.php
index 885166a3ae6a..bc745ea4a19f 100644
--- a/Spanner/src/Database.php
+++ b/Spanner/src/Database.php
@@ -17,6 +17,7 @@
 
 namespace Google\Cloud\Spanner;
 
+use BadMethodCallException;
 use Closure;
 use DateTimeInterface;
 use Generator;
@@ -24,6 +25,7 @@
 use Google\ApiCore\Options\CallOptions;
 use Google\ApiCore\RetrySettings;
 use Google\ApiCore\ValidationException;
+use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\Exception\AbortedException;
 use Google\Cloud\Core\Exception\NotFoundException;
 use Google\Cloud\Core\Exception\ServiceException;
@@ -55,13 +57,10 @@
 use Google\Cloud\Spanner\V1\Mutation;
 use Google\Cloud\Spanner\V1\Mutation\Delete;
 use Google\Cloud\Spanner\V1\Mutation\Write;
-use Google\Cloud\Spanner\V1\TransactionOptions;
 use Google\Cloud\Spanner\V1\TransactionOptions\IsolationLevel;
 use Google\Cloud\Spanner\V1\TypeCode;
 use Google\LongRunning\ListOperationsRequest;
 use Google\LongRunning\Operation as OperationProto;
-use Google\Protobuf\Duration;
-use Google\Protobuf\ListValue;
 use Google\Protobuf\Struct;
 use Google\Protobuf\Value;
 use Google\Rpc\Code;
@@ -91,31 +90,35 @@
  */
 class Database
 {
+    use ApiHelperTrait;
     use TransactionConfigurationTrait;
     use RequestTrait;
 
-    const STATE_CREATING = State::CREATING;
-    const STATE_READY = State::READY;
-    const STATE_READY_OPTIMIZING = State::READY_OPTIMIZING;
-    const MAX_RETRIES = 10;
-
-    const TYPE_BOOL = TypeCode::BOOL;
-    const TYPE_INT64 = TypeCode::INT64;
-    const TYPE_FLOAT32 = TypeCode::FLOAT32;
-    const TYPE_FLOAT64 = TypeCode::FLOAT64;
-    const TYPE_TIMESTAMP = TypeCode::TIMESTAMP;
-    const TYPE_DATE = TypeCode::DATE;
-    const TYPE_STRING = TypeCode::STRING;
-    const TYPE_BYTES = TypeCode::BYTES;
-    const TYPE_ARRAY = TypeCode::PBARRAY;
-    const TYPE_STRUCT = TypeCode::STRUCT;
-    const TYPE_NUMERIC = TypeCode::NUMERIC;
-    const TYPE_PROTO = TypeCode::PROTO;
-    const TYPE_PG_NUMERIC = 'pgNumeric';
-    const TYPE_PG_JSONB = 'pgJsonb';
-    const TYPE_JSON = TypeCode::JSON;
-    const TYPE_PG_OID = 'pgOid';
-    const TYPE_INTERVAL = TypeCode::INTERVAL;
+    public const CONTEXT_READ = 'r';
+    public const CONTEXT_READWRITE = 'rw';
+
+    public const STATE_CREATING = State::CREATING;
+    public const STATE_READY = State::READY;
+    public const STATE_READY_OPTIMIZING = State::READY_OPTIMIZING;
+    public const MAX_RETRIES = 10;
+
+    public const TYPE_BOOL = TypeCode::BOOL;
+    public const TYPE_INT64 = TypeCode::INT64;
+    public const TYPE_FLOAT32 = TypeCode::FLOAT32;
+    public const TYPE_FLOAT64 = TypeCode::FLOAT64;
+    public const TYPE_TIMESTAMP = TypeCode::TIMESTAMP;
+    public const TYPE_DATE = TypeCode::DATE;
+    public const TYPE_STRING = TypeCode::STRING;
+    public const TYPE_BYTES = TypeCode::BYTES;
+    public const TYPE_ARRAY = TypeCode::PBARRAY;
+    public const TYPE_STRUCT = TypeCode::STRUCT;
+    public const TYPE_NUMERIC = TypeCode::NUMERIC;
+    public const TYPE_PROTO = TypeCode::PROTO;
+    public const TYPE_PG_NUMERIC = 'pgNumeric';
+    public const TYPE_PG_JSONB = 'pgJsonb';
+    public const TYPE_JSON = TypeCode::JSON;
+    public const TYPE_PG_OID = 'pgOid';
+    public const TYPE_INTERVAL = TypeCode::INTERVAL;
 
     private Operation $operation;
     private IamManager|null $iam = null;
@@ -128,18 +131,6 @@ class Database
     private bool $returnInt64AsObject;
     private SessionPoolInterface|null $sessionPool;
     private array $info;
-
-    private const MUTATION_SETTERS = [
-        'insert' => 'setInsert',
-        'update' => 'setUpdate',
-        'insertOrUpdate' => 'setInsertOrUpdate',
-        'replace' => 'setReplace',
-        'delete' => 'setDelete'
-    ];
-
-    /**
-     * @var int
-     */
     private int $isolationLevel;
 
     /**
@@ -484,25 +475,15 @@ public function restore(Backup|string $backup, array $options = []): LongRunning
      */
     public function updateDatabase(array $options = []): LongRunningOperation
     {
-        $fieldMask = [];
-        if (isset($options['enableDropProtection'])) {
-            $fieldMask[] = 'enable_drop_protection';
-        }
-        $options += [
-            'updateMask' => ['paths' => $fieldMask],
-            'database' => [
-                'name' => $this->name,
-                'enableDropProtection' =>
-                    $this->pluck('enableDropProtection', $options, false) ?: false
-            ]
-        ];
-
         /**
          * @var UpdateDatabaseRequest $updateDatabase
          * @var array $callOptions
          */
         [$updateDatabase, $callOptions] = $this->validateOptions(
-            $options,
+            [
+                'database' => $options + ['name' => $this->name],
+                'updateMask' => $this->fieldMask($options),
+            ],
             new UpdateDatabaseRequest(),
             CallOptions::class
         );
@@ -774,14 +755,14 @@ public function iam(): IamManager
      *           Session labels may be applied using the `labels` key.
      * }
      * @return TransactionalReadInterface
-     * @throws \BadMethodCallException If attempting to call this method within
+     * @throws BadMethodCallException If attempting to call this method within
      *         an existing transaction.
      * @codingStandardsIgnoreEnd
      */
     public function snapshot(array $options = []): TransactionalReadInterface
     {
         if ($this->isRunningTransaction) {
-            throw new \BadMethodCallException('Nested transactions are not supported by this client.');
+            throw new BadMethodCallException('Nested transactions are not supported by this client.');
         }
 
         $options += [
@@ -850,13 +831,13 @@ public function snapshot(array $options = []): TransactionalReadInterface
      *           use this as the transaction tag.
      * }
      * @return Transaction
-     * @throws \BadMethodCallException If attempting to call this method within
+     * @throws BadMethodCallException If attempting to call this method within
      *         an existing transaction.
      */
     public function transaction(array $options = []): Transaction
     {
         if ($this->isRunningTransaction) {
-            throw new \BadMethodCallException('Nested transactions are not supported by this client.');
+            throw new BadMethodCallException('Nested transactions are not supported by this client.');
         }
 
         // Configure readWrite options here. Any nested options for readWrite should be added to this call
@@ -961,22 +942,18 @@ public function transaction(array $options = []): Transaction
      * }
      * @return mixed The return value of `$operation`.
      * @throws \RuntimeException If a transaction is not committed or rolled back.
-     * @throws \BadMethodCallException If attempting to call this method within
+     * @throws BadMethodCallException If attempting to call this method within
      *         an existing transaction.
      */
     public function runTransaction(callable $operation, array $options = []): mixed
     {
         if ($this->isRunningTransaction) {
-            throw new \BadMethodCallException('Nested transactions are not supported by this client.');
-        }
-        $options += ['retrySettings' => ['maxRetries' => self::MAX_RETRIES]];
-
-        $retrySettings = $this->pluck('retrySettings', $options);
-        if ($retrySettings instanceof RetrySettings) {
-            $maxRetries = $retrySettings->getMaxRetries();
-        } else {
-            $maxRetries = $retrySettings['maxRetries'];
+            throw new BadMethodCallException('Nested transactions are not supported by this client.');
         }
+        $retrySettings = $options['retrySettings'] ?? ['maxRetries' => self::MAX_RETRIES];
+        $maxRetries = $retrySettings instanceof RetrySettings
+            ? $retrySettings->getMaxRetries()
+            : $retrySettings['maxRetries'];
 
         // Configure necessary readWrite nested and base options
         $transactionOptions = $options['transactionOptions'] ?? [];
@@ -1829,7 +1806,7 @@ public function mutationGroup(): MutationGroup
     public function batchWrite(array $mutationGroups, array $options = []): Generator
     {
         if ($this->isRunningTransaction) {
-            throw new \BadMethodCallException('Nested transactions are not supported by this client.');
+            throw new BadMethodCallException('Nested transactions are not supported by this client.');
         }
         // Prevent nested transactions.
         $this->isRunningTransaction = true;
@@ -1838,13 +1815,6 @@ public function batchWrite(array $mutationGroups, array $options = []): Generato
             $this->pluck('sessionOptions', $options, false) ?: []
         );
 
-        $mutationGroups = array_map(fn ($x) => $x->toArray(), $mutationGroups);
-
-        array_walk(
-            $mutationGroups,
-            fn (&$x) => $x['mutations'] = $this->parseMutations($x['mutations'])
-        );
-
         try {
             $options += [
                 'session' => $session->name(),
@@ -2557,7 +2527,8 @@ private function selectSession(
      *         [RequestOptions](https://cloud.google.com/spanner/docs/reference/rest/v1/RequestOptions).
      *         Please note, if using the `priority` setting you may utilize the constants available
      *         on {@see \Google\Cloud\Spanner\V1\RequestOptions\Priority} to set a value.
-     *         Please note, the `transactionTag` setting will be ignored as it is not supported for single-use transactions.
+     *         Please note, the `transactionTag` setting will be ignored as it is not supported for
+     *         single-use transactions.
      * }
      * @return Timestamp The commit timestamp.
      */
@@ -2627,104 +2598,6 @@ private function databaseIdOnly(string $name): string
         }
     }
 
-    private function parseMutations(array $rawMutations): array
-    {
-        if (!is_array($rawMutations)) {
-            return [];
-        }
-
-        $mutations = [];
-        foreach ($rawMutations as $mutation) {
-            $type = array_keys($mutation)[0];
-            $data = $mutation[$type];
-
-            switch ($type) {
-                case Operation::OP_DELETE:
-                    $operation = $this->serializer->decodeMessage(
-                        new Delete(),
-                        $data
-                    );
-                    break;
-                default:
-                    $operation = new Write();
-                    $operation->setTable($data['table']);
-                    $operation->setColumns($data['columns']);
-
-                    $modifiedData = [];
-                    foreach ($data['values'] as $key => $param) {
-                        $modifiedData[$key] = $this->fieldValue($param);
-                    }
-
-                    $list = new ListValue();
-                    $list->setValues($modifiedData);
-                    $values = [$list];
-                    $operation->setValues($values);
-
-                    break;
-            }
-
-            $setterName = self::MUTATION_SETTERS[$type];
-            $mutation = new Mutation();
-            $mutation->$setterName($operation);
-            $mutations[] = $mutation;
-        }
-        return $mutations;
-    }
-
-    /**
-     * @param mixed $param
-     * @return Value
-     */
-    private function fieldValue($param): Value
-    {
-        $field = new Value();
-        $value = $this->formatValueForApi($param);
-
-        $setter = null;
-        switch (array_keys($value)[0]) {
-            case 'string_value':
-                $setter = 'setStringValue';
-                break;
-            case 'number_value':
-                $setter = 'setNumberValue';
-                break;
-            case 'bool_value':
-                $setter = 'setBoolValue';
-                break;
-            case 'null_value':
-                $setter = 'setNullValue';
-                break;
-            case 'struct_value':
-                $setter = 'setStructValue';
-                $modifiedParams = [];
-                foreach ($param as $key => $value) {
-                    $modifiedParams[$key] = $this->fieldValue($value);
-                }
-                $value = new Struct();
-                $value->setFields($modifiedParams);
-
-                break;
-            case 'list_value':
-                $setter = 'setListValue';
-                $modifiedParams = [];
-                foreach ($param as $item) {
-                    $modifiedParams[] = $this->fieldValue($item);
-                }
-                $list = new ListValue();
-                $list->setValues($modifiedParams);
-                $value = $list;
-
-                break;
-        }
-
-        $value = is_array($value) ? current($value) : $value;
-        if ($setter) {
-            $field->$setter($value);
-        }
-
-        return $field;
-    }
-
     private function databaseResultFunction(): Closure
     {
         return function (array $database): self {
diff --git a/Spanner/src/Instance.php b/Spanner/src/Instance.php
index b8ff3d9ec629..89a3adf5a1cf 100644
--- a/Spanner/src/Instance.php
+++ b/Spanner/src/Instance.php
@@ -19,6 +19,8 @@
 
 use Closure;
 use Google\ApiCore\Options\CallOptions;
+use Google\ApiCore\ValidationException;
+use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\Exception\NotFoundException;
 use Google\Cloud\Core\Iam\IamManager;
 use Google\Cloud\Core\Iterator\ItemIterator;
@@ -27,12 +29,15 @@
 use Google\Cloud\Core\OptionsValidator;
 use Google\Cloud\Core\RequestHandler;
 use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
+use Google\Cloud\Spanner\Admin\Database\V1\ListBackupOperationsRequest;
 use Google\Cloud\Spanner\Admin\Database\V1\ListBackupsRequest;
+use Google\Cloud\Spanner\Admin\Database\V1\ListDatabaseOperationsRequest;
 use Google\Cloud\Spanner\Admin\Database\V1\ListDatabasesRequest;
 use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
 use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstanceRequest;
 use Google\Cloud\Spanner\Admin\Instance\V1\DeleteInstanceRequest;
 use Google\Cloud\Spanner\Admin\Instance\V1\GetInstanceRequest;
+use Google\Cloud\Spanner\Admin\Instance\V1\Instance as InstanceProto;
 use Google\Cloud\Spanner\Admin\Instance\V1\Instance\State;
 use Google\Cloud\Spanner\Admin\Instance\V1\UpdateInstanceRequest;
 use Google\Cloud\Spanner\Session\SessionPoolInterface;
@@ -40,6 +45,7 @@
 use Google\Cloud\Spanner\V1\TransactionOptions\IsolationLevel;
 use Google\LongRunning\ListOperationsRequest;
 use Google\LongRunning\Operation as OperationProto;
+use InvalidArgumentException;
 
 /**
  * Represents a Cloud Spanner instance
@@ -55,6 +61,7 @@
  */
 class Instance
 {
+    use ApiHelperTrait;
     use RequestTrait;
 
     const STATE_READY = State::READY;
@@ -69,11 +76,7 @@ class Instance
     private string $projectName;
     private bool $returnInt64AsObject;
     private array $info;
-
-    /**
-     * @var int
-     */
-    private $isolationLevel;
+    private int $isolationLevel;
 
     /**
      * Create an object representing a Cloud Spanner instance.
@@ -239,28 +242,16 @@ public function exists(array $options = []): bool
      */
     public function reload(array $options = []): array
     {
+        $options['name'] ??= $this->name;
         /**
-         * @var array $data
-         * @var array $calloptions
+         * @var GetInstanceRequest $request
+         * @var array $callOptions
          */
-        [$data, $callOptions] = $this->splitOptionalArgs($options);
-        $data += [
-            'name' => $this->name
-        ];
-
-        if (isset($data['fieldMask'])) {
-            $fieldMask = [];
-            if (is_array($data['fieldMask'])) {
-                foreach (array_values($data['fieldMask']) as $field) {
-                    $fieldMask[] = $this->serializer::toSnakeCase($field);
-                }
-            } else {
-                $fieldMask[] = $this->serializer::toSnakeCase($data['fieldMask']);
-            }
-            $data['fieldMask'] = ['paths' => $fieldMask];
-        }
-
-        $request = $this->serializer->decodeMessage(new GetInstanceRequest(), $data);
+        [$request, $callOptions] = $this->validateOptions(
+            $options,
+            new GetInstanceRequest(),
+            CallOptions::class
+        );
 
         $response = $this->instanceAdminClient->getInstance($request, $callOptions + [
             'resource-prefix' => $this->projectName
@@ -290,33 +281,40 @@ public function reload(array $options = []): array
      *           [Using labels to organize Google Cloud Platform resources](https://cloudplatform.googleblog.com/2015/10/using-labels-to-organize-Google-Cloud-Platform-resources.html).
      * }
      * @return LongRunningOperation
-     * @throws \InvalidArgumentException
+     * @throws InvalidArgumentException
      * @codingStandardsIgnoreEnd
      */
     public function create(InstanceConfiguration $config, array $options = []): LongRunningOperation
     {
         /**
-         * @var array $instance
-         * @var array $calloptions
+         * @var InstanceProto $instance
+         * @var array $callOptions
          */
-        [$instance, $callOptions] = $this->splitOptionalArgs($options);
+        [$instance, $callOptions] = $this->validateOptions(
+            $options,
+            new InstanceProto(),
+            CallOptions::class
+        );
+
         $instanceId = InstanceAdminClient::parseName($this->name)['instance'];
-        if (isset($instance['nodeCount']) && isset($instance['processingUnits'])) {
-            throw new \InvalidArgumentException('Must only set either `nodeCount` or `processingUnits`');
+        if ($instance->getNodeCount() !== 0 && $instance->getProcessingUnits() !== 0) {
+            throw new InvalidArgumentException('Must only set either `nodeCount` or `processingUnits`');
         }
-        if (empty($instance['nodeCount']) && empty($instance['processingUnits'])) {
-            $instance['nodeCount'] = self::DEFAULT_NODE_COUNT;
+        if ($instance->getNodeCount() === 0 && $instance->getProcessingUnits() === 0) {
+            $instance->setNodeCount(self::DEFAULT_NODE_COUNT);
         }
 
-        $data = [
-            'parent' => InstanceAdminClient::projectName(
-                $this->projectId
-            ),
-            'instanceId' => $instanceId,
-            'instance' => $this->createInstanceArray($instance, $config)
-        ];
+        $instance->setName($this->name);
+        $instance->setConfig($config->name());
+        if (!$instance->getDisplayName()) {
+            $instance->setDisplayName($instanceId);
+        }
 
-        $request = $this->serializer->decodeMessage(new CreateInstanceRequest(), $data);
+        $request = new CreateInstanceRequest([
+            'parent' => InstanceAdminClient::projectName($this->projectId),
+            'instance_id' => $instanceId,
+            'instance' => $instance
+        ]);
 
         $operation = $this->instanceAdminClient->createInstance($request, $callOptions + [
             'resource-prefix' => $this->name
@@ -377,27 +375,26 @@ public function state(array $options = []): int
      *           [Using labels to organize Google Cloud Platform resources](https://goo.gl/xmQnxf).
      * }
      * @return LongRunningOperation
-     * @throws \InvalidArgumentException
+     * @throws InvalidArgumentException
      */
     public function update(array $options = []): LongRunningOperation
     {
-        /**
-         * @var array $instance
-         * @var array $calloptions
-         */
-        [$instance, $callOptions] = $this->splitOptionalArgs($options);
-
         if (isset($options['nodeCount']) && isset($options['processingUnits'])) {
-            throw new \InvalidArgumentException('Must only set either `nodeCount` or `processingUnits`');
+            throw new InvalidArgumentException('Must only set either `nodeCount` or `processingUnits`');
         }
 
-        $fieldMask = $this->fieldMask($instance);
-        $data = [
-            'fieldMask' => $fieldMask,
-            'instance' => $this->createInstanceArray($instance)
-        ];
-
-        $request = $this->serializer->decodeMessage(new UpdateInstanceRequest(), $data);
+        /**
+         * @var UpdateInstanceRequest $request
+         * @var array $callOptions
+         */
+        [$request, $callOptions] = $this->validateOptions(
+            [
+                'instance' => $options + ['name' => $this->name],
+                'fieldMask' => $this->fieldMask($options)
+            ],
+            new UpdateInstanceRequest(),
+            CallOptions::class
+        );
 
         $operation = $this->instanceAdminClient->updateInstance($request, $callOptions + [
             'resource-prefix' => $this->name
@@ -532,6 +529,28 @@ public function createDatabaseFromBackup(
      */
     public function database(string $name, array $options = []): Database
     {
+        [$options] = $this->validateOptions($options, [
+            'routeToLeader',
+            'defaultQueryOptions',
+            'returnint64AsObject',
+            'databaseRole',
+            'database',
+            'sessionPool',
+            'lock',
+            'isolationLevel',
+        ]);
+
+        try {
+            $instance = DatabaseAdminClient::parseName($this->name())['instance'];
+            $databaseName = GapicSpannerClient::databaseName(
+                $this->projectId,
+                $instance,
+                $name
+            );
+        } catch (ValidationException $e) {
+            $databaseName = $name;
+        }
+
         return new Database(
             $this->spannerClient,
             $this->databaseAdminClient,
@@ -705,7 +724,23 @@ function (array $backup) {
      */
     public function backupOperations(array $options = []): ItemIterator
     {
-        return $this->database($this->name)->backupOperations($options);
+        /**
+         * @var ListBackupOperationsRequest $listBackupOperations
+         * @var array $callOptions
+         */
+        [$listBackupOperations, $callOptions] = $this->validateOptions(
+            $options,
+            new ListBackupOperationsRequest(),
+            CallOptions::class
+        );
+        $listBackupOperations->setParent($this->name);
+
+        return $this->buildLongRunningIterator(
+            [$this->databaseAdminClient, 'listBackupOperations'],
+            $listBackupOperations,
+            $callOptions +  ['resource-prefix' => $this->name],
+            $this->getResultMapper()
+        );
     }
 
     /**
@@ -736,7 +771,23 @@ public function backupOperations(array $options = []): ItemIterator
      */
     public function databaseOperations(array $options = []): ItemIterator
     {
-        return $this->database($this->name)->databaseOperations($options);
+        /**
+         * @var ListDatabaseOperationsRequest $listDatabaseOperations
+         * @var array $callOptions
+         */
+        [$listDatabaseOperations, $callOptions] = $this->validateOptions(
+            $options,
+            new ListDatabaseOperationsRequest(),
+            CallOptions::class
+        );
+        $listDatabaseOperations->setParent($this->name);
+
+        return $this->buildLongRunningIterator(
+            [$this->databaseAdminClient, 'listDatabaseOperations'],
+            $listDatabaseOperations,
+            $callOptions + ['resource-prefix' => $this->name],
+            $this->getResultMapper()
+        );
     }
 
     /**
@@ -778,24 +829,6 @@ private function fullyQualifiedInstanceName(string $name, string $project): stri
         );
     }
 
-    /**
-     * Represent the class in a more readable and digestable fashion.
-     *
-     * @access private
-     * @codeCoverageIgnore
-     */
-    public function __debugInfo()
-    {
-        return [
-            'spannerClient' => get_class($this->spannerClient),
-            'databaseAdminClient' => get_class($this->databaseAdminClient),
-            'instanceAdminClient' => get_class($this->instanceAdminClient),
-            'projectId' => $this->projectId,
-            'name' => $this->name,
-            'info' => $this->info
-        ];
-    }
-
     /**
      * Return the directed read options.
      *
@@ -811,36 +844,6 @@ public function directedReadOptions(): array
         return $this->directedReadOptions;
     }
 
-    /**
-     * @param array $instanceArray
-     * @return array
-     */
-    private function fieldMask(array $instanceArray): array
-    {
-        $mask = [];
-        foreach (array_keys($instanceArray) as $key) {
-            $mask[] = $this->serializer::toSnakeCase($key);
-        }
-        return ['paths' => $mask];
-    }
-
-    /**
-     * @param array $instanceArray
-     * @param InstanceConfiguration $config
-     * @return array
-     */
-    public function createInstanceArray(
-        array $instanceArray,
-        InstanceConfiguration|null $config = null
-    ): array {
-        return $instanceArray + [
-            'name' => $this->name,
-            'displayName' => InstanceAdminClient::parseName($this->name)['instance'],
-            'labels' => [],
-            'config' => $config ? $config->name() : ''
-        ];
-    }
-
     /**
      * Resume a Long Running Operation
      *
@@ -910,12 +913,7 @@ public function longRunningOperations(array $options = []): ItemIterator
             [$this->instanceAdminClient->getOperationsClient(), 'listOperations'],
             $listOperationsRequest,
             $callOptions,
-            function (OperationProto $operation) {
-                return $this->resumeOperation(
-                    $operation->getName(),
-                    $this->handleResponse($operation)
-                );
-            }
+            $this->getResultMapper(),
         );
     }
 
@@ -940,4 +938,32 @@ private function instanceResultFunction(): Closure
             );
         };
     }
+
+    private function getResultMapper(): callable
+    {
+        return function (OperationProto $operation) {
+            return $this->resumeOperation(
+                $operation->getName(),
+                $this->handleResponse($operation)
+            );
+        };
+    }
+
+    /**
+     * Represent the class in a more readable and digestable fashion.
+     *
+     * @access private
+     * @codeCoverageIgnore
+     */
+    public function __debugInfo()
+    {
+        return [
+            'spannerClient' => get_class($this->spannerClient),
+            'databaseAdminClient' => get_class($this->databaseAdminClient),
+            'instanceAdminClient' => get_class($this->instanceAdminClient),
+            'projectId' => $this->projectId,
+            'name' => $this->name,
+            'info' => $this->info,
+        ];
+    }
 }
diff --git a/Spanner/src/InstanceConfiguration.php b/Spanner/src/InstanceConfiguration.php
index 2c0f35d66763..ed66e531b094 100644
--- a/Spanner/src/InstanceConfiguration.php
+++ b/Spanner/src/InstanceConfiguration.php
@@ -21,6 +21,7 @@
 use Google\ApiCore\ApiException;
 use Google\ApiCore\Options\CallOptions;
 use Google\ApiCore\ValidationException;
+use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\LongRunning\LongRunningClientConnection;
 use Google\Cloud\Core\LongRunning\LongRunningOperation;
 use Google\Cloud\Core\OptionsValidator;
@@ -52,6 +53,7 @@
  */
 class InstanceConfiguration
 {
+    use ApiHelperTrait;
     use RequestTrait;
 
     private array $info;
@@ -93,7 +95,7 @@ public function __construct(
      *
      * @return string
      */
-    public function name()
+    public function name(): string
     {
         return $this->name;
     }
@@ -115,7 +117,7 @@ public function name()
      * @return array [InstanceConfig](https://cloud.google.com/spanner/docs/reference/rpc/google.spanner.admin.instance.v1#instanceconfig)
      * @codingStandardsIgnoreEnd
      */
-    public function info(array $options = [])
+    public function info(array $options = []): array
     {
         if (!$this->info) {
             $this->reload($options);
@@ -141,10 +143,10 @@ public function info(array $options = [])
      * @param array $options [optional] Configuration options.
      * @return bool
      */
-    public function exists(array $options = [])
+    public function exists(array $options = []): bool
     {
         try {
-            $this->reload($options = []);
+            $this->reload($options);
         } catch (ApiException $e) {
             if ($e->getCode() === Code::NOT_FOUND) {
                 return false;
@@ -170,7 +172,7 @@ public function exists(array $options = [])
      * @return array [InstanceConfig](https://cloud.google.com/spanner/docs/reference/rpc/google.spanner.admin.instance.v1#instanceconfig)
      * @codingStandardsIgnoreEnd
      */
-    public function reload(array $options = [])
+    public function reload(array $options = []): array
     {
         $options += ['name' => $this->name];
         /**
@@ -224,30 +226,34 @@ public function reload(array $options = [])
      * @throws ValidationException
      * @codingStandardsIgnoreEnd
      */
-    public function create(InstanceConfiguration $baseConfig, array $replicas, array $options = [])
-    {
-        [$data, $callOptions] = $this->splitOptionalArgs($options);
+    public function create(
+        InstanceConfiguration $baseConfig,
+        array $replicas,
+        array $options = []
+    ): LongRunningOperation {
+        $leaderOptions = $baseConfig->info()['leaderOptions'] ?? [];
+        $options['leaderOptions'] = $leaderOptions;
+        $options['replicas'] = $replicas;
+        $options['baseConfig'] = $baseConfig->name();
+
+        [$instanceConfig, $callOptions] = $this->validateOptions(
+            $options,
+            new InstanceConfig(),
+            CallOptions::class
+        );
 
-        $leaderOptions = $baseConfig->__debugInfo()['info']['leaderOptions'] ?? [];
-        $validateOnly = $data['validateOnly'] ?? false;
-        unset($data['validateOnly']);
-        $data += [
-            'replicas' => $replicas,
-            'baseConfig' => $baseConfig->name(),
-            'leaderOptions' => $leaderOptions
-        ];
-        $instanceConfig = $this->instanceConfigArray($data);
-        $requestArray = [
-            'parent' => InstanceAdminClient::projectName($this->projectId),
-            'instanceConfigId' => InstanceAdminClient::parseName($this->name)['instance_config'],
-            'instanceConfig' => $instanceConfig,
-            'validateOnly' => $validateOnly
-        ];
+        $instanceConfig->setName($this->name);
+        if (!$instanceConfig->getDisplayName()) {
+            $instanceConfig->setDisplayName(InstanceAdminClient::parseName($this->name)['instance_config']);
+        }
+        $instanceConfig->setConfigType(InstanceConfig\Type::USER_MANAGED);
 
-        $request = $this->serializer->decodeMessage(
-            new CreateInstanceConfigRequest(),
-            $requestArray
-        );
+        $request = new CreateInstanceConfigRequest([
+            'parent' => InstanceAdminClient::projectName($this->projectId),
+            'instance_config_id' => InstanceAdminClient::parseName($this->name)['instance_config'],
+            'instance_config' => $instanceConfig,
+            'validate_only' => $options['validateOnly'] ?? false
+        ]);
 
         $operation = $this->instanceAdminClient->createInstanceConfig(
             $request,
@@ -284,17 +290,20 @@ public function create(InstanceConfiguration $baseConfig, array $replicas, array
      * @return LongRunningOperation
      * @throws \InvalidArgumentException
      */
-    public function update(array $options = [])
+    public function update(array $options = []): LongRunningOperation
     {
-        [$data, $callOptions] = $this->splitOptionalArgs($options);
-        $validateOnly = $data['validateOnly'] ?? false;
-        unset($data['validateOnly']);
+        $validateOnly = $options['validateOnly'] ?? false;
+        unset($options['validateOnly']);
 
-        $request = $this->serializer->decodeMessage(new UpdateInstanceConfigRequest(), [
-            'instanceConfig' => $data + ['name' => $this->name],
-            'updateMask' => $this->fieldMask($data),
-            'validateOnly' => $validateOnly
-        ]);
+        [$request, $callOptions] = $this->validateOptions(
+            [
+                'instanceConfig' => $options + ['name' => $this->name],
+                'updateMask' => $this->fieldMask($options),
+                'validateOnly' => $validateOnly,
+            ],
+            new UpdateInstanceConfigRequest(),
+            CallOptions::class
+        );
 
         $operation = $this->instanceAdminClient->updateInstanceConfig(
             $request,
@@ -320,7 +329,7 @@ public function update(array $options = [])
      * @param array $options [optional] Configuration options.
      * @return void
      */
-    public function delete(array $options = [])
+    public function delete(array $options = []): void
     {
         $options += ['name' => $this->name];
 
@@ -350,7 +359,7 @@ public function delete(array $options = [])
      * @param string $operationName The Long Running Operation name.
      * @return LongRunningOperation
      */
-    public function resumeOperation(string $operationName, array $options = [])
+    public function resumeOperation(string $operationName, array $options = []): LongRunningOperation
     {
         return new LongRunningOperation(
             new LongRunningClientConnection($this->instanceAdminClient, $this->serializer),
@@ -376,7 +385,7 @@ public function resumeOperation(string $operationName, array $options = [])
      * @param string $projectId The project ID.
      * @return string
      */
-    private function fullyQualifiedConfigName($name, $projectId)
+    private function fullyQualifiedConfigName($name, $projectId): string
     {
         try {
             return InstanceAdminClient::instanceConfigName(
@@ -388,35 +397,6 @@ private function fullyQualifiedConfigName($name, $projectId)
         }
     }
 
-    /**
-     * @param array $args
-     *
-     * @return array
-     */
-    private function instanceConfigArray(array $args)
-    {
-        $configId = InstanceAdminClient::parseName($this->name)['instance_config'];
-
-        return $args += [
-            'name' => $this->name,
-            'displayName' => $configId,
-            'configType' => Type::USER_MANAGED
-        ];
-    }
-
-    /**
-     * @param array $instanceArray
-     * @return array
-     */
-    private function fieldMask(array $instanceArray)
-    {
-        $mask = [];
-        foreach (array_keys($instanceArray) as $key) {
-            $mask[] = $this->serializer::toSnakeCase($key);
-        }
-        return ['paths' => $mask];
-    }
-
     private function instanceConfigResultFunction(): Closure
     {
         return function (array $result) {
diff --git a/Spanner/src/Middleware/SpannerMiddleware.php b/Spanner/src/Middleware/SpannerMiddleware.php
index 7d602a54d14b..8ca0bcc54582 100644
--- a/Spanner/src/Middleware/SpannerMiddleware.php
+++ b/Spanner/src/Middleware/SpannerMiddleware.php
@@ -84,7 +84,7 @@ public function __invoke(
         array $options
     ): PromiseInterface|ClientStream|ServerStream|BidiStream {
         if ($resourcePrefix = $this->pluck('resource-prefix', $options, false)) {
-            $options['headers'][self::RESOURCE_PREFIX_HEADER] = [$options['resource-prefix']];
+            $options['headers'][self::RESOURCE_PREFIX_HEADER] = [$resourcePrefix];
         }
 
         if (true === $this->pluck('route-to-leader', $options, false)) {
diff --git a/Spanner/src/Operation.php b/Spanner/src/Operation.php
index 28d1d807f288..da355e4bcc86 100644
--- a/Spanner/src/Operation.php
+++ b/Spanner/src/Operation.php
@@ -17,9 +17,12 @@
 
 namespace Google\Cloud\Spanner;
 
+use DateTimeImmutable;
 use Generator;
 use Google\ApiCore\Options\CallOptions;
+use Google\ApiCore\ServerStream;
 use Google\Cloud\Core\ApiHelperTrait;
+use Google\Cloud\Core\Exception\ServiceException;
 use Google\Cloud\Core\OptionsValidator;
 use Google\Cloud\Core\RequestProcessorTrait;
 use Google\Cloud\Spanner\Batch\QueryPartition;
@@ -31,18 +34,20 @@
 use Google\Cloud\Spanner\V1\CreateSessionRequest;
 use Google\Cloud\Spanner\V1\ExecuteBatchDmlRequest;
 use Google\Cloud\Spanner\V1\ExecuteSqlRequest;
+use Google\Cloud\Spanner\V1\Partition;
 use Google\Cloud\Spanner\V1\PartitionOptions;
 use Google\Cloud\Spanner\V1\PartitionQueryRequest;
 use Google\Cloud\Spanner\V1\PartitionReadRequest;
 use Google\Cloud\Spanner\V1\ReadRequest;
 use Google\Cloud\Spanner\V1\RequestOptions;
 use Google\Cloud\Spanner\V1\RollbackRequest;
+use Google\Cloud\Spanner\V1\Transaction as TransactionProto;
 use Google\Cloud\Spanner\V1\TransactionOptions;
 use Google\Cloud\Spanner\V1\TransactionOptions\ReadWrite;
 use Google\Cloud\Spanner\V1\TransactionSelector;
 use Google\Cloud\Spanner\V1\Type;
+use Google\Protobuf\RepeatedField;
 use Google\Rpc\Code;
-use GPBMetadata\Google\Protobuf\Struct;
 use InvalidArgumentException;
 
 /**
@@ -54,6 +59,8 @@
  * Usage examples may be found in classes making use of this class:
  * * {@see \Google\Cloud\Spanner\Database}
  * * {@see \Google\Cloud\Spanner\Transaction}
+ *
+ * @internal
  */
 class Operation
 {
@@ -159,11 +166,10 @@ public function commitWithResponse(Session $session, array $mutations, array $op
     {
         $options += [
             'session' => $session->name(),
-            'mutations' => $this->serializeMutations($mutations),
+            'mutations' => $mutations,
         ];
+
         /**
-         * @TODO: Find out why singleUse is being passed in and if we can remove it.
-         *
          * @var CommitRequest $commitRequest
          * @var bool|null $_singleUse
          * @var array $callOptions
@@ -192,10 +198,10 @@ public function commitWithResponse(Session $session, array $mutations, array $op
 
         return [
             new Timestamp(
-                $this->createDateTimeFromSeconds($timestamp->getSeconds()),
-                $timestamp->getNanos()
+                $this->createDateTimeFromSeconds($timestamp?->getSeconds()) ?: new DateTimeImmutable(),
+                $timestamp?->getNanos()
             ),
-            $this->handleResponse($response)
+            $response,
         ];
     }
 
@@ -220,8 +226,6 @@ public function rollback(
         }
 
         /**
-         * @TODO: find out why "transactionOptions" are being passed in by are unused.
-         *
          * @var array $callOptions
          * @var array|null $_transactionOptions
          */
@@ -230,6 +234,7 @@ public function rollback(
             CallOptions::class,
             'transactionOptions'
         );
+
         $rollbackRequest = (new RollbackRequest())
             ->setSession($session->name())
             ->setTransactionId($transactionId);
@@ -284,7 +289,7 @@ public function execute(Session $session, string $sql, array $options = []): Res
             $options,
             new ExecuteSqlRequest(),
             CallOptions::class,
-            ['parameters', 'types', 'transactionContext'],
+            ['parameters', 'types', 'transactionContext', 'singleUse'],
             ['route-to-leader']
         );
         $executeSqlRequest->setSql($sql);
@@ -299,7 +304,6 @@ public function execute(Session $session, string $sql, array $options = []): Res
         // transaction will be passed to this callable by the Result class.
         $call = function ($resumeToken = null, $transaction = null) use (
             $session,
-            $sql,
             $executeSqlRequest,
             $callOptions
         ) {
@@ -310,8 +314,15 @@ public function execute(Session $session, string $sql, array $options = []): Res
                 $executeSqlRequest->setResumeToken($resumeToken);
             }
 
-            $databaseName = $this->getDatabaseNameFromSession($session);
-            return $this->executeStreamingSql($databaseName, $executeSqlRequest, $callOptions);
+            if (!$this->routeToLeader) {
+                unset($callOptions['route-to-leader']);
+            }
+
+            $stream = $this->spannerClient->executeStreamingSql($executeSqlRequest, $callOptions + [
+                'resource-prefix' => $this->getDatabaseNameFromSession($session),
+            ]);
+
+            return $this->handleResultSetStream($stream, $transaction);
         };
         return new Result($this, $session, $call, $miscOptions['transactionContext'] ?? null, $this->mapper);
     }
@@ -351,9 +362,7 @@ public function executeUpdate(
 
         $res = $this->execute($session, $sql, $options);
 
-        if (empty($transaction->id()) && $res->transaction()) {
-            $transaction->setId($res->transaction()->id());
-        }
+        $transaction->updateFromResult($res->transaction());
 
         // Iterate through the result to ensure we have query statistics available.
         iterator_to_array($res->rows());
@@ -527,12 +536,16 @@ public function read(
                 ->setSession($session->name())
                 ->setColumns($columns);
 
+            if (!$this->routeToLeader) {
+                unset($callOptions['route-to-leader']);
+            }
+
+            $stream = $this->spannerClient->streamingRead($readRequest, $callOptions + [
+                'resource-prefix' => $this->getDatabaseNameFromSession($session),
+            ]);
+
             // return the generator
-            return $this->streamingRead(
-                $this->getDatabaseNameFromSession($session),
-                $readRequest,
-                $callOptions
-            );
+            return $this->handleResultSetStream($stream, $transaction);
         };
 
         return new Result($this, $session, $call, $context, $this->mapper);
@@ -564,6 +577,10 @@ public function read(
      */
     public function transaction(Session $session, array $options = []): Transaction
     {
+        if (isset($options['transactionOptions'])) {
+            $options['options'] = $options['transactionOptions'];
+        }
+
         /**
          * @var array $options
          * @var BeginTransactionRequest $beginTransaction
@@ -577,20 +594,15 @@ public function transaction(Session $session, array $options = []): Transaction
             new TransactionSelector(),
             CallOptions::class,
         );
+        $id = null;
+        $precommitToken = null;
         $transactionTag = $options['tag'] ?? null;
         $isRetry = $options['isRetry'] ?? false;
+
         // transaction options may be passed in as a message or array
         // TODO: only allow messages
-        $transactionOptions = null;
-        if (isset($options['transactionOptions'])) {
-            $transactionOptions = is_array($options['transactionOptions'])
-                ? $this->serializer->decodeMessage(
-                    new TransactionOptions(),
-                    $this->formatTransactionOptions($options['transactionOptions'])
-                )
-                : $options['transactionOptions'];
-        }
-        $res = [];
+        $transactionOptions = $beginTransaction->getOptions();
+
         if (empty($options['singleUse']) && (
             !$transactionSelector->hasBegin()
             || $transactionOptions?->hasPartitionedDml()
@@ -605,7 +617,10 @@ public function transaction(Session $session, array $options = []): Transaction
                 $beginTransaction->setOptions($transactionOptions);
             }
 
-            $res = $this->beginTransaction($session, $beginTransaction, $callOptions);
+            // Execute the beginTransaction RPC
+            $transactionProto = $this->beginTransaction($session, $beginTransaction, $callOptions);
+            $id = $transactionProto->getId();
+            $precommitToken = $transactionProto->getPrecommitToken();
         }
 
         $options = array_filter([
@@ -619,7 +634,7 @@ public function transaction(Session $session, array $options = []): Transaction
         return new Transaction(
             $this,
             $session,
-            $res['id'] ?? null,
+            $id,
             $options,
             $this->mapper
         );
@@ -647,42 +662,56 @@ public function transaction(Session $session, array $options = []): Transaction
      */
     public function snapshot(Session $session, array $options = []): TransactionalReadInterface
     {
+        // We allow the setting of "options" under the keyword "transactionOptions"
+        // @TODO: get rid of this? This seems like a poor naming choice.
+        if (isset($options['transactionOptions'])) {
+            $options['options'] = $options['transactionOptions'];
+            unset($options['transactionOptions']);
+        }
+
         /**
          * @var BeginTransactionRequest $beginTransaction
          * @var array $callOptions
-         * @var array $misc
+         * @var bool $singleUse
+         * @var string $className
          */
-        [$beginTransaction, $callOptions, $misc] = $this->validateOptions(
+        [$beginTransaction, $callOptions, $singleUse, $className] = $this->validateOptions(
             $options,
             new BeginTransactionRequest(),
             CallOptions::class,
-            ['singleUse', 'className', 'transactionOptions']
+            'singleUse',
+            'className',
         );
-        if (isset($misc['transactionOptions'])) {
-            $transactionOptions = is_array($misc['transactionOptions'])
-                ? $this->serializer->decodeMessage(
-                    new TransactionOptions(),
-                    $this->formatTransactionOptions($misc['transactionOptions'])
-                )
-                : $misc['transactionOptions'];
-            $beginTransaction->setOptions($transactionOptions);
-            $options['transactionOptions'] = $transactionOptions;
-        }
 
-        $res = [];
-        if (false === ($misc['singleUse'] ?? false)) {
-            $res = $this->beginTransaction($session, $beginTransaction, $callOptions);
-        }
-
-        $snapshotClass = $misc['className'] ?? Snapshot::class;
-        if (isset($res['readTimestamp'])) {
-            if (!($res['readTimestamp'] instanceof Timestamp)) {
-                $time = $this->parseTimeString($res['readTimestamp']);
-                $res['readTimestamp'] = new Timestamp($time[0], $time[1]);
+        $className ??= Snapshot::class;
+        $transactionId = null;
+        $readTimestamp = null;
+        if (!$singleUse) {
+            $transactionProto = $this->beginTransaction($session, $beginTransaction, $callOptions);
+            $transactionId = $transactionProto->getId();
+            if ($timestamp = $transactionProto->getReadTimestamp()) {
+                // Convert nanoseconds to microseconds (1 microsecond = 1000 nanoseconds)
+                $microseconds = (int) ($timestamp->getNanos() / 1000);
+
+                // Combine the seconds and microseconds into a floating-point timestamp
+                $timestampFloat = (float) $timestamp->getSeconds() + ($microseconds / 1000000);
+
+                // Create a DateTimeImmutable object from the floating-point timestamp
+                $datetime = DateTimeImmutable::createFromFormat('U.u', sprintf('%.6f', $timestampFloat));
+                $readTimestamp = new Timestamp($datetime, $timestamp->getNanos());
             }
         }
 
-        return new $snapshotClass($this, $session, $res + $options);
+        return new $className($this, $session, [
+            'id' => $transactionId,
+            'readTimestamp' => $readTimestamp,
+            'singleUse' => $singleUse,
+            'directedReadOptions' => $options['directedReadOptions'] ?? null,
+            'transactionOptions' => $beginTransaction->getOptions(),
+        ]);
+        $res = $this->handleResponse($response);
+
+        return $this->session($res['name']);
     }
 
     /**
@@ -811,20 +840,19 @@ public function partitionQuery(
         ]);
         $options['transaction'] = $this->createTransactionSelector($options, $transactionId);
 
-        // Split all the options into their respective categories
         /**
-         * @var array $_paramsAndTypes
          * @var PartitionOptions $partitionOptions
          * @var PartitionQueryRequest $partitionQuery
          * @var ExecuteSqlRequest $_executeSql
+         * @var array $_paramsAndTypes
          * @var array $callOptions
          */
-        [$_paramsAndTypes, $partitionOptions, $partitionQuery, $_executeSql, $callOptions] = $this->validateOptions(
+        [$partitionOptions, $partitionQuery, $_executeSql, $_paramsAndTypes, $callOptions] = $this->validateOptions(
             $options,
-            ['parameters', 'types'], // handled above, but define them here as well (so they're validated)
             new PartitionOptions(),
             new PartitionQueryRequest(),
             new ExecuteSqlRequest(), // these options are unused in this method, but are passed to QueryPartition
+            ['parameters', 'types'], // handled above, but define them here as well (so they're validated)
             CallOptions::class
         );
 
@@ -837,13 +865,15 @@ public function partitionQuery(
             'resource-prefix' => $this->getDatabaseNameFromSession($session),
             'route-to-leader' => $this->routeToLeader
         ]);
-        $res = $this->handleResponse($response);
 
         $partitions = [];
         $queryPartitionOptions = $this->pluckArray(['parameters', 'types', 'maxPartitions', 'partitionSizeBytes'], $options);
-        foreach ($res['partitions'] as $partition) {
+
+        /** @var RepeatedField<Partition> $protoPartitions */
+        $protoPartitions = $response->getPartitions();
+        foreach ($protoPartitions as $partition) {
             $partitions[] = new QueryPartition(
-                $partition['partitionToken'],
+                $partition->getPartitionToken(),
                 $sql,
                 $queryPartitionOptions
             );
@@ -913,13 +943,15 @@ public function partitionRead(
             'resource-prefix' => $this->getDatabaseNameFromSession($session),
             'route-to-leader' => $this->routeToLeader
         ]);
-        $res = $this->handleResponse($response);
 
         $partitions = [];
         $readPartitionOptions = $this->pluckArray(['index', 'maxPartitions', 'partitionSizeBytes'], $options);
-        foreach ($res['partitions'] as $partition) {
+
+        /** @var RepeatedField<Partition> $protoPartitions */
+        $protoPartitions = $response->getPartitions();
+        foreach ($protoPartitions as $partition) {
             $partitions[] = new ReadPartition(
-                $partition['partitionToken'],
+                $partition->getPartitionToken(),
                 $table,
                 $keySet,
                 $columns,
@@ -939,9 +971,9 @@ public function partitionRead(
      * @param BeginTransactionRequest $beginTransaction
      * @param array $callOptions
      *
-     * @return array
+     * @return TransactionProto
      */
-    private function beginTransaction(Session $session, BeginTransactionRequest $beginTransaction, array $callOptions): array
+    private function beginTransaction(Session $session, BeginTransactionRequest $beginTransaction, array $callOptions): TransactionProto
     {
         $routeToLeader = $this->routeToLeader && (
             $beginTransaction->getOptions()?->hasReadWrite()
@@ -952,38 +984,10 @@ private function beginTransaction(Session $session, BeginTransactionRequest $beg
             $beginTransaction->setSession($session->name());
         }
 
-        $response = $this->spannerClient->beginTransaction($beginTransaction, $callOptions + [
+        return $this->spannerClient->beginTransaction($beginTransaction, $callOptions + [
             'resource-prefix' => $this->getDatabaseNameFromSession($session),
             'route-to-leader' => $routeToLeader,
         ]);
-        return $this->handleResponse($response);
-    }
-
-    /**
-     * Convert a KeySet object to an API-ready array.
-     *
-     * @param KeySet $keySet The keySet object.
-     * @return array [KeySet](https://cloud.google.com/spanner/reference/rpc/google.spanner.v1#keyset)
-     */
-    private function flattenKeySet(KeySet $keySet): array
-    {
-        $keys = $keySet->keySetObject();
-
-        if (!empty($keys['ranges'])) {
-            foreach ($keys['ranges'] as $index => $range) {
-                foreach ($range as $type => $rangeKeys) {
-                    $range[$type] = $this->mapper->encodeValuesAsSimpleType($rangeKeys);
-                }
-
-                $keys['ranges'][$index] = $range;
-            }
-        }
-
-        if (!empty($keys['keys'])) {
-            $keys['keys'] = $this->mapper->encodeValuesAsSimpleType($keys['keys'], true);
-        }
-
-        return $this->arrayFilterRemoveNull($keys);
     }
 
     private function getDatabaseNameFromSession(Session $session): string
@@ -1002,27 +1006,33 @@ private function serializeMutations(array $mutations): array
         $serializedMutations = [];
         if (is_array($mutations)) {
             foreach ($mutations as $mutation) {
-                $type = array_keys($mutation)[0];
-                $data = $mutation[$type];
-
-                switch ($type) {
-                    case Operation::OP_DELETE:
-                        // nothing to do
-                        break;
-                    default:
-                        $modifiedData = array_map([$this, 'formatValueForApi'], $data['values']);
-                        $data['values'] = [['values' => $modifiedData]];
-
-                        break;
-                }
-
-                $serializedMutations[] = [$type => $data];
+                $serializedMutations[] = $this->serializeMutation($mutation);
             }
         }
 
         return $serializedMutations;
     }
 
+    private function serializeMutation(array $mutation): array
+    {
+        if (!$mutation) {
+            return [];
+        }
+        $type = array_keys($mutation)[0];
+        $data = $mutation[$type];
+        switch ($type) {
+            case Operation::OP_DELETE:
+                // no-op
+                break;
+            default:
+                $modifiedData = array_map([$this, 'formatValueForApi'], $data['values']);
+                $data['values'] = [['values' => $modifiedData]];
+                break;
+        }
+
+        return [$type => $data];
+    }
+
     /**
      * Format statements.
      *
@@ -1074,18 +1084,7 @@ private function createTransactionSelector(
         string|null $transactionId = null
     ): array {
         if (isset($args['transaction'])) {
-            $transactionSelector = $args['transaction'];
-
-            if (isset($transactionSelector['singleUse'])) {
-                $transactionSelector['singleUse'] =
-                    $this->formatTransactionOptions($transactionSelector['singleUse']);
-            }
-
-            if (isset($transactionSelector['begin'])) {
-                $transactionSelector['begin'] =
-                    $this->formatTransactionOptions($transactionSelector['begin']);
-            }
-            return $transactionSelector;
+            return $args['transaction'];
         }
 
         if ($transactionId) {
@@ -1117,6 +1116,39 @@ private function createQueryOptions(array $args): array
         return $queryOptions;
     }
 
+    /**
+     * @param array $args
+     *
+     * @return array{params: array, paramTypes: array}
+     */
+    private function formatPartitionQueryOptions(array $args): array
+    {
+        $parameters = $args['parameters'] ?? [];
+        $types = $args['types'] ?? [];
+
+        $paramsAndParamTypes = $this->mapper->formatParamsForExecuteSql($parameters, $types);
+        return $this->formatSqlParams($paramsAndParamTypes);
+    }
+
+    /**
+     * Handles a streaming response.
+     *
+     * @param ServerStream $response
+     * @return \Generator<array>
+     * @throws ServiceException
+     */
+    private function handleResultSetStream(ServerStream $response, ?Transaction $transaction)
+    {
+        try {
+            foreach ($response->readAll() as $count => $result) {
+                $res = $this->serializer->encodeMessage($result);
+                yield $res;
+            }
+        } catch (\Exception $ex) {
+            throw $this->convertToGoogleException($ex);
+        }
+    }
+
     /**
      * @param array $transactionOptions
      * @return array
@@ -1178,20 +1210,6 @@ private function streamingRead(string $databaseName, ReadRequest $readRequest, a
         return $this->handleResponse($response);
     }
 
-    /**
-     * @param array $args
-     *
-     * @return array{params: array, paramTypes: array}
-     */
-    private function formatPartitionQueryOptions(array $args): array
-    {
-        $parameters = $args['parameters'] ?? [];
-        $types = $args['types'] ?? [];
-
-        $paramsAndParamTypes = $this->mapper->formatParamsForExecuteSql($parameters, $types);
-        return $this->formatSqlParams($paramsAndParamTypes);
-    }
-
     /**
      * Represent the class in a more readable and digestable fashion.
      *
diff --git a/Spanner/src/RequestTrait.php b/Spanner/src/RequestTrait.php
index 52fd073be783..954757a637a5 100644
--- a/Spanner/src/RequestTrait.php
+++ b/Spanner/src/RequestTrait.php
@@ -18,8 +18,8 @@
 namespace Google\Cloud\Spanner;
 
 use Google\ApiCore\ApiException;
+use Google\ApiCore\ArrayTrait;
 use Google\ApiCore\OperationResponse;
-use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\Iterator\ItemIterator;
 use Google\Cloud\Core\Iterator\PageIterator;
 use Google\Cloud\Core\LongRunning\LongRunningOperation;
@@ -33,7 +33,7 @@
  */
 trait RequestTrait
 {
-    use ApiHelperTrait;
+    use ArrayTrait;
     use RequestProcessorTrait;
 
     /**
@@ -124,4 +124,17 @@ private function operationFromOperationResponse(
             $this->handleResponse($operation->getLastProtoResponse()) ?? []
         );
     }
+
+    /**
+     * @param array $instanceArray
+     * @return array
+     */
+    private function fieldMask(array $instanceArray): array
+    {
+        $mask = [];
+        foreach (array_keys($instanceArray) as $key) {
+            $mask[] = $this->serializer::toSnakeCase($key);
+        }
+        return ['paths' => $mask];
+    }
 }
diff --git a/Spanner/src/Result.php b/Spanner/src/Result.php
index 54fff45198d7..617b17e7b017 100644
--- a/Spanner/src/Result.php
+++ b/Spanner/src/Result.php
@@ -60,9 +60,10 @@ class Result implements \IteratorAggregate
     private array|null $metadata;
     private int $retries;
     private string|null $resumeToken = null;
-    private TransactionalReadInterface|null $snapshot;
+    private TransactionalReadInterface $snapshot;
+    private Transaction $transaction;
     private array|bool|null $stats;
-    private Transaction|null $transaction = null;
+
     /**
      * @var callable
      */
@@ -297,7 +298,7 @@ public function stats(): array|bool|null
      */
     public function snapshot(): TransactionalReadInterface|null
     {
-        return $this->snapshot;
+        return $this->snapshot ?? null;
     }
 
     /**
@@ -314,7 +315,7 @@ public function snapshot(): TransactionalReadInterface|null
      */
     public function transaction(): Transaction|null
     {
-        return $this->transaction;
+        return $this->transaction ?? null;
     }
 
     /**
diff --git a/Spanner/src/Serializer.php b/Spanner/src/Serializer.php
index 641ebacdcc8b..cd4ecd1b7efc 100644
--- a/Spanner/src/Serializer.php
+++ b/Spanner/src/Serializer.php
@@ -34,9 +34,13 @@
 
 use Google\ApiCore\Serializer as ApiCoreSerializer;
 use Google\Cloud\Core\ApiHelperTrait;
+use Google\Cloud\Spanner\V1\Mutation;
+use Google\Cloud\Spanner\V1\Mutation\Delete;
+use Google\Cloud\Spanner\V1\Mutation\Write;
 use Google\Cloud\Spanner\V1\PartialResultSet;
 use Google\Cloud\Spanner\V1\Type;
 use Google\Protobuf\Internal\RepeatedField as DeprecatedRepeatedField;
+use Google\Protobuf\ListValue;
 use Google\Protobuf\RepeatedField;
 use Google\Protobuf\Struct;
 use Google\Protobuf\Value;
@@ -50,6 +54,14 @@ class Serializer extends ApiCoreSerializer
 {
     use ApiHelperTrait;
 
+    private const MUTATION_SETTERS = [
+        'insert' => 'setInsert',
+        'update' => 'setUpdate',
+        'insertOrUpdate' => 'setInsertOrUpdate',
+        'replace' => 'setReplace',
+        'delete' => 'setDelete'
+    ];
+
     private Serializer $serializer; // Self reference for ApiHelperTrait
 
     public function __construct()
@@ -92,6 +104,19 @@ public function __construct()
 
                 return $keySet;
             },
+            'google.spanner.v1.Mutation' => function ($v) {
+                return $this->formatMutation($v);
+            },
+            'google.spanner.v1.BatchWriteRequest.MutationGroup' => function ($mutationGroup) {
+                if ($mutationGroup instanceof MutationGroup) {
+                    $mutationGroup = $mutationGroup->toArray();
+                }
+                $mutationGroup['mutations'] = $this->parseMutations($mutationGroup['mutations']);
+                return $mutationGroup;
+            },
+            'google.spanner.v1.TransactionOptions' => function ($v) {
+                return $this->formatTransactionOptions($v);
+            },
             'google.protobuf.Struct' => function ($v) {
                 if (!isset($v['fields'])) {
                     return ['fields' => $v];
@@ -117,6 +142,20 @@ public function __construct()
                 }
                 return $v;
             },
+            'google.protobuf.FieldMask' => function ($v) {
+                if (isset($v['paths'])) {
+                    return $v;
+                }
+                $fieldMask = [];
+                if (is_array($v)) {
+                    foreach (array_values($v) as $field) {
+                        $fieldMask[] = $this->serializer::toSnakeCase($field);
+                    }
+                } else {
+                    $fieldMask[] = $this->serializer::toSnakeCase($v);
+                }
+                return ['paths' => $fieldMask];
+            }
         ];
         $customEncoders = [
             // A custom encoder that short-circuits the encodeMessage in Serializer class,
@@ -229,4 +268,147 @@ private function getTypeData(Type $type): array
 
         return $data;
     }
+
+    private function formatMutation(array $mutation): array
+    {
+        if (!$mutation) {
+            return [];
+        }
+        $type = array_keys($mutation)[0];
+        $data = $mutation[$type];
+        switch ($type) {
+            case Operation::OP_DELETE:
+                // no-op
+                break;
+            default:
+                $modifiedData = array_map([$this, 'formatValueForApi'], $data['values']);
+                $data['values'] = [['values' => $modifiedData]];
+                break;
+        }
+
+        return [$type => $data];
+    }
+
+    /**
+     * @param array $transactionOptions
+     * @return array
+     */
+    private function formatTransactionOptions(array $transactionOptions): array
+    {
+        // sometimes readOnly is a PBReadOnly message instance
+        if (isset($transactionOptions['readOnly']) && is_array($transactionOptions['readOnly'])) {
+            $ro = $transactionOptions['readOnly'];
+            if (isset($ro['minReadTimestamp'])) {
+                $ro['minReadTimestamp'] =
+                    $this->formatTimestampForApi($ro['minReadTimestamp']);
+            }
+
+            if (isset($ro['readTimestamp'])) {
+                $ro['readTimestamp'] =
+                    $this->formatTimestampForApi($ro['readTimestamp']);
+            }
+
+            $transactionOptions['readOnly'] = $ro;
+        }
+
+        return $transactionOptions;
+    }
+
+    private function parseMutations(array $rawMutations): array
+    {
+        if (!is_array($rawMutations)) {
+            return [];
+        }
+
+        $mutations = [];
+        foreach ($rawMutations as $mutation) {
+            $type = array_keys($mutation)[0];
+            $data = $mutation[$type];
+
+            switch ($type) {
+                case Operation::OP_DELETE:
+                    $operation = $this->serializer->decodeMessage(
+                        new Delete(),
+                        $data
+                    );
+                    break;
+                default:
+                    $operation = new Write();
+                    $operation->setTable($data['table']);
+                    $operation->setColumns($data['columns']);
+
+                    $modifiedData = [];
+                    foreach ($data['values'] as $key => $param) {
+                        $modifiedData[$key] = $this->fieldValue($param);
+                    }
+
+                    $list = new ListValue();
+                    $list->setValues($modifiedData);
+                    $values = [$list];
+                    $operation->setValues($values);
+
+                    break;
+            }
+
+            $setterName = self::MUTATION_SETTERS[$type];
+            $mutation = new Mutation();
+            $mutation->$setterName($operation);
+            $mutations[] = $mutation;
+        }
+        return $mutations;
+    }
+
+    /**
+     * @param mixed $param
+     * @return Value
+     */
+    private function fieldValue($param): Value
+    {
+        $field = new Value();
+        $value = $this->formatValueForApi($param);
+
+        $setter = null;
+        switch (array_keys($value)[0]) {
+            case 'string_value':
+                $setter = 'setStringValue';
+                break;
+            case 'number_value':
+                $setter = 'setNumberValue';
+                break;
+            case 'bool_value':
+                $setter = 'setBoolValue';
+                break;
+            case 'null_value':
+                $setter = 'setNullValue';
+                break;
+            case 'struct_value':
+                $setter = 'setStructValue';
+                $modifiedParams = [];
+                foreach ($param as $key => $value) {
+                    $modifiedParams[$key] = $this->fieldValue($value);
+                }
+                $value = new Struct();
+                $value->setFields($modifiedParams);
+
+                break;
+            case 'list_value':
+                $setter = 'setListValue';
+                $modifiedParams = [];
+                foreach ($param as $item) {
+                    $modifiedParams[] = $this->fieldValue($item);
+                }
+                $list = new ListValue();
+                $list->setValues($modifiedParams);
+                $value = $list;
+
+                break;
+        }
+
+        $value = is_array($value) ? current($value) : $value;
+        if ($setter) {
+            $field->$setter($value);
+        }
+
+        return $field;
+    }
 }
diff --git a/Spanner/src/Session/Session.php b/Spanner/src/Session/Session.php
index 033867a115d6..f7a464c64f99 100644
--- a/Spanner/src/Session/Session.php
+++ b/Spanner/src/Session/Session.php
@@ -190,7 +190,7 @@ public function expiration(): int|null
     public function __debugInfo()
     {
         return [
-            'spannerClient' => isset($this->spannerClient) ? get_class($this->spannerClient) : '<not set>',
+            'spannerClient' => get_class($this->spannerClient),
             'projectId' => $this->projectId,
             'instance' => $this->instance,
             'database' => $this->database,
diff --git a/Spanner/src/SpannerClient.php b/Spanner/src/SpannerClient.php
index 93ae43e80232..592735eee8b1 100644
--- a/Spanner/src/SpannerClient.php
+++ b/Spanner/src/SpannerClient.php
@@ -18,11 +18,10 @@
 namespace Google\Cloud\Spanner;
 
 use Google\ApiCore\ClientOptionsTrait;
-use Google\ApiCore\CredentialsWrapper;
 use Google\ApiCore\Middleware\MiddlewareInterface;
 use Google\ApiCore\Options\CallOptions;
 use Google\ApiCore\ValidationException;
-use Google\Auth\FetchAuthTokenInterface;
+use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\DetectProjectIdTrait;
 use Google\Cloud\Core\EmulatorTrait;
 use Google\Cloud\Core\Exception\GoogleException;
@@ -112,6 +111,7 @@ class SpannerClient
     use DetectProjectIdTrait;
     use ClientOptionsTrait;
     use EmulatorTrait;
+    use ApiHelperTrait;
     use RequestTrait;
 
     const VERSION = '1.106.0';
@@ -119,24 +119,18 @@ class SpannerClient
     const FULL_CONTROL_SCOPE = 'https://www.googleapis.com/auth/spanner.data';
     const ADMIN_SCOPE = 'https://www.googleapis.com/auth/spanner.admin';
 
+    private const SERVICE_NAME = 'google.spanner.v1.Spanner';
+
     private GapicSpannerClient $spannerClient;
     private InstanceAdminClient $instanceAdminClient;
     private DatabaseAdminClient $databaseAdminClient;
     private Serializer $serializer;
-    /**
-     * @var string
-     */
-    private $projectId;
     private string $projectName;
     private bool $returnInt64AsObject;
     private array $directedReadOptions;
     private bool $routeToLeader;
     private array $defaultQueryOptions;
-
-    /**
-     * @var int
-     */
-    private $isolationLevel;
+    private int $isolationLevel;
 
     /**
      * Create a Spanner client. Please note that this client requires
@@ -159,7 +153,6 @@ class SpannerClient
      *           The credentials to be used by the client to authorize API calls.
      *     @type array $credentialsConfig.scopes Scopes to be used for the request.
      *     @type string $credentialsConfig.quotaProject Specifies a user project to bill for
-     *     @type string $quotaProject Specifies a user project to bill for
      *           access charges associated with the request.
      *     @type bool $returnInt64AsObject If true, 64 bit integers will be
      *           returned as a {@see \Google\Cloud\Core\Int64} object for 32 bit
diff --git a/Spanner/src/Transaction.php b/Spanner/src/Transaction.php
index dbb11e003be0..6e44d57f3ba3 100644
--- a/Spanner/src/Transaction.php
+++ b/Spanner/src/Transaction.php
@@ -21,6 +21,7 @@
 use Google\Cloud\Core\Exception\AbortedException;
 use Google\Cloud\Spanner\Session\Session;
 use Google\Cloud\Spanner\Session\SessionPoolInterface;
+use Google\Cloud\Spanner\V1\CommitResponse\CommitStats;
 use Google\Cloud\Spanner\V1\RequestOptions;
 use Google\Cloud\Spanner\V1\TransactionOptions;
 use Google\Protobuf\Duration;
@@ -71,7 +72,7 @@ class Transaction implements TransactionalReadInterface
     use MutationTrait;
     use TransactionalReadTrait;
 
-    private array $commitStats = [];
+    private CommitStats|null $commitStats = null;
     private array $mutations = [];
     private bool $isRetry;
     private array|RequestOptions $requestOptions;
@@ -101,7 +102,7 @@ public function __construct(
         private Session $session,
         private string|null $transactionId = null,
         array $options = [],
-        private ValueMapper|null $mapper = null
+        private ValueMapper|null $mapper = null,
     ) {
         $this->type = ($transactionId || isset($options['begin']))
             ? self::TYPE_PRE_ALLOCATED
@@ -139,9 +140,9 @@ public function __construct(
      * $commitStats = $transaction->getCommitStats();
      * ```
      *
-     * @return array The commit stats
+     * @return CommitStats|null The commit stats
      */
-    public function getCommitStats(): array
+    public function getCommitStats(): CommitStats|null
     {
         return $this->commitStats;
     }
@@ -349,13 +350,12 @@ public function executeUpdate(string $sql, array $options = []): int
     public function executeUpdateBatch(array $statements, array $options = []): BatchDmlResult
     {
         $options = $this->buildUpdateOptions($options);
-        return $this->operation
-            ->executeUpdateBatch(
-                $this->session,
-                $this,
-                $statements,
-                $options
-            );
+        return $this->operation->executeUpdateBatch(
+            $this->session,
+            $this,
+            $statements,
+            $options
+        );
     }
 
     /**
@@ -433,8 +433,17 @@ public function commit(array $options = []): Timestamp
             throw new \BadMethodCallException('The transaction cannot be committed because it is not active');
         }
 
+        // set mutations, transactionId, and precommit token in the request
+        $options['mutations'] = ($options['mutations'] ?? []) + $this->getMutations();
+
+        // set the transaction tag if it exists
+        unset($options['requestOptions']['requestTag']);
+        if (isset($this->tag)) {
+            $options['requestOptions']['transactionTag'] = $this->tag;
+        }
+
         // For commit, A transaction ID is mandatory for non-single-use transactions,
-        // and the `begin` option is not supported (because `begin` is only used in "inline begin transactions")
+        // and the `begin` option is not supported (because `begin` is only used by ILBs)
         if (empty($this->transactionId) && isset($this->transactionSelector['begin'])) {
             $operationTransactionOptions = array_filter([
                 'requestOptions' => $this->requestOptions,
@@ -451,31 +460,31 @@ public function commit(array $options = []): Timestamp
             $this->state = self::STATE_COMMITTED;
         }
 
-        $options += [
-            'mutations' => [],
-            'requestOptions' => []
-        ];
-
-        $options['mutations'] += $this->getMutations();
-
+        // set transactionId in the request
         $options['transactionId'] = $this->transactionId;
 
-        unset($options['requestOptions']['requestTag']);
-        if (isset($this->tag)) {
-            $options['requestOptions']['transactionTag'] = $this->tag;
-        }
-
         $t = $this->transactionOptions($options);
 
         // @TODO find out what this is and clean it up
         $options[$t[1]] = $t[0];
 
-        $res = $this->operation->commitWithResponse($this->session, $this->pluck('mutations', $options), $options);
-        if (isset($res[1]['commitStats'])) {
-            $this->commitStats = $res[1]['commitStats'];
-        }
+        [$timestamp, $response] = $this->operation->commitWithResponse(
+            $this->session,
+            $this->pluck('mutations', $options, false) ?? [],
+            $options
+        );
 
-        return $res[0];
+        // Update commitStats
+        $this->commitStats = $response->getCommitStats();
+
+        // Return the commit timestamp as a Core Timestamp
+        $timestamp = $response->getCommitTimestamp();
+        $dateTime = \DateTimeImmutable::createFromFormat(
+            'U',
+            (int) $timestamp?->getSeconds(),
+            new \DateTimeZone('UTC')
+        );
+        return new Timestamp($dateTime, $timestamp?->getNanos());
     }
 
     /**
@@ -553,4 +562,15 @@ private function buildUpdateOptions(array $options): array
 
         return $options;
     }
+
+    public function updateFromResult(?Transaction $transaction = null): void
+    {
+        if (is_null($transaction)) {
+            return;
+        }
+
+        if (empty($this->transactionId)) {
+            $this->transactionId = $transaction->id();
+        }
+    }
 }
diff --git a/Spanner/src/TransactionalReadTrait.php b/Spanner/src/TransactionalReadTrait.php
index 9ec0d403f632..44ec8ee5b336 100644
--- a/Spanner/src/TransactionalReadTrait.php
+++ b/Spanner/src/TransactionalReadTrait.php
@@ -264,15 +264,12 @@ public function execute(string $sql, array $options = []): Result
 
         unset($executeSqlOptions['requestOptions']['transactionTag']);
         if (isset($this->tag)) {
-            $executeSqlOptions += [
-                'requestOptions' => []
-            ];
             $executeSqlOptions['requestOptions']['transactionTag'] = $this->tag;
         }
 
         $executeSqlOptions['directedReadOptions'] = $this->configureDirectedReadOptions(
             $executeSqlOptions,
-            $this->directedReadOptions ?? []
+            $this->directedReadOptions
         );
 
         // Unsetting the internal flag
diff --git a/Spanner/tests/ResultGeneratorTrait.php b/Spanner/tests/ResultGeneratorTrait.php
index 2067a5dac663..37de46933fba 100644
--- a/Spanner/tests/ResultGeneratorTrait.php
+++ b/Spanner/tests/ResultGeneratorTrait.php
@@ -81,7 +81,7 @@ private function resultGeneratorStream(
                         'fields' => $fields
                     ])
                 ]),
-                'values' => $values
+                'values' => $values,
             ];
 
             if ($stats) {
diff --git a/Spanner/tests/Snippet/BackupTest.php b/Spanner/tests/Snippet/BackupTest.php
index 13c38f82d8c2..f5b065d0f777 100644
--- a/Spanner/tests/Snippet/BackupTest.php
+++ b/Spanner/tests/Snippet/BackupTest.php
@@ -51,14 +51,13 @@
  */
 class BackupTest extends SnippetTestCase
 {
-    use GrpcTestTrait;
-    use ProphecyTrait;
-
-    const PROJECT = 'my-awesome-project';
-    const INSTANCE = 'my-instance';
     const DATABASE = 'my-database';
+    const INSTANCE = 'my-instance';
     const BACKUP = 'my-backup';
 
+    use GrpcTestTrait;
+    use ProphecyTrait;
+
     private $serializer;
     private $operationResponse;
     private $databaseAdminClient;
diff --git a/Spanner/tests/Snippet/Batch/BatchClientTest.php b/Spanner/tests/Snippet/Batch/BatchClientTest.php
index ef30783ad093..830ce5940f19 100644
--- a/Spanner/tests/Snippet/Batch/BatchClientTest.php
+++ b/Spanner/tests/Snippet/Batch/BatchClientTest.php
@@ -35,6 +35,7 @@
 use Google\Cloud\Spanner\V1\Client\SpannerClient;
 use Google\Cloud\Spanner\V1\CreateSessionRequest;
 use Google\Cloud\Spanner\V1\DeleteSessionRequest;
+use Google\Cloud\Spanner\V1\ExecuteSqlRequest;
 use Google\Cloud\Spanner\V1\PartialResultSet;
 use Google\Cloud\Spanner\V1\Partition;
 use Google\Cloud\Spanner\V1\PartitionQueryRequest;
@@ -149,17 +150,16 @@ public function testPubSubExample()
             ]));
 
         $this->spannerClient->executeStreamingSql(
-            Argument::that(function ($request) use ($partition1) {
-                $message = $this->serializer->encodeMessage($request);
+            Argument::that(function (ExecuteSqlRequest $request) use ($partition1) {
                 $this->assertEquals(
-                    $message['partitionToken'],
+                    $request->getPartitionToken(),
                     $partition1->token()
                 );
                 $this->assertEquals(
-                    $message['transaction']['id'],
+                    $request->getTransaction()->getId(),
                     self::TRANSACTION
                 );
-                $this->assertEquals($message['session'], self::SESSION);
+                $this->assertEquals($request->getSession(), self::SESSION);
                 return true;
             }),
             Argument::type('array')
diff --git a/Spanner/tests/Snippet/CommitTimestampTest.php b/Spanner/tests/Snippet/CommitTimestampTest.php
index 2d2bfa554d0c..fe5c48b9c34a 100644
--- a/Spanner/tests/Snippet/CommitTimestampTest.php
+++ b/Spanner/tests/Snippet/CommitTimestampTest.php
@@ -87,9 +87,7 @@ public function testClass()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $client = new SpannerClient([
             'projectId' => 'my-project',
diff --git a/Spanner/tests/Snippet/DatabaseTest.php b/Spanner/tests/Snippet/DatabaseTest.php
index d9f033734b61..1284a96c89d4 100644
--- a/Spanner/tests/Snippet/DatabaseTest.php
+++ b/Spanner/tests/Snippet/DatabaseTest.php
@@ -459,9 +459,7 @@ public function testRunTransaction()
         $this->spannerClient->commit(
             Argument::type(CommitRequest::class),
             Argument::type('array')
-        )->willReturn(new CommitResponse([
-            'commit_timestamp' => new TimestampProto(['seconds' => time()])
-        ]));
+        )->willReturn(new CommitResponse());
 
         $this->spannerClient->executeStreamingSql(
             Argument::type(ExecuteSqlRequest::class),
@@ -564,9 +562,7 @@ public function testInsert()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'insert');
         $snippet->addLocal('database', $this->database);
@@ -584,9 +580,7 @@ public function testInsertBatch()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'insertBatch');
         $snippet->addLocal('database', $this->database);
@@ -603,9 +597,7 @@ public function testUpdate()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'update');
         $snippet->addLocal('database', $this->database);
@@ -623,9 +615,7 @@ public function testUpdateBatch()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'updateBatch');
         $snippet->addLocal('database', $this->database);
@@ -642,9 +632,7 @@ public function testInsertOrUpdate()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'insertOrUpdate');
         $snippet->addLocal('database', $this->database);
@@ -662,9 +650,7 @@ public function testInsertOrUpdateBatch()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'insertOrUpdateBatch');
         $snippet->addLocal('database', $this->database);
@@ -681,9 +667,7 @@ public function testReplace()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'replace');
         $snippet->addLocal('database', $this->database);
@@ -701,9 +685,7 @@ public function testReplaceBatch()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'replaceBatch');
         $snippet->addLocal('database', $this->database);
@@ -720,9 +702,7 @@ public function testDelete()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Database::class, 'delete');
         $snippet->addUse(KeySet::class);
diff --git a/Spanner/tests/Snippet/InstanceConfigurationTest.php b/Spanner/tests/Snippet/InstanceConfigurationTest.php
index b584cf84e426..f10763ff4fd4 100644
--- a/Spanner/tests/Snippet/InstanceConfigurationTest.php
+++ b/Spanner/tests/Snippet/InstanceConfigurationTest.php
@@ -94,6 +94,7 @@ public function testCreate()
             $this->serializer,
             self::PROJECT,
             self::CONFIG,
+            ['instanceConfig' => ['name' => 'foo']],
         );
         $snippet->addLocal('baseConfig', $baseConfig);
         $snippet->addLocal('options', []);
diff --git a/Spanner/tests/Snippet/TransactionTest.php b/Spanner/tests/Snippet/TransactionTest.php
index 3dd709e52afe..d5345b5eaa01 100644
--- a/Spanner/tests/Snippet/TransactionTest.php
+++ b/Spanner/tests/Snippet/TransactionTest.php
@@ -40,7 +40,6 @@
 use Google\Cloud\Spanner\V1\ResultSet;
 use Google\Cloud\Spanner\V1\ResultSetStats;
 use Google\Cloud\Spanner\V1\RollbackRequest;
-use Google\Protobuf\Timestamp as TimestampProto;
 use Google\Rpc\Status;
 use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
@@ -392,9 +391,7 @@ public function testCommit()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse([
-                'commit_timestamp' => new TimestampProto(['seconds' => time()])
-            ]));
+            ->willReturn(new CommitResponse());
 
         $snippet = $this->snippetFromMethod(Transaction::class, 'commit');
         $snippet->addLocal('transaction', $this->transaction);
@@ -409,7 +406,6 @@ public function testGetCommitStats()
             Argument::type(CommitRequest::class),
             Argument::type('array')
         )->willReturn(new CommitResponse([
-            'commit_timestamp' => new TimestampProto(['seconds' => time()]),
             'commit_stats' => $expectedCommitStats,
         ]));
 
@@ -417,7 +413,8 @@ public function testGetCommitStats()
         $snippet->addLocal('transaction', $this->transaction);
 
         $res = $snippet->invoke('commitStats');
-        $this->assertEquals(['mutationCount' => 4], $res->returnVal());
+        $this->assertInstanceOf(CommitStats::class, $res->returnVal());
+        $this->assertEquals(4, $res->returnVal()->getMutationCount());
     }
 
     public function testState()
diff --git a/Spanner/tests/System/AdminTest.php b/Spanner/tests/System/AdminTest.php
index 9d6c93926f87..fa2790440775 100644
--- a/Spanner/tests/System/AdminTest.php
+++ b/Spanner/tests/System/AdminTest.php
@@ -29,6 +29,7 @@
 
 /**
  * @group spanner
+ * @group admin
  */
 class AdminTest extends SpannerTestCase
 {
diff --git a/Spanner/tests/System/BackupTest.php b/Spanner/tests/System/BackupTest.php
index 2f2e716ca060..6b3dcbf55bd4 100644
--- a/Spanner/tests/System/BackupTest.php
+++ b/Spanner/tests/System/BackupTest.php
@@ -17,9 +17,9 @@
 
 namespace Google\Cloud\Spanner\Tests\System;
 
-use Google\ApiCore\OperationResponse;
 use Google\Cloud\Core\Exception\BadRequestException;
 use Google\Cloud\Core\Exception\ConflictException;
+use Google\Cloud\Core\LongRunning\LongRunningOperation;
 use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;
 use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupEncryptionConfig;
 use Google\Cloud\Spanner\Admin\Database\V1\EncryptionInfo\Type;
@@ -54,7 +54,9 @@ class BackupTest extends SpannerTestCase
      */
     public static function setUpTestFixtures(): void
     {
+        // skip this test (it's not working)
         self::skipEmulatorTests();
+        self::emulatorOnly();
 
         self::setUpTestDatabase();
         if (self::$hasSetUp) {
@@ -113,55 +115,55 @@ public static function setUpTestFixtures(): void
         self::$hasSetUp = true;
     }
 
-    // public function testCreateBackup()
-    // {
-    //     $expireTime = new \DateTime('+7 hours');
-    //     $encryptionConfig = [
-    //         'encryptionType' => CreateBackupEncryptionConfig\EncryptionType::GOOGLE_DEFAULT_ENCRYPTION,
-    //     ];
-
-    //     $backup = self::$instance->backup(self::$backupId1);
-    //     $db1 = self::getDatabaseInstance(self::$dbName1);
-
-    //     self::$createTime1 = gmdate('"Y-m-d\TH:i:s\Z"');
-    //     $op = $backup->create(self::$dbName1, $expireTime, [
-    //         'encryptionConfig' => $encryptionConfig,
-    //     ]);
-    //     self::$backupOperationName = $op->name();
-
-    //     $metadata = null;
-    //     foreach (self::$instance->backupOperations() as $listItem) {
-    //         if ($listItem->name() == $op->name()) {
-    //             $metadata = $listItem->info()['metadata'];
-    //             break;
-    //         }
-    //     }
-
-    //     $op->pollUntilComplete();
-
-    //     self::$deletionQueue->add(function () use ($backup) {
-    //         $backup->delete();
-    //     });
-
-    //     $this->assertTrue($backup->exists());
-    //     $this->assertInstanceOf(Backup::class, $backup);
-    //     $this->assertEquals(self::$backupId1, DatabaseAdminClient::parseName($backup->info()['name'])['backup']);
-    //     $this->assertEquals(self::$dbName1, DatabaseAdminClient::parseName($backup->info()['database'])['database']);
-    //     $this->assertEquals($expireTime->format('Y-m-d\TH:i:s.u\Z'), $backup->info()['expireTime']);
-    //     $this->assertTrue(is_string($backup->info()['createTime']));
-    //     $this->assertEquals(Backup::STATE_READY, $backup->state());
-    //     $this->assertTrue($backup->info()['sizeBytes'] > 0);
-    //     // earliestVersionTime deviates from backup's versionTime by a couple of minutes
-    //     $expectedDateTime = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $db1->info()['earliestVersionTime']);
-    //     $actualDateTime = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $backup->info()['versionTime']);
-    //     $this->assertEqualsWithDelta($expectedDateTime->getTimestamp(), $actualDateTime->getTimestamp(), 300);
-    //     $this->assertEquals(Type::GOOGLE_DEFAULT_ENCRYPTION, $backup->info()['encryptionInfo']['encryptionType']);
-
-    //     $this->assertNotNull($metadata);
-    //     $this->assertArrayHasKey('progress', $metadata);
-    //     $this->assertArrayHasKey('progressPercent', $metadata['progress']);
-    //     $this->assertArrayHasKey('startTime', $metadata['progress']);
-    // }
+    public function testCreateBackup()
+    {
+        $expireTime = new \DateTime('+7 hours');
+        $encryptionConfig = [
+            'encryptionType' => CreateBackupEncryptionConfig\EncryptionType::GOOGLE_DEFAULT_ENCRYPTION,
+        ];
+
+        $backup = self::$instance->backup(self::$backupId1);
+        $db1 = self::getDatabaseInstance(self::$dbName1);
+
+        self::$createTime1 = gmdate('"Y-m-d\TH:i:s\Z"');
+        $op = $backup->create(self::$dbName1, $expireTime, [
+            'encryptionConfig' => $encryptionConfig,
+        ]);
+        self::$backupOperationName = $op->name();
+
+        $metadata = null;
+        foreach (self::$instance->backupOperations() as $listItem) {
+            if ($listItem->name() == $op->name()) {
+                $metadata = $listItem->info()['metadata'];
+                break;
+            }
+        }
+
+        $op->pollUntilComplete();
+
+        self::$deletionQueue->add(function () use ($backup) {
+            $backup->delete();
+        });
+
+        $this->assertTrue($backup->exists());
+        $this->assertInstanceOf(Backup::class, $backup);
+        $this->assertEquals(self::$backupId1, DatabaseAdminClient::parseName($backup->info()['name'])['backup']);
+        $this->assertEquals(self::$dbName1, DatabaseAdminClient::parseName($backup->info()['database'])['database']);
+        $this->assertEquals($expireTime->format('Y-m-d\TH:i:s.u\Z'), $backup->info()['expireTime']);
+        $this->assertTrue(is_string($backup->info()['createTime']));
+        $this->assertEquals(Backup::STATE_READY, $backup->state());
+        $this->assertTrue($backup->info()['sizeBytes'] > 0);
+        // earliestVersionTime deviates from backup's versionTime by a couple of minutes
+        $expectedDateTime = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $db1->info()['earliestVersionTime']);
+        $actualDateTime = \DateTime::createFromFormat('Y-m-d\TH:i:s.u\Z', $backup->info()['versionTime']);
+        $this->assertEqualsWithDelta($expectedDateTime->getTimestamp(), $actualDateTime->getTimestamp(), 300);
+        $this->assertEquals(Type::GOOGLE_DEFAULT_ENCRYPTION, $backup->info()['encryptionInfo']['encryptionType']);
+
+        $this->assertNotNull($metadata);
+        $this->assertArrayHasKey('progress', $metadata);
+        $this->assertArrayHasKey('progressPercent', $metadata['progress']);
+        $this->assertArrayHasKey('startTime', $metadata['progress']);
+    }
 
     public function testCreateBackupRequestFailed()
     {
@@ -470,7 +472,7 @@ public function testListAllBackupOperations()
         }, $backupOps);
 
         $this->assertTrue(count($backupOps) > 0);
-        $this->assertContainsOnlyInstancesOf(OperationResponse::class, $backupOps);
+        $this->assertContainsOnlyInstancesOf(LongRunningOperation::class, $backupOps);
         $this->assertTrue(in_array(self::$backupOperationName, $backupOpsNames));
     }
 
@@ -584,7 +586,7 @@ public function testRestoreAppearsInListDatabaseOperations()
         }, $databaseOps);
 
         $this->assertTrue(count($databaseOps) > 0);
-        $this->assertContainsOnlyInstancesOf(OperationResponse::class, $databaseOps);
+        $this->assertContainsOnlyInstancesOf(LongRunningOperation::class, $databaseOps);
         $this->assertTrue(in_array(self::$restoreOperationName, $databaseOpsNames));
     }
 
diff --git a/Spanner/tests/System/BatchTest.php b/Spanner/tests/System/BatchTest.php
index 36491f6881e3..f645cce38499 100644
--- a/Spanner/tests/System/BatchTest.php
+++ b/Spanner/tests/System/BatchTest.php
@@ -170,6 +170,9 @@ public function testBatchWithDbRole($dbRole, $expected)
         try {
             $partitions = $snapshot->partitionQuery($query, ['parameters' => $parameters]);
         } catch (ServiceException $e) {
+            if (is_null($expected)) {
+                throw $e;
+            }
             $error = $e;
         }
 
diff --git a/Spanner/tests/System/OperationsTest.php b/Spanner/tests/System/OperationsTest.php
index d960482ef3e2..82a6a645210e 100644
--- a/Spanner/tests/System/OperationsTest.php
+++ b/Spanner/tests/System/OperationsTest.php
@@ -239,6 +239,7 @@ public function testReadWithDbRole($db, $expected)
         ]);
         $columns = ['id', 'name', 'birthday'];
 
+        $row = null;
         try {
             $res = $db->read(self::TEST_TABLE_NAME, $keySet, $columns);
             $row = $res->rows()->current();
@@ -247,6 +248,7 @@ public function testReadWithDbRole($db, $expected)
         }
 
         if ($expected === null) {
+            $this->assertNotNull($row);
             $this->assertEquals(self::$id1, $row['id']);
         } else {
             $this->assertEquals($error->getServiceException()->getStatus(), $expected);
diff --git a/Spanner/tests/System/SnapshotTest.php b/Spanner/tests/System/SnapshotTest.php
index 8ed0063d91ef..6cb2fbc966ff 100644
--- a/Spanner/tests/System/SnapshotTest.php
+++ b/Spanner/tests/System/SnapshotTest.php
@@ -173,7 +173,10 @@ public function testSnapshotExactStaleness()
             'returnReadTimestamp' => true
         ]);
 
-        $this->assertGreaterThan($ts->get()->format('U.u'), $snapshot->readTimestamp()->get()->format('U.u'));
+        $this->assertGreaterThan(
+            $ts->get()->format('U.u'),
+            $snapshot->readTimestamp()->get()->format('U.u')
+        );
 
         $res = $this->getRow($snapshot, $id);
         $this->assertEquals($row, $res);
diff --git a/Spanner/tests/System/SpannerTestCase.php b/Spanner/tests/System/SpannerTestCase.php
index 0317707f2e7a..f0836cda2ad9 100644
--- a/Spanner/tests/System/SpannerTestCase.php
+++ b/Spanner/tests/System/SpannerTestCase.php
@@ -160,11 +160,23 @@ public static function getDatabaseWithSessionPool($dbName, $options = [])
 
     public static function skipEmulatorTests()
     {
-        if ((bool) getenv('SPANNER_EMULATOR_HOST')) {
+        if (self::isEmulatorUsed()) {
             self::markTestSkipped('This test is not supported by the emulator.');
         }
     }
 
+    public static function emulatorOnly()
+    {
+        if (!self::isEmulatorUsed()) {
+            self::markTestSkipped('This test is only supported by the emulator.');
+        }
+    }
+
+    public static function isEmulatorUsed(): bool
+    {
+        return (bool) getenv('SPANNER_EMULATOR_HOST');
+    }
+
     public static function getDbWithReaderRole()
     {
         return self::getDatabaseFromInstance(
diff --git a/Spanner/tests/System/TransactionTest.php b/Spanner/tests/System/TransactionTest.php
index 3011d11690ee..c998d32057fb 100644
--- a/Spanner/tests/System/TransactionTest.php
+++ b/Spanner/tests/System/TransactionTest.php
@@ -21,10 +21,13 @@
 use Google\Cloud\Spanner\Date;
 use Google\Cloud\Spanner\KeySet;
 use Google\Cloud\Spanner\Timestamp;
+use Google\Cloud\Spanner\Transaction;
 use Google\Cloud\Spanner\V1\DirectedReadOptions\ReplicaSelection\Type as ReplicaType;
 use Google\Cloud\Spanner\V1\ReadRequest\LockHint;
 use Google\Cloud\Spanner\V1\ReadRequest\OrderBy;
-use Google\Cloud\Spanner\V1\TransactionOptions\IsolationLevel;
+use Grpc\BaseStub;
+use Grpc\Channel;
+use ReflectionClass;
 
 /**
  * @group spanner
@@ -109,6 +112,10 @@ public function testRunTransaction()
      */
     public function testConcurrentTransactionsIncrementValueWithRead()
     {
+        if (!ini_get('grpc.enable_fork_support')) {
+            $this->markTestSkipped('This test requires grpc.enable_fork_support=1 in php.ini');
+        }
+
         $db = self::$database;
 
         $id = $this->randId();
@@ -164,6 +171,10 @@ public function testTransactionNoCommit()
      */
     public function testAbortedErrorCausesRetry()
     {
+        if (!ini_get('grpc.enable_fork_support')) {
+            $this->markTestSkipped('This test requires grpc.enable_fork_support=1 in php.ini');
+        }
+
         $db = self::$database;
         $db2 = self::$database2;
 
@@ -200,6 +211,10 @@ public function testAbortedErrorCausesRetry()
      */
     public function testConcurrentTransactionsIncrementValueWithExecute()
     {
+        if (!ini_get('grpc.enable_fork_support')) {
+            $this->markTestSkipped('This test requires grpc.enable_fork_support=1 in php.ini');
+        }
+
         $db = self::$database;
 
         $id = $this->randId();
@@ -411,11 +426,6 @@ public function testRunTransactionILBWithMultipleOperations()
                         'id' => $id,
                         'name' => uniqid(self::TESTING_PREFIX),
                         'birthday' => new Date(new \DateTime())
-                    ],
-                    'transaction' => [
-                        'begin' => [
-                            'isolationLevel' => IsolationLevel::REPEATABLE_READ,
-                        ]
                     ]
                 ]
             );
@@ -428,14 +438,27 @@ public function testRunTransactionILBWithMultipleOperations()
                 ]
             ]);
             $this->assertEquals($res->rows()->current()['id'], $id);
-            // No new transaction created.
-            $this->assertNull($res->transaction());
+            // For Multiplexed Sessions, a transaction is returned on READ
+            // The emulator doesn't support this
+            if (!$this->isEmulatorUsed()) {
+                $this->assertNotNull($res->transaction());
+                $this->assertEquals($res->transaction()->id(), $t->id());
+            } else {
+                usleep(1000000);
+            }
             $this->assertEquals($t->id(), $transactionId);
 
             $keyset = new KeySet(['keys' => [$id]]);
             $res = $t->read(self::TEST_TABLE_NAME, $keyset, ['id']);
             $this->assertEquals($res->rows()->current()['id'], $id);
-            $this->assertNull($res->transaction());
+            // For Multiplexed Sessions, a transaction is returned on READ
+            // The emulator doesn't support this
+            if (!$this->isEmulatorUsed()) {
+                $this->assertNotNull($res->transaction());
+                $this->assertEquals($res->transaction()->id(), $t->id());
+            } else {
+                usleep(1000000);
+            }
             $this->assertEquals($t->id(), $transactionId);
 
             $res = $t->executeUpdateBatch([
diff --git a/Spanner/tests/System/WriteTest.php b/Spanner/tests/System/WriteTest.php
index f56fa8e73717..2d63db8a23e6 100644
--- a/Spanner/tests/System/WriteTest.php
+++ b/Spanner/tests/System/WriteTest.php
@@ -26,6 +26,7 @@
 use Google\Cloud\Spanner\Date;
 use Google\Cloud\Spanner\KeySet;
 use Google\Cloud\Spanner\Numeric;
+use Google\Cloud\Spanner\Proto;
 use Google\Cloud\Spanner\Timestamp;
 use Google\Protobuf\Internal\Message;
 use Google\Rpc\Code;
@@ -151,7 +152,7 @@ public function testWriteAndReadBackValue($id, $field, $value)
             $this->assertEquals($value->formatAsString(), $row[$field]->formatAsString());
         } elseif ($value instanceof Message) {
             $this->assertInstanceOf(Proto::class, $row[$field]);
-            $this->assertEquals($value->serializeToString(), $row[$field]->getValue());
+            $this->assertEquals(base64_encode($value->serializeToString()), $row[$field]->getValue());
             $this->assertEquals($value, $row[$field]->get());
         } else {
             $this->assertValues($value, $row[$field]);
@@ -357,11 +358,6 @@ public function testWriteAndReadBackFancyArrayValue($id, $field, $value)
         if ($value instanceof Bytes) {
             $this->assertEquals($value->formatAsString(), $row[$field]->formatAsString());
         } else {
-            if ($field === 'arrayProtoField' && $value !== null) {
-                foreach ($row[$field] as $i => $protoItem) {
-                    $row[$field][$i] = $protoItem->get();
-                }
-            }
             $this->assertValues($value, $row[$field]);
         }
     }
@@ -1194,6 +1190,8 @@ private function assertValues($expected, $actual, $delta = 0.000001)
             foreach ($expected as $key => $value) {
                 $this->assertValues($value, $actual[$key]);
             }
+        } elseif ($actual instanceof Proto) {
+            $this->assertEquals($expected, $actual->get());
         } else {
             $this->assertEquals($expected, $actual);
         }
diff --git a/Spanner/tests/Unit/DatabaseTest.php b/Spanner/tests/Unit/DatabaseTest.php
index 535d1709ebc0..a116971fcc32 100644
--- a/Spanner/tests/Unit/DatabaseTest.php
+++ b/Spanner/tests/Unit/DatabaseTest.php
@@ -17,6 +17,7 @@
 
 namespace Google\Cloud\Spanner\Tests\Unit;
 
+use BadMethodCallException;
 use Google\ApiCore\OperationResponse;
 use Google\ApiCore\Page;
 use Google\ApiCore\PagedListResponse;
@@ -41,6 +42,7 @@
 use Google\Cloud\Spanner\Admin\Database\V1\ListBackupsResponse;
 use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
 use Google\Cloud\Spanner\Database;
+use Google\Cloud\Spanner\Date;
 use Google\Cloud\Spanner\Instance;
 use Google\Cloud\Spanner\KeySet;
 use Google\Cloud\Spanner\Operation;
@@ -86,6 +88,7 @@
 use Google\Protobuf\Value;
 use Google\Rpc\Code;
 use Google\Rpc\Status;
+use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
@@ -110,7 +113,7 @@ class DatabaseTest extends TestCase
     const TRANSACTION_TAG = 'my-transaction-tag';
     const TEST_TABLE_NAME = 'Users';
     const TIMESTAMP = '2017-01-09T18:05:22.534799Z';
-    const BEGIN_RW_OPTIONS = ['begin' => ['readWrite' => [], 'isolationLevel' => 0]];
+    const BEGIN_RW_OPTIONS = ['begin' => ['readWrite' => []]];
 
     private const DIRECTED_READ_OPTIONS_INCLUDE_REPLICAS = [
         'includeReplicas' => [
@@ -863,7 +866,7 @@ public function testRunTransaction()
 
     public function testRunTransactionNoCommit()
     {
-        $this->expectException(\InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
 
         $this->spannerClient->beginTransaction(Argument::cetera())->shouldNotBeCalled();
 
@@ -874,7 +877,7 @@ public function testRunTransactionNoCommit()
 
     public function testRunTransactionNestedTransaction()
     {
-        $this->expectException(\BadMethodCallException::class);
+        $this->expectException(BadMethodCallException::class);
 
         $this->spannerClient->beginTransaction(Argument::cetera())->shouldNotBeCalled();
 
@@ -1328,20 +1331,12 @@ public function testDelete()
 
         $this->spannerClient->commit(
             Argument::that(function ($request) use ($table, $keys) {
-                $request = $this->serializer->encodeMessage($request);
-
-                if ($request['mutations'][0][Operation::OP_DELETE]['table'] !== $table) {
-                    return false;
-                }
-
-                if ($request['mutations'][0][Operation::OP_DELETE]['keySet']['keys'][0][0] !== (string) $keys[0]) {
-                    return false;
-                }
-
-                if ($request['mutations'][0][Operation::OP_DELETE]['keySet']['keys'][1][0] !== $keys[1]) {
-                    return false;
-                }
-
+                $mutation = $request->getMutations()[0]->getDelete();
+                $this->assertNotNull($mutation);
+                $this->assertEquals($table, $mutation->getTable());
+                $keySet = $this->serializer->encodeMessage($mutation->getKeySet());
+                $this->assertEquals($keys[0], $keySet['keys'][0][0]);
+                $this->assertEquals($keys[1], $keySet['keys'][1][0]);
                 return true;
             }),
             Argument::type('array')
@@ -1573,10 +1568,10 @@ public function testSetOrderBy()
         ];
 
         $res = $this->database->read(
-            $table,
+            'Table',
             new KeySet(['all' => true]),
             ['ID'],
-            $options
+            ['orderBy' => OrderBy::ORDER_BY_PRIMARY_KEY],
         );
         $this->assertInstanceOf(Result::class, $res);
         $rows = iterator_to_array($res->rows());
diff --git a/Spanner/tests/Unit/InstanceConfigurationTest.php b/Spanner/tests/Unit/InstanceConfigurationTest.php
index 93c3ece1a348..9b5df8c3df95 100644
--- a/Spanner/tests/Unit/InstanceConfigurationTest.php
+++ b/Spanner/tests/Unit/InstanceConfigurationTest.php
@@ -21,6 +21,7 @@
 use Google\ApiCore\OperationResponse;
 use Google\Cloud\Core\Testing\GrpcTestTrait;
 use Google\Cloud\Spanner\Admin\Instance\V1\Client\InstanceAdminClient;
+use Google\Cloud\Spanner\Admin\Instance\V1\CreateInstanceConfigRequest;
 use Google\Cloud\Spanner\Admin\Instance\V1\DeleteInstanceConfigRequest;
 use Google\Cloud\Spanner\Admin\Instance\V1\GetInstanceConfigRequest;
 use Google\Cloud\Spanner\Admin\Instance\V1\InstanceConfig;
@@ -286,4 +287,64 @@ private function getDefaultInstance()
     {
         return json_decode(file_get_contents(Fixtures::INSTANCE_CONFIG_FIXTURE()), true);
     }
+
+    public function testCreate()
+    {
+        $expectedInstanceConfig = new InstanceConfig([
+            'name' => InstanceAdminClient::instanceConfigName(self::PROJECT_ID, 'foo'),
+            'display_name' => 'bar2'
+        ]);
+        $result = new Any();
+        $result->pack($expectedInstanceConfig);
+        $metadata = new Any();
+        $metadata->pack(new UpdateInstanceConfigMetadata());
+        $operationProto = new Operation([
+            'response' => $result,
+            'metadata' => $metadata,
+            'done' => true
+        ]);
+
+        $operationResponse = new OperationResponse(
+            'operation-name',
+            $this->operationsClient->reveal(),
+            [
+                'operationReturnType' => InstanceConfig::class,
+                'lastProtoResponse' => $operationProto,
+            ]
+        );
+
+        $this->instanceAdminClient->resumeOperation($operationResponse->getName())
+            ->shouldBeCalledOnce()
+            ->willReturn($operationResponse);
+
+        $this->instanceAdminClient->createInstanceConfig(
+            Argument::type(CreateInstanceConfigRequest::class),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce()
+            ->willReturn($operationResponse);
+
+        $instanceConfig = new InstanceConfiguration(
+            $this->instanceAdminClient->reveal(),
+            $this->serializer,
+            self::PROJECT_ID,
+            self::NAME
+        );
+
+        $baseConfig = $this->prophesize(InstanceConfiguration::class);
+        $baseConfig->name()->willReturn('base-config');
+        $baseConfig->info()->willReturn([]);
+
+        $operation = $instanceConfig->create(
+            $baseConfig->reveal(),
+            [],  // Add some replicas if needed for a valid request
+            ['displayName' => self::NAME]
+        );
+        $operation->pollUntilComplete();
+        $createdInstanceConfig = $operation->result();
+
+        $this->assertInstanceOf(InstanceConfiguration::class, $createdInstanceConfig);
+        $this->assertEquals($expectedInstanceConfig->getName(), $createdInstanceConfig->name());
+        $this->assertEquals($expectedInstanceConfig->getDisplayName(), $createdInstanceConfig->info()['displayName']);
+    }
 }
diff --git a/Spanner/tests/Unit/InstanceTest.php b/Spanner/tests/Unit/InstanceTest.php
index e85f7fce7a9d..97a7f3378afd 100644
--- a/Spanner/tests/Unit/InstanceTest.php
+++ b/Spanner/tests/Unit/InstanceTest.php
@@ -49,6 +49,7 @@
 use Google\Cloud\Spanner\V1\ExecuteSqlRequest;
 use Google\Cloud\Spanner\V1\Session;
 use Google\LongRunning\Operation;
+use Google\Protobuf\Timestamp;
 use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
@@ -64,8 +65,8 @@ class InstanceTest extends TestCase
     use ProphecyTrait;
     use ResultGeneratorTrait;
 
-    const PROJECT_ID = 'test-project';
-    const NAME = 'instance-name';
+    const PROJECT = 'test-project';
+    const INSTANCE = 'instance-name';
     const DATABASE = 'database-name';
     const BACKUP = 'my-backup';
     const SESSION = 'projects/test-project/instances/instance-name/databases/database-name/sessions/session';
@@ -106,15 +107,17 @@ public function setUp(): void
             $this->instanceAdminClient->reveal(),
             $this->databaseAdminClient->reveal(),
             $this->serializer,
-            self::PROJECT_ID,
-            self::NAME,
-            ['directedReadOptions' => $this->directedReadOptionsIncludeReplicas]
+            self::PROJECT,
+            self::INSTANCE,
+            [
+                'directedReadOptions' => $this->directedReadOptionsIncludeReplicas,
+            ]
         );
     }
 
     public function testName()
     {
-        $this->assertEquals(self::NAME, InstanceAdminClient::parseName($this->instance->name())['instance']);
+        $this->assertEquals(self::INSTANCE, InstanceAdminClient::parseName($this->instance->name())['instance']);
     }
 
     public function testInfo()
@@ -365,7 +368,7 @@ public function testDelete()
             Argument::that(function ($request) {
                 $this->assertEquals(
                     $request->getName(),
-                    InstanceAdminClient::instanceName(self::PROJECT_ID, self::NAME)
+                    InstanceAdminClient::instanceName(self::PROJECT, self::INSTANCE)
                 );
                 return true;
             }),
@@ -386,7 +389,7 @@ public function testCreateDatabase()
                 $this->assertEquals($message['createStatement'], $createStatement);
                 $this->assertEquals(
                     $message['parent'],
-                    InstanceAdminClient::instanceName(self::PROJECT_ID, self::NAME)
+                    InstanceAdminClient::instanceName(self::PROJECT, self::INSTANCE)
                 );
                 $this->assertEquals($message['extraStatements'], $extra);
                 return true;
@@ -405,7 +408,7 @@ public function testCreateDatabase()
 
     public function testCreateDatabaseFromBackupName()
     {
-        $backupName = DatabaseAdminClient::backupName(self::PROJECT_ID, self::NAME, self::BACKUP);
+        $backupName = DatabaseAdminClient::backupName(self::PROJECT, self::INSTANCE, self::BACKUP);
 
         $this->databaseAdminClient->restoreDatabase(
             Argument::that(function ($request) use ($backupName) {
@@ -452,12 +455,18 @@ public function testDatabase()
 
     public function testDatabases()
     {
+        $dbName1 = DatabaseAdminClient::databaseName(self::PROJECT, self::INSTANCE, 'database1');
+        $dbName2 = DatabaseAdminClient::databaseName(self::PROJECT, self::INSTANCE, 'database2');
+
         $databases = [
-            new DatabaseProto(['name' => DatabaseAdminClient::databaseName(self::PROJECT_ID, self::NAME, 'database1')]),
-            new DatabaseProto(['name' => DatabaseAdminClient::databaseName(self::PROJECT_ID, self::NAME, 'database2')])
+            new DatabaseProto(['name' => $dbName1]),
+            new DatabaseProto(['name' => $dbName2]),
         ];
 
-        $this->page->getResponseObject()->willReturn(new ListDatabasesResponse(['databases' => $databases]));
+        $this->page
+            ->getResponseObject()
+            ->shouldBeCalledOnce()
+            ->willReturn(new ListDatabasesResponse(['databases' => $databases]));
 
         $this->databaseAdminClient->listDatabases(
             Argument::that(function ($request) {
@@ -494,9 +503,12 @@ public function testDatabases()
 
     public function testDatabasesPaged()
     {
+        $dbName1 = DatabaseAdminClient::databaseName(self::PROJECT, self::INSTANCE, 'database1');
+        $dbName2 = DatabaseAdminClient::databaseName(self::PROJECT, self::INSTANCE, 'database2');
+
         $databases = [
-            new DatabaseProto(['name' => DatabaseAdminClient::databaseName(self::PROJECT_ID, self::NAME, 'database1')]),
-            new DatabaseProto(['name' => DatabaseAdminClient::databaseName(self::PROJECT_ID, self::NAME, 'database2')]),
+            new DatabaseProto(['name' => $dbName1]),
+            new DatabaseProto(['name' => $dbName2]),
         ];
 
         $page1 = $this->prophesize(Page::class);
@@ -571,8 +583,8 @@ public function testBackup()
     public function testBackups()
     {
         $backups = [
-            new BackupProto(['name' => DatabaseAdminClient::backupName(self::PROJECT_ID, self::NAME, 'backup1')]),
-            new BackupProto(['name' => DatabaseAdminClient::backupName(self::PROJECT_ID, self::NAME, 'backup2')]),
+            new BackupProto(['name' => DatabaseAdminClient::backupName(self::PROJECT, self::INSTANCE, 'backup1')]),
+            new BackupProto(['name' => DatabaseAdminClient::backupName(self::PROJECT, self::INSTANCE, 'backup2')]),
         ];
 
         $this->page->getResponseObject()->willReturn(new ListBackupsResponse(['backups' => $backups]));
diff --git a/Spanner/tests/Unit/OperationTest.php b/Spanner/tests/Unit/OperationTest.php
index e646185d6b23..a029e8c10026 100644
--- a/Spanner/tests/Unit/OperationTest.php
+++ b/Spanner/tests/Unit/OperationTest.php
@@ -17,6 +17,7 @@
 
 namespace Google\Cloud\Spanner\Tests\Unit;
 
+use Google\ApiCore\ApiException;
 use Google\ApiCore\ServerStream;
 use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\Testing\GrpcTestTrait;
@@ -187,7 +188,7 @@ public function testCommitWithReturnCommitStats()
         $this->assertEquals([
             'commitTimestamp' => self::TIMESTAMP,
             'commitStats' => ['mutationCount' => 1]
-        ], $res[1]);
+        ], $this->serializer->encodeMessage($res[1]));
     }
 
     public function testCommitWithMaxCommitDelay()
@@ -222,7 +223,7 @@ public function testCommitWithMaxCommitDelay()
         $this->assertInstanceOf(Timestamp::class, $res[0]);
         $this->assertEquals([
             'commitTimestamp' => self::TIMESTAMP,
-        ], $res[1]);
+        ], $this->serializer->encodeMessage($res[1]));
     }
 
     public function testCommitWithExistingTransaction()
@@ -419,36 +420,42 @@ public function testTransactionNoTag()
         $this->assertEquals(self::TRANSACTION, $t->id());
     }
 
-    public function testTransactionWithExcludeTxnFromChangeStreams()
+    public function testTransactionWithReadLockMode()
     {
         $this->spannerClient->beginTransaction(
             Argument::that(function (BeginTransactionRequest $request) {
-                $this->assertTrue($request->getOptions()->getExcludeTxnFromChangeStreams());
+                $this->assertNotNull($txnOptions = $request->getOptions());
+                $this->assertNotNull($readWriteTxnOptions = $txnOptions->getReadWrite());
+                $this->assertEquals(ReadLockMode::OPTIMISTIC, $readWriteTxnOptions->getReadLockMode());
                 return true;
             }),
             Argument::type('array')
         )
-            ->shouldBeCalled()
+            ->shouldBeCalledOnce()
             ->willReturn(new TransactionProto(['id' => 'foo']));
 
         $transaction = $this->operation->transaction($this->session, [
-           'transactionOptions' => ['excludeTxnFromChangeStreams' => true]
+            'transactionOptions' => ['readWrite' => ['readLockMode' => ReadLockMode::OPTIMISTIC]]
         ]);
 
         $this->assertEquals('foo', $transaction->id());
     }
 
-    public function testExecuteAndExecuteUpdateWithExcludeTxnFromChangeStreams()
+    public function testExecuteAndExecuteUpdateWithReadLockMode()
     {
         $sql = 'SELECT example FROM sql_query';
 
-        $resultSet = new ResultSet(['stats' => new ResultSetStats(['row_count_exact' => 0])]);
         $stream = $this->prophesize(ServerStream::class);
-        $stream->readAll()->shouldBeCalledTimes(2)->willReturn([$resultSet]);
+        $stream->readAll()
+            ->shouldBeCalledTimes(2)
+            ->willReturn([new ResultSet(['stats' => new ResultSetStats(['row_count_exact' => 0])])]);
 
         $this->spannerClient->executeStreamingSql(
             Argument::that(function (ExecuteSqlRequest $request) {
-                $this->assertTrue($request->getTransaction()->getBegin()->getExcludeTxnFromChangeStreams());
+                $this->assertNotNull($transaction = $request->getTransaction());
+                $this->assertNotNull($txnOptions = $transaction->getBegin());
+                $this->assertNotNull($readWriteTxnOptions = $txnOptions->getReadWrite());
+                $this->assertEquals(ReadLockMode::OPTIMISTIC, $readWriteTxnOptions->getReadLockMode());
                 return true;
             }),
             Argument::type('array')
@@ -456,53 +463,50 @@ public function testExecuteAndExecuteUpdateWithExcludeTxnFromChangeStreams()
             ->shouldBeCalledTimes(2)
             ->willReturn($stream->reveal());
 
-        $this->operation->execute($this->session, $sql, [
-           'transaction' => ['begin' => ['excludeTxnFromChangeStreams' => true]]
-        ]);
+        $lockModeOptions = [
+            'transaction' => [
+                'begin' => [
+                    'readWrite' => ['readLockMode' => ReadLockMode::OPTIMISTIC],
+                ]
+            ]
+         ];
 
-        $transaction = $this->prophesize(Transaction::class)->reveal();
+        $this->operation->execute($this->session, $sql, $lockModeOptions);
 
-        $this->operation->executeUpdate($this->session, $transaction, $sql, [
-           'transaction' => ['begin' => ['excludeTxnFromChangeStreams' => true]]
-        ]);
+        $transaction = $this->prophesize(Transaction::class)->reveal();
+        $this->operation->executeUpdate($this->session, $transaction, $sql, $lockModeOptions);
     }
 
-    public function testTransactionWithReadLockMode()
+    public function testTransactionWithExcludeTxnFromChangeStreams()
     {
         $this->spannerClient->beginTransaction(
             Argument::that(function (BeginTransactionRequest $request) {
-                $this->assertNotNull($txnOptions = $request->getOptions());
-                $this->assertNotNull($readWriteTxnOptions = $txnOptions->getReadWrite());
-                $this->assertEquals(ReadLockMode::OPTIMISTIC, $readWriteTxnOptions->getReadLockMode());
+                $this->assertTrue($request->getOptions()->getExcludeTxnFromChangeStreams());
                 return true;
             }),
             Argument::type('array')
         )
-            ->shouldBeCalledOnce()
+            ->shouldBeCalled()
             ->willReturn(new TransactionProto(['id' => 'foo']));
 
         $transaction = $this->operation->transaction($this->session, [
-            'transactionOptions' => ['readWrite' => ['readLockMode' => ReadLockMode::OPTIMISTIC]]
+           'transactionOptions' => ['excludeTxnFromChangeStreams' => true]
         ]);
 
         $this->assertEquals('foo', $transaction->id());
     }
 
-    public function testExecuteAndExecuteUpdateWithReadLockMode()
+    public function testExecuteAndExecuteUpdateWithExcludeTxnFromChangeStreams()
     {
         $sql = 'SELECT example FROM sql_query';
 
+        $resultSet = new ResultSet(['stats' => new ResultSetStats(['row_count_exact' => 0])]);
         $stream = $this->prophesize(ServerStream::class);
-        $stream->readAll()
-            ->shouldBeCalledTimes(2)
-            ->willReturn([new ResultSet(['stats' => new ResultSetStats(['row_count_exact' => 0])])]);
+        $stream->readAll()->shouldBeCalledTimes(2)->willReturn([$resultSet]);
 
         $this->spannerClient->executeStreamingSql(
             Argument::that(function (ExecuteSqlRequest $request) {
-                $this->assertNotNull($transaction = $request->getTransaction());
-                $this->assertNotNull($txnOptions = $transaction->getBegin());
-                $this->assertNotNull($readWriteTxnOptions = $txnOptions->getReadWrite());
-                $this->assertEquals(ReadLockMode::OPTIMISTIC, $readWriteTxnOptions->getReadLockMode());
+                $this->assertTrue($request->getTransaction()->getBegin()->getExcludeTxnFromChangeStreams());
                 return true;
             }),
             Argument::type('array')
@@ -510,18 +514,15 @@ public function testExecuteAndExecuteUpdateWithReadLockMode()
             ->shouldBeCalledTimes(2)
             ->willReturn($stream->reveal());
 
-        $lockModeOptions = [
-            'transaction' => [
-                'begin' => [
-                    'readWrite' => ['readLockMode' => ReadLockMode::OPTIMISTIC],
-                ]
-            ]
-         ];
-
-        $this->operation->execute($this->session, $sql, $lockModeOptions);
+        $this->operation->execute($this->session, $sql, [
+           'transaction' => ['begin' => ['excludeTxnFromChangeStreams' => true]]
+        ]);
 
         $transaction = $this->prophesize(Transaction::class)->reveal();
-        $this->operation->executeUpdate($this->session, $transaction, $sql, $lockModeOptions);
+
+        $this->operation->executeUpdate($this->session, $transaction, $sql, [
+           'transaction' => ['begin' => ['excludeTxnFromChangeStreams' => true]]
+        ]);
     }
 
     public function testSnapshot()
diff --git a/Spanner/tests/Unit/SpannerClientTest.php b/Spanner/tests/Unit/SpannerClientTest.php
index 7b1a8fefd114..5853d112bc1a 100644
--- a/Spanner/tests/Unit/SpannerClientTest.php
+++ b/Spanner/tests/Unit/SpannerClientTest.php
@@ -50,6 +50,7 @@
 use Google\Cloud\Spanner\V1\Client\SpannerClient as GapicSpannerClient;
 use Google\Cloud\Spanner\V1\TransactionOptions\IsolationLevel;
 use Google\Protobuf\Duration;
+use Google\Protobuf\Timestamp as TimestampProto;
 use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
@@ -68,10 +69,12 @@ class SpannerClientTest extends TestCase
     const INSTANCE = 'inst';
     const DATABASE = 'db';
     const CONFIG = 'conf';
+    const SESSION = 'sess';
 
     private $serializer;
     private SpannerClient $spannerClient;
     private $instanceAdminClient;
+    private $gapicSpannerClient;
     private $directedReadOptionsIncludeReplicas;
     private $operationResponse;
 
@@ -107,7 +110,7 @@ public function testBatch()
         $batch = $this->spannerClient->batch('foo', 'bar');
         $this->assertInstanceOf(BatchClient::class, $batch);
 
-        $ref = new \ReflectionObject($batch);
+        $ref = new ReflectionClass($batch);
         $prop = $ref->getProperty('databaseName');
         $prop->setAccessible(true);
 
@@ -523,7 +526,7 @@ public function testCommitTimestamp()
     public function testSpannerClientDatabaseRole()
     {
         $instance = $this->prophesize(Instance::class);
-        $instance->database(Argument::any(), ['databaseRole' => 'Reader'])->shouldBeCalled();
+        $instance->database(Argument::any(), Argument::withEntry('databaseRole', 'Reader'))->shouldBeCalled();
         $this->spannerClient->connect($instance->reveal(), self::DATABASE, ['databaseRole' => 'Reader']);
     }
 
diff --git a/Spanner/tests/Unit/TransactionTest.php b/Spanner/tests/Unit/TransactionTest.php
index 3f643e34b313..4e246299c2b7 100644
--- a/Spanner/tests/Unit/TransactionTest.php
+++ b/Spanner/tests/Unit/TransactionTest.php
@@ -17,9 +17,11 @@
 
 namespace Google\Cloud\Spanner\Tests\Unit;
 
+use DateTimeImmutable;
 use Google\ApiCore\ValidationException;
 use Google\Cloud\Core\ApiHelperTrait;
 use Google\Cloud\Core\Testing\GrpcTestTrait;
+use Google\Cloud\Core\Timestamp;
 use Google\Cloud\Core\TimeTrait;
 use Google\Cloud\Spanner\BatchDmlResult;
 use Google\Cloud\Spanner\Database;
@@ -29,9 +31,10 @@
 use Google\Cloud\Spanner\Serializer;
 use Google\Cloud\Spanner\Session\Session;
 use Google\Cloud\Spanner\Tests\ResultGeneratorTrait;
-use Google\Cloud\Spanner\Timestamp;
 use Google\Cloud\Spanner\Transaction;
 use Google\Cloud\Spanner\V1\Client\SpannerClient;
+use Google\Cloud\Spanner\V1\CommitResponse;
+use Google\Cloud\Spanner\V1\CommitResponse\CommitStats;
 use Google\Cloud\Spanner\V1\ExecuteBatchDmlRequest;
 use Google\Cloud\Spanner\V1\ExecuteBatchDmlResponse;
 use Google\Cloud\Spanner\V1\ExecuteSqlRequest;
@@ -41,11 +44,13 @@
 use Google\Cloud\Spanner\V1\RollbackRequest;
 use Google\Cloud\Spanner\V1\TransactionOptions\IsolationLevel;
 use Google\Protobuf\Duration;
+use Google\Protobuf\Timestamp as TimestampProto;
 use Google\Rpc\Status;
 use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
+use ReflectionClass;
 
 /**
  * @group spanner
@@ -427,7 +432,7 @@ public function testRead()
             })
         )
             ->shouldBeCalledOnce()
-            ->willReturn($this->resultGeneratorStream());
+            ->willReturn($this->resultGeneratorStream([]));
 
         $res = $this->transaction->read(
             $table,
@@ -507,7 +512,7 @@ public function testCommitWithReturnCommitStats()
         $transaction->insert('Posts', ['foo' => 'bar']);
         $transaction->commit(['returnCommitStats' => true]);
 
-        $this->assertEquals(['mutationCount' => 1], $transaction->getCommitStats());
+        $this->assertEquals(1, $transaction->getCommitStats()->getMutationCount());
     }
 
     public function testCommitWithMaxCommitDelay()
@@ -549,7 +554,7 @@ public function testCommitWithMaxCommitDelay()
             'maxCommitDelay' => $duration
         ]);
 
-        $this->assertEquals(['mutationCount' => 1], $transaction->getCommitStats());
+        $this->assertEquals(1, $transaction->getCommitStats()->getMutationCount());
     }
 
     public function testCommitInvalidState()
@@ -559,7 +564,10 @@ public function testCommitInvalidState()
         $operation = $this->prophesize(Operation::class);
         $operation->commitWithResponse(Argument::cetera())
             ->shouldBeCalledOnce()
-            ->willReturn([$this->prophesize(Timestamp::class)->reveal()]);
+            ->willReturn([
+                $this->prophesize(Timestamp::class)->reveal(),
+                new CommitResponse(),
+            ]);
 
         $transaction = new Transaction(
             $operation->reveal(),
@@ -596,7 +604,10 @@ public function testRollbackInvalidState()
         $operation = $this->prophesize(Operation::class);
         $operation->commitWithResponse(Argument::cetera())
             ->shouldBeCalledOnce()
-            ->willReturn([$this->prophesize(Timestamp::class)->reveal()]);
+            ->willReturn([
+                $this->prophesize(Timestamp::class)->reveal(),
+                new CommitResponse(),
+            ]);
 
         $transaction = new Transaction(
             $operation->reveal(),
@@ -622,7 +633,10 @@ public function testState()
         $operation = $this->prophesize(Operation::class);
         $operation->commitWithResponse(Argument::cetera())
             ->shouldBeCalledOnce()
-            ->willReturn([$this->prophesize(Timestamp::class)->reveal()]);
+            ->willReturn([
+                $this->prophesize(Timestamp::class)->reveal(),
+                new CommitResponse(),
+            ]);
 
         $transaction = new Transaction(
             $operation->reveal(),
@@ -737,14 +751,12 @@ public function testSingleUseWithIsolationLevelThrowsAnExceptionOnReadOnly()
 
     private function commitResponseWithCommitStats()
     {
-        $time = $this->parseTimeString(self::TIMESTAMP);
-        $timestamp = new Timestamp($time[0], $time[1]);
         return [
-            $timestamp,
-            [
-                'commitTimestamp' => self::TIMESTAMP,
-                'commitStats' => ['mutationCount' => 1]
-            ]
+            new Timestamp(new \DateTimeImmutable()),
+            new CommitResponse([
+                'commit_timestamp' => new TimestampProto(['seconds' => strtotime(self::TIMESTAMP)]),
+                'commit_stats' => new CommitStats(['mutation_count' => 1])
+            ])
         ];
     }
 }
diff --git a/Spanner/tests/Unit/TransactionTypeTest.php b/Spanner/tests/Unit/TransactionTypeTest.php
index 2109599777cc..add5d40fe5e1 100644
--- a/Spanner/tests/Unit/TransactionTypeTest.php
+++ b/Spanner/tests/Unit/TransactionTypeTest.php
@@ -25,7 +25,6 @@
 use Google\Cloud\Spanner\Database;
 use Google\Cloud\Spanner\Instance;
 use Google\Cloud\Spanner\KeySet;
-use Google\Cloud\Spanner\Operation;
 use Google\Cloud\Spanner\Serializer;
 use Google\Cloud\Spanner\Session\SessionPoolInterface;
 use Google\Cloud\Spanner\Snapshot;
@@ -72,9 +71,9 @@ class TransactionTypeTest extends TestCase
     const SESSION = 'my-session';
 
     private $spannerClient;
-    private $serializer;
     private $timestamp;
     private $protoTimestamp;
+    private $database;
 
     public function setUp(): void
     {
@@ -86,25 +85,10 @@ public function setUp(): void
         $this->protoTimestamp = new TimestampProto(['seconds' => $time->format('U'), 'nanos' => $nanos]);
 
         $this->spannerClient = $this->prophesize(SpannerClient::class);
-        $this->serializer = $this->prophesize(Serializer::class);
 
-        // mock serializer responses for sessions (used for streaming tests)
-        $this->serializer = $this->prophesize(Serializer::class);
-        $this->serializer->decodeMessage(
-            Argument::type(CreateSessionRequest::class),
-            Argument::type('array')
-        )
-            ->willReturn(new CreateSessionRequest([
-                'database' => SpannerClient::databaseName(self::PROJECT, self::INSTANCE, self::DATABASE)
-            ]));
-        $this->serializer->encodeMessage(Argument::type(Session::class))
-            ->willReturn(['name' => $this->getFullyQualifiedSessionName()]);
-
-        $this->serializer->decodeMessage(
-            Argument::type(DeleteSessionRequest::class),
-            Argument::type('array')
-        )
-            ->willReturn(new DeleteSessionRequest());
+        $instance = $this->prophesize(Instance::class);
+        $instance->name()->willReturn(InstanceAdminClient::instanceName(self::PROJECT, self::INSTANCE));
+        $instance->directedReadOptions()->willReturn([]);
 
         $this->spannerClient->createSession(
             Argument::that(function (CreateSessionRequest $request) {
@@ -118,8 +102,14 @@ public function setUp(): void
         )
             ->willReturn(new Session(['name' => $this->getFullyQualifiedSessionName()]));
 
-        $this->spannerClient->deleteSession(Argument::cetera())
-            ->shouldBeCalledOnce();
+        $this->database = new Database(
+            $this->spannerClient->reveal(),
+            $this->prophesize(DatabaseAdminClient::class)->reveal(),
+            new Serializer(),
+            $instance->reveal(),
+            self::PROJECT,
+            self::DATABASE,
+        );
     }
 
     public function testDatabaseRunTransactionPreAllocate()
@@ -142,11 +132,9 @@ public function testDatabaseRunTransactionPreAllocate()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse(['commit_timestamp' => $this->protoTimestamp]));
+            ->willReturn(new CommitResponse());
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $database->runTransaction(function ($t) {
+        $this->database->runTransaction(function ($t) {
             // Transaction gets created at the commit operation
             $t->commit();
         });
@@ -167,11 +155,9 @@ public function testDatabaseRunTransactionSingleUse()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse(['commit_timestamp' => $this->protoTimestamp]));
-
-        $database = $this->database($this->spannerClient->reveal());
+            ->willReturn(new CommitResponse());
 
-        $database->runTransaction(function ($t) {
+        $this->database->runTransaction(function ($t) {
             $this->assertNull($t->id());
 
             $t->commit();
@@ -190,8 +176,7 @@ public function testDatabaseTransactionPreAllocate()
             ->shouldBeCalledOnce()
             ->willReturn(new TransactionProto(['id' => self::TRANSACTION]));
 
-        $database = $this->database($this->spannerClient->reveal());
-        $transaction = $database->transaction();
+        $transaction = $this->database->transaction();
 
         $this->assertInstanceOf(Transaction::class, $transaction);
         $this->assertEquals($transaction->id(), self::TRANSACTION);
@@ -201,9 +186,7 @@ public function testDatabaseTransactionSingleUse()
     {
         $this->spannerClient->beginTransaction(Argument::cetera())->shouldNotBeCalled();
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $transaction = $database->transaction(['singleUse' => true]);
+        $transaction = $this->database->transaction(['singleUse' => true]);
 
         $this->assertInstanceOf(Transaction::class, $transaction);
         $this->assertNull($transaction->id());
@@ -224,11 +207,7 @@ public function testDatabaseSnapshotPreAllocate()
             ->shouldBeCalledOnce()
             ->willReturn(new TransactionProto(['id' => self::TRANSACTION]));
 
-        $database = $database = $this->database(
-            $this->spannerClient->reveal(),
-        );
-
-        $snapshot = $database->snapshot();
+        $snapshot = $this->database->snapshot();
 
         $this->assertInstanceOf(Snapshot::class, $snapshot);
         $this->assertEquals($snapshot->id(), self::TRANSACTION);
@@ -238,11 +217,7 @@ public function testDatabaseSnapshotSingleUse()
     {
         $this->spannerClient->beginTransaction(Argument::cetera())->shouldNotBeCalled();
 
-        $database = $database = $this->database(
-            $this->spannerClient->reveal(),
-        );
-
-        $snapshot = $database->snapshot(['singleUse' => true]);
+        $snapshot = $this->database->snapshot(['singleUse' => true]);
 
         $this->assertInstanceOf(Snapshot::class, $snapshot);
         $this->assertNull($snapshot->id());
@@ -271,8 +246,7 @@ public function testDatabaseSingleUseSnapshotMinReadTimestampAndMaxStaleness($ch
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-        $snapshot = $database->snapshot([
+        $snapshot = $this->database->snapshot([
             'singleUse' => true,
             'minReadTimestamp' => $this->timestamp,
             'maxStaleness' => $duration
@@ -289,9 +263,7 @@ public function testDatabasePreAllocatedSnapshotMinReadTimestamp()
         $this->spannerClient->executeStreamingSql(Argument::cetera())->shouldNotBeCalled();
         $this->spannerClient->deleteSession(Argument::cetera())->shouldNotBeCalled();
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $database->snapshot([
+        $this->database->snapshot([
             'minReadTimestamp' => $this->timestamp,
         ]);
     }
@@ -308,9 +280,7 @@ public function testDatabasePreAllocatedSnapshotMaxStaleness()
         $this->spannerClient->executeStreamingSql(Argument::cetera())->shouldNotBeCalled();
         $this->spannerClient->deleteSession(Argument::cetera())->shouldNotBeCalled();
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $database->snapshot([
+        $this->database->snapshot([
             'maxStaleness' => $duration
         ]);
     }
@@ -338,9 +308,7 @@ public function testDatabaseSnapshotSingleUseReadTimestampAndExactStaleness($chu
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $snapshot = $database->snapshot([
+        $snapshot = $this->database->snapshot([
             'singleUse' => true,
             'readTimestamp' => $this->timestamp,
             'exactStaleness' => $duration
@@ -379,8 +347,7 @@ public function testDatabaseSnapshotPreAllocateReadTimestampAndExactStaleness($c
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-        $snapshot = $database->snapshot([
+        $snapshot = $this->database->snapshot([
             'readTimestamp' => $this->timestamp,
             'exactStaleness' => $duration
         ]);
@@ -404,9 +371,7 @@ public function testDatabaseSingleUseSnapshotStrongConsistency($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $snapshot = $database->snapshot([
+        $snapshot = $this->database->snapshot([
             'singleUse' => true,
             'strong' => true
         ]);
@@ -437,9 +402,7 @@ public function testDatabasePreAllocatedSnapshotStrongConsistency($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $snapshot = $database->snapshot([
+        $snapshot = $this->database->snapshot([
             'strong' => true
         ]);
 
@@ -462,9 +425,7 @@ public function testDatabaseSingleUseSnapshotDefaultsToStrongConsistency($chunks
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $snapshot = $database->snapshot([
+        $snapshot = $this->database->snapshot([
             'singleUse' => true,
         ]);
 
@@ -494,10 +455,7 @@ public function testDatabasePreAllocatedSnapshotDefaultsToStrongConsistency($chu
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $snapshot = $database->snapshot();
-
+        $snapshot = $this->database->snapshot();
         $snapshot->execute('SELECT * FROM Table')->rows()->current();
     }
 
@@ -524,9 +482,7 @@ public function testDatabaseSnapshotReturnReadTimestamp($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
-        $database = $this->database($this->spannerClient->reveal());
-
-        $snapshot = $database->snapshot([
+        $snapshot = $this->database->snapshot([
             'returnReadTimestamp' => true
         ]);
 
@@ -546,83 +502,81 @@ public function testDatabaseInsertSingleUseReadWrite()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse(['commit_timestamp' => $this->protoTimestamp]));
-
-        $database = $this->database($this->spannerClient->reveal());
+            ->willReturn(new CommitResponse());
 
-        $database->insert('Table', [
+        $this->database->insert('Table', [
             'column' => 'value'
         ]);
     }
 
     public function testDatabaseInsertBatchSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->insertBatch('Table', [[
+        $this->database->insertBatch('Table', [[
             'column' => 'value'
         ]]);
     }
 
     public function testDatabaseUpdateSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->update('Table', [
+        $this->database->update('Table', [
             'column' => 'value'
         ]);
     }
 
     public function testDatabaseUpdateBatchSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->updateBatch('Table', [[
+        $this->database->updateBatch('Table', [[
             'column' => 'value'
         ]]);
     }
 
     public function testDatabaseInsertOrUpdateSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->insertOrUpdate('Table', [
+        $this->database->insertOrUpdate('Table', [
             'column' => 'value'
         ]);
     }
 
     public function testDatabaseInsertOrUpdateBatchSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->insertOrUpdateBatch('Table', [[
+        $this->database->insertOrUpdateBatch('Table', [[
             'column' => 'value'
         ]]);
     }
 
     public function testDatabaseReplaceSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->replace('Table', [
+        $this->database->replace('Table', [
             'column' => 'value'
         ]);
     }
 
     public function testDatabaseReplaceBatchSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->replaceBatch('Table', [[
+        $this->database->replaceBatch('Table', [[
             'column' => 'value'
         ]]);
     }
 
     public function testDatabaseDeleteSingleUseReadWrite()
     {
-        $database = $this->createMockedCommitDatabase();
+        $this->createMockedCommitDatabase();
 
-        $database->delete('Table', new KeySet());
+        $this->database->delete('Table', new KeySet());
     }
 
     /**
@@ -645,8 +599,14 @@ public function testDatabaseExecuteSingleUseReadOnly($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
+        $this->spannerClient->deleteSession(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce();
+
         $serializer = $this->serializerForStreamingSql($chunks, $transaction);
-        $database = $this->database($this->spannerClient->reveal(), $serializer);
+        $database = $this->database($serializer);
         $database->execute('SELECT * FROM Table')->rows()->current();
     }
 
@@ -672,8 +632,14 @@ public function testDatabaseExecuteBeginReadOnly($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
+        $this->spannerClient->deleteSession(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce();
+
         $serializer = $this->serializerForStreamingSql($chunks, $transaction);
-        $database = $this->database($this->spannerClient->reveal(), $serializer);
+        $database = $this->database($serializer);
         $database->execute('SELECT * FROM Table', [
             'begin' => true
         ])->rows()->current();
@@ -697,8 +663,14 @@ public function testDatabaseExecuteBeginReadWrite($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
+        $this->spannerClient->deleteSession(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce();
+
         $serializer = $this->serializerForStreamingSql($chunks, $transaction);
-        $database = $this->database($this->spannerClient->reveal(), $serializer);
+        $database = $this->database($serializer);
         $database->execute('SELECT * FROM Table', [
             'begin' => true,
             'transactionType' => SessionPoolInterface::CONTEXT_READWRITE
@@ -725,8 +697,14 @@ public function testDatabaseReadSingleUseReadOnly($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
+        $this->spannerClient->deleteSession(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce();
+
         $serializer = $this->serializerForStreamingRead($chunks, $transaction);
-        $database = $this->database($this->spannerClient->reveal(), $serializer);
+        $database = $this->database($serializer);
         $database->read('Table', new KeySet(), [])->rows()->current();
     }
 
@@ -751,8 +729,14 @@ public function testDatabaseReadBeginReadOnly($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
+        $this->spannerClient->deleteSession(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce();
+
         $serializer = $this->serializerForStreamingRead($chunks, $transaction);
-        $database = $this->database($this->spannerClient->reveal(), $serializer);
+        $database = $this->database($serializer);
         $database->read('Table', new KeySet(), [], [
             'begin' => true
         ])->rows()->current();
@@ -776,8 +760,14 @@ public function testDatabaseReadBeginReadWrite($chunks)
             ->shouldBeCalledOnce()
             ->willReturn($this->resultGeneratorStream($chunks));
 
+        $this->spannerClient->deleteSession(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->shouldBeCalledOnce();
+
         $serializer = $this->serializerForStreamingRead($chunks, $transaction);
-        $database = $this->database($this->spannerClient->reveal(), $serializer);
+        $database = $this->database($serializer);
         $database->read('Table', new KeySet(), [], [
             'begin' => true,
             'transactionType' => SessionPoolInterface::CONTEXT_READWRITE
@@ -813,8 +803,7 @@ public function testTransactionPreAllocatedRollback()
         )
             ->shouldBeCalledOnce();
 
-        $database = $this->database($this->spannerClient->reveal());
-        $t = $database->transaction();
+        $t = $this->database->transaction();
         $t->rollback();
     }
 
@@ -825,33 +814,32 @@ public function testTransactionSingleUseRollback()
         $this->spannerClient->beginTransaction(Argument::cetera())->shouldNotBeCalled();
         $this->spannerClient->rollback(Argument::cetera())->shouldNotBeCalled();
 
-        $database = $this->database($this->spannerClient->reveal());
-        $t = $database->transaction(['singleUse' => true]);
+        $t = $this->database->transaction(['singleUse' => true]);
         $t->rollback();
     }
 
-    private function database(SpannerClient $spannerClient, ?Serializer $serializer = null)
+    private function database(?Serializer $serializer = null)
     {
         $instance = $this->prophesize(Instance::class);
         $instance->name()->willReturn(InstanceAdminClient::instanceName(self::PROJECT, self::INSTANCE));
         $instance->directedReadOptions()->willReturn([]);
 
-        $database = new Database(
-            $spannerClient,
+        return new Database(
+            $this->spannerClient->reveal(),
             $this->prophesize(DatabaseAdminClient::class)->reveal(),
             $serializer ?: new Serializer(),
             $instance->reveal(),
             self::PROJECT,
-            self::DATABASE
+            self::DATABASE,
         );
-
-        return $database;
     }
 
     private function serializerForStreamingRead(array $chunks, array $expectedTransaction): Serializer
     {
+        $serializer = $this->prophesize(Serializer::class);
+
         // mock serializer responses for streaming read
-        $this->serializer->decodeMessage(
+        $serializer->decodeMessage(
             Argument::type(ReadRequest::class),
             Argument::that(function ($data) use ($expectedTransaction) {
                 $this->assertEquals($data['transaction'], $expectedTransaction);
@@ -861,21 +849,44 @@ private function serializerForStreamingRead(array $chunks, array $expectedTransa
             ->shouldBeCalledOnce()
             ->willReturn(new ReadRequest());
 
+        $serializer->decodeMessage(
+            Argument::type(CreateSessionRequest::class),
+            Argument::type('array')
+        )
+            ->willReturn(new CreateSessionRequest([
+                'database' => SpannerClient::databaseName(self::PROJECT, self::INSTANCE, self::DATABASE),
+            ]));
+
+        $serializer->encodeMessage(
+            Argument::type(Session::class)
+        )
+            ->willReturn([
+                'name' => SpannerClient::sessionName(self::PROJECT, self::INSTANCE, self::DATABASE, self::SESSION),
+            ]);
+
+        $serializer->decodeMessage(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->willReturn(new DeleteSessionRequest());
+
         foreach ($chunks as $chunk) {
             $result = new PartialResultSet();
             $result->mergeFromJsonString($chunk);
-            $this->serializer->encodeMessage($result)
+            $serializer->encodeMessage($result)
                 ->shouldBeCalledOnce()
                 ->willReturn(json_decode($chunk, true));
         }
 
-        return $this->serializer->reveal();
+        return $serializer->reveal();
     }
 
     private function serializerForStreamingSql(array $chunks, array $expectedTransaction): Serializer
     {
+        $serializer = $this->prophesize(Serializer::class);
+
         // mock serializer responses for streaming read
-        $this->serializer->decodeMessage(
+        $serializer->decodeMessage(
             Argument::type(ExecuteSqlRequest::class),
             Argument::that(function ($data) use ($expectedTransaction) {
                 $this->assertEquals($expectedTransaction, $data['transaction']);
@@ -885,21 +896,42 @@ private function serializerForStreamingSql(array $chunks, array $expectedTransac
             ->shouldBeCalledOnce()
             ->willReturn(new ExecuteSqlRequest());
 
-        $this->serializer->decodeMessage(
+        $serializer->decodeMessage(
             Argument::type(BeginTransactionRequest::class),
             Argument::type('array')
         )
             ->willReturn(new BeginTransactionRequest());
 
+        $serializer->decodeMessage(
+            Argument::type(CreateSessionRequest::class),
+            Argument::type('array')
+        )
+            ->willReturn(new CreateSessionRequest([
+                'database' => SpannerClient::databaseName(self::PROJECT, self::INSTANCE, self::DATABASE),
+            ]));
+
+        $serializer->encodeMessage(
+            Argument::type(Session::class)
+        )
+            ->willReturn([
+                'name' => SpannerClient::sessionName(self::PROJECT, self::INSTANCE, self::DATABASE, self::SESSION),
+            ]);
+
+        $serializer->decodeMessage(
+            Argument::type(DeleteSessionRequest::class),
+            Argument::type('array')
+        )
+            ->willReturn(new DeleteSessionRequest());
+
         foreach ($chunks as $chunk) {
             $result = new PartialResultSet();
             $result->mergeFromJsonString($chunk);
-            $this->serializer->encodeMessage($result)
+            $serializer->encodeMessage($result)
                 ->shouldBeCalledOnce()
                 ->willReturn(json_decode($chunk, true));
         }
 
-        return $this->serializer->reveal();
+        return $serializer->reveal();
     }
 
     private function getFullyQualifiedSessionName()
@@ -945,8 +977,8 @@ private function createMockedCommitDatabase()
             Argument::type('array')
         )
             ->shouldBeCalledOnce()
-            ->willReturn(new CommitResponse(['commit_timestamp' => $this->protoTimestamp]));
-
-        return $this->database($this->spannerClient->reveal());
+            ->willReturn(new CommitResponse([
+                'commit_timestamp' => new TimestampProto(['seconds' => time()])
+            ]));
     }
 }
diff --git a/dev/sh/static-analysis b/dev/sh/static-analysis
index f250fa03635e..31c2d6befbe0 100755
--- a/dev/sh/static-analysis
+++ b/dev/sh/static-analysis
@@ -1,16 +1,22 @@
 #!/bin/bash
 
-# Create a temporary bootstrap file that combines the autoloader of the project and the dev autoloader
+set -euo pipefail
+
+# Create a temporary directory
 TMPDIR=$(mktemp -d 2>/dev/null || mktemp -d -t 'mytmpdir')
-echo "<?php require 'vendor/autoload.php';require 'dev/vendor/autoload.php';" > $TMPDIR/phpstan-bootstrap.php
+
+# Ensure the temporary directory is cleaned up on exit
+trap 'rm -rf "$TMPDIR"' EXIT
+
+# Create a temporary bootstrap file that combines the autoloader of the project and the dev autoloader
+echo "<?php require 'vendor/autoload.php';require 'dev/vendor/autoload.php';" > "$TMPDIR/phpstan-bootstrap.php"
 
 # Run phpstan
-dev/vendor/bin/phpstan analyse */src */metadata --autoload-file=$TMPDIR/phpstan-bootstrap.php
+dev/vendor/bin/phpstan analyse */src */metadata --autoload-file="$TMPDIR/phpstan-bootstrap.php"
 
 # Run phpstan in individual package directories which support them
-find . -name phpstan.neon.dist -depth 2 | while IFS= read -r FILE; do
+find . -mindepth 2 -maxdepth 2 -name phpstan.neon.dist | while IFS= read -r FILE; do
   DIR="$(dirname "$FILE")"
   echo "Running phpstan in $DIR"
-  dev/vendor/bin/phpstan analyze -c $DIR/phpstan.neon.dist $DIR/src/
+  dev/vendor/bin/phpstan analyze -c "$DIR/phpstan.neon.dist" "$DIR/src/"
 done
-