First test

Author: GromNaN

src/Bus/MongoBatchRepository.php

@@ -2,7 +2,6 @@
 
 namespace MongoDB\Laravel\Bus;
 
-use BadMethodCallException;
 use Carbon\CarbonImmutable;
 use Closure;
 use DateTimeInterface;
@@ -12,15 +11,14 @@
 use Illuminate\Bus\PendingBatch;
 use Illuminate\Bus\PrunableBatchRepository;
 use Illuminate\Bus\UpdatedBatchJobCounts;
-use Illuminate\Database\Connection;
 use Illuminate\Support\Carbon;
 use MongoDB\BSON\ObjectId;
 use MongoDB\BSON\UTCDateTime;
 use MongoDB\Driver\ReadPreference;
 use MongoDB\Laravel\Collection;
+use MongoDB\Laravel\Connection;
 use Override;
 
-use function assert;
 use function date_default_timezone_get;
 use function is_string;
 
@@ -35,7 +33,6 @@ public function __construct(
         Connection $connection,
         string $collection,
     ) {
-        assert($connection instanceof \MongoDB\Laravel\Connection);
         $this->collection = $connection->getCollection($collection);
 
         parent::__construct($factory, $connection, $collection);
@@ -65,38 +62,43 @@ public function find(string $batchId): ?Batch
 
         $batch = $this->collection->findOne(
             ['_id' => $batchId],
-            ['readPreference' => ReadPreference::PRIMARY],
+            [
+                'readPreference' => new ReadPreference(ReadPreference::PRIMARY),
+                'typeMap' => ['root' => 'array', 'array' => 'array', 'document' => 'array'],
+            ],
         );
 
         return $this->factory->make(
             $this,
-            $batch['id'],
+            $batch['_id'],
             $batch['name'],
             $batch['total_jobs'],
             $batch['pending_jobs'],
             $batch['failed_jobs'],
             $batch['failed_job_ids'],
             $batch['options'],
-            CarbonImmutable::createFromTimestamp($batch['created_at']->getTimestamp(), date_default_timezone_get()),
-            $batch['cancelled_at'] ? CarbonImmutable::createFromTimestamp($batch['cancelled_at']->getTimestamp(), date_default_timezone_get()) : null,
-            $batch['finished_at'] ? CarbonImmutable::createFromTimestamp($batch['finished_at']->getTimestamp(), date_default_timezone_get()) : null,
+            $this->toCarbon($batch['created_at']),
+            $this->toCarbon($batch['cancelled_at']),
+            $this->toCarbon($batch['finished_at']),
         );
     }
 
     #[Override]
     public function store(PendingBatch $batch): Batch
     {
-        $this->collection->insertOne([
+        $result = $this->collection->insertOne([
             'name' => $batch->name,
             'total_jobs' => 0,
             'pending_jobs' => 0,
             'failed_jobs' => 0,
-            'failed_job_ids' => '[]',
-            'options' => $this->serialize($batch->options),
+            'failed_job_ids' => [],
+            'options' => $batch->options,
             'created_at' => new UTCDateTime(Carbon::now()),
             'cancelled_at' => null,
             'finished_at' => null,
         ]);
+
+        return $this->find($result->getInsertedId());
     }
 
     #[Override]
@@ -195,19 +197,16 @@ public function delete(string $batchId): void
     #[Override]
     public function transaction(Closure $callback): mixed
     {
-        // Transactions are not necessary
-        return $callback();
+        return $this->connection->transaction(fn () => $callback());
     }
 
     /**
      * Rollback the last database transaction for the connection.
-     *
-     * Not implemented.
      */
     #[Override]
     public function rollBack(): void
     {
-        throw new BadMethodCallException('Not implemented');
+        $this->connection->rollBack();
     }
 
     /** Mark the batch that has the given ID as finished. */
@@ -259,9 +258,19 @@ protected function toBatch($batch): Batch
             $batch->failed_jobs,
             $batch->failed_job_ids,
             $batch->options,
-            CarbonImmutable::createFromTimestamp($batch->created_at->getTimestamp(), date_default_timezone_get()),
-            $batch->cancelled_at ? CarbonImmutable::createFromTimestamp($batch->cancelled_at->getTimestamp(), date_default_timezone_get()) : null,
-            $batch->finished_at ? CarbonImmutable::createFromTimestamp($batch->finished_at->getTimestamp(), date_default_timezone_get()) : null,
+            $this->toCarbon($batch->created_at),
+            $this->toCarbon($batch->cancelled_at),
+            $this->toCarbon($batch->finished_at),
         );
     }
+
+    /** @return ($date is null ? null : CarbonImmutable) */
+    private function toCarbon(?UTCDateTime $date): ?CarbonImmutable
+    {
+        if ($date === null) {
+            return null;
+        }
+
+        return CarbonImmutable::createFromTimestamp((string) $date, date_default_timezone_get());
+    }
 }

tests/Bus/MongoBatchRepositoryTest.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace MongoDB\Laravel\Tests\Bus;
+
+use Carbon\CarbonImmutable;
+use Illuminate\Bus\Batch;
+use Illuminate\Bus\Batchable;
+use Illuminate\Bus\BatchFactory;
+use Illuminate\Bus\PendingBatch;
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Queue\Factory;
+use Illuminate\Queue\CallQueuedClosure;
+use Illuminate\Queue\Queue;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Tests\Bus\BusBatchTest;
+use Mockery as m;
+use MongoDB\Laravel\Bus\MongoBatchRepository;
+use MongoDB\Laravel\Connection;
+use MongoDB\Laravel\Tests\TestCase;
+use stdClass;
+
+use function collect;
+use function is_string;
+
+final class MongoBatchRepositoryTest extends TestCase
+{
+    private Queue $queue;
+
+    /** @see BusBatchTest::test_jobs_can_be_added_to_the_batch */
+    public function testJobsCanBeAddedToTheBatch(): void
+    {
+        $queue = m::mock(Factory::class);
+
+        $batch = $this->createTestBatch($queue);
+
+        $job = new class
+        {
+            use Batchable;
+        };
+
+        $secondJob = new class
+        {
+            use Batchable;
+        };
+
+        $thirdJob = function () {
+        };
+
+        $queue->shouldReceive('connection')->once()
+            ->with('test-connection')
+            ->andReturn($connection = m::mock(stdClass::class));
+
+        $connection->shouldReceive('bulk')->once()->with(m::on(function ($args) use ($job, $secondJob) {
+            return $args[0] === $job &&
+                $args[1] === $secondJob &&
+                $args[2] instanceof CallQueuedClosure
+                && is_string($args[2]->batchId);
+        }), '', 'test-queue');
+
+        $batch = $batch->add([$job, $secondJob, $thirdJob]);
+
+        $this->assertEquals(3, $batch->totalJobs);
+        $this->assertEquals(3, $batch->pendingJobs);
+        $this->assertIsString($job->batchId);
+        $this->assertInstanceOf(CarbonImmutable::class, $batch->createdAt);
+    }
+
+    /** @see BusBatchTest::createTestBatch() */
+    private function createTestBatch($queue, $allowFailures = false)
+    {
+        $connection = DB::connection('mongodb');
+        $this->assertInstanceOf(Connection::class, $connection);
+
+        $repository = new MongoBatchRepository(new BatchFactory($queue), $connection, 'job_batches');
+
+        $pendingBatch = (new PendingBatch(new Container(), collect()))
+            ->progress(function (Batch $batch) {
+                $_SERVER['__progress.batch'] = $batch;
+                $_SERVER['__progress.count']++;
+            })
+            ->then(function (Batch $batch) {
+                $_SERVER['__then.batch'] = $batch;
+                $_SERVER['__then.count']++;
+            })
+            ->catch(function (Batch $batch, $e) {
+                $_SERVER['__catch.batch'] = $batch;
+                $_SERVER['__catch.exception'] = $e;
+                $_SERVER['__catch.count']++;
+            })
+            ->finally(function (Batch $batch) {
+                $_SERVER['__finally.batch'] = $batch;
+                $_SERVER['__finally.count']++;
+            })
+            ->allowFailures($allowFailures)
+            ->onConnection('test-connection')
+            ->onQueue('test-queue');
+
+        return $repository->store($pendingBatch);
+    }
+}