@fleetbase/fleetops-engine 0.6.58 → 0.6.60

package/server/tests/Unit/Support/Metrics/CountMetricsTest.php

@@ -0,0 +1,280 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Metrics\DriversOnlineMetric;
+use Fleetbase\FleetOps\Support\Metrics\OpenIssuesMetric;
+use Fleetbase\FleetOps\Support\Metrics\OrdersCanceledMetric;
+use Fleetbase\FleetOps\Support\Metrics\OrdersCompletedMetric;
+use Fleetbase\FleetOps\Support\Metrics\OrdersInProgressMetric;
+use Fleetbase\FleetOps\Support\Metrics\ResolvedIssuesMetric;
+use Fleetbase\FleetOps\Support\Metrics\TotalCustomersMetric;
+use Fleetbase\FleetOps\Support\Metrics\TotalDistanceTraveledMetric;
+use Fleetbase\FleetOps\Support\Metrics\TotalDriversMetric;
+use Fleetbase\FleetOps\Support\Metrics\TotalTimeTraveledMetric;
+use Fleetbase\Models\Company;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+class FleetOpsCountMetricsDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+function fleetopsCountMetricsUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table orders (uuid varchar(64), company_uuid varchar(64), status varchar(64), distance numeric null, time integer null, created_at datetime null, deleted_at datetime null)');
+    $connection->statement('create table issues (uuid varchar(64), company_uuid varchar(64), status varchar(64), resolved_at datetime null, created_at datetime null, deleted_at datetime null)');
+    $connection->statement('create table contacts (uuid varchar(64), company_uuid varchar(64), type varchar(64), created_at datetime null, deleted_at datetime null)');
+    $connection->statement('create table drivers (uuid varchar(64), company_uuid varchar(64), user_uuid varchar(64), online integer, current_job_uuid varchar(64) null, created_at datetime null, deleted_at datetime null)');
+    $connection->statement('create table users (uuid varchar(64), type varchar(64) null, deleted_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsCountMetricsDatabaseProbe($connection));
+
+    return $connection;
+}
+
+function fleetopsCountMetricsCompany(): Company
+{
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-count-metrics'], true);
+
+    return $company;
+}
+
+test('order count metrics filter company status and reporting period', function () {
+    $connection = fleetopsCountMetricsUseInMemoryConnection();
+    $connection->table('orders')->insert([
+        [
+            'uuid'         => 'completed-in-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'completed',
+            'distance'     => 1250.5,
+            'time'         => 12,
+            'created_at'   => '2026-07-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'completed-outside-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'completed',
+            'distance'     => 10000,
+            'time'         => 90,
+            'created_at'   => '2026-06-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'canceled-in-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'canceled',
+            'distance'     => 4000,
+            'time'         => 30,
+            'created_at'   => '2026-07-11 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'assigned-in-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'assigned',
+            'distance'     => 2200,
+            'time'         => 18,
+            'created_at'   => '2026-07-12 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'driver-enroute-in-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'driver_enroute',
+            'distance'     => 1800,
+            'time'         => 15,
+            'created_at'   => '2026-07-13 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'created-ignored',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'created',
+            'distance'     => 600,
+            'time'         => 9,
+            'created_at'   => '2026-07-14 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'other-company',
+            'company_uuid' => 'other-company',
+            'status'       => 'completed',
+            'distance'     => 5000,
+            'time'         => 45,
+            'created_at'   => '2026-07-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+    ]);
+
+    $company = fleetopsCountMetricsCompany();
+    $start   = new DateTimeImmutable('2026-07-01 00:00:00');
+    $end     = new DateTimeImmutable('2026-07-31 23:59:59');
+
+    expect(OrdersCompletedMetric::slug())->toBe('orders_completed')
+        ->and(OrdersCompletedMetric::forCompany($company)->between($start, $end)->format())->toBe('count')
+        ->and(OrdersCompletedMetric::forCompany($company)->between($start, $end)->value())->toBe(1)
+        ->and(OrdersCanceledMetric::slug())->toBe('orders_canceled')
+        ->and(OrdersCanceledMetric::forCompany($company)->between($start, $end)->value())->toBe(1)
+        ->and(OrdersInProgressMetric::slug())->toBe('orders_in_progress')
+        ->and(OrdersInProgressMetric::forCompany($company)->between($start, $end)->value())->toBe(2)
+        ->and(TotalDistanceTraveledMetric::slug())->toBe('total_distance_traveled')
+        ->and(TotalDistanceTraveledMetric::forCompany($company)->between($start, $end)->format())->toBe('meters')
+        ->and(TotalDistanceTraveledMetric::forCompany($company)->between($start, $end)->value())->toBe(1250.5)
+        ->and(TotalTimeTraveledMetric::slug())->toBe('total_time_traveled')
+        ->and(TotalTimeTraveledMetric::forCompany($company)->between($start, $end)->format())->toBe('duration')
+        ->and(TotalTimeTraveledMetric::forCompany($company)->between($start, $end)->value())->toBe(720);
+});
+
+test('issue count metrics distinguish open and resolved issue periods', function () {
+    $connection = fleetopsCountMetricsUseInMemoryConnection();
+    $connection->table('issues')->insert([
+        [
+            'uuid'         => 'pending-in-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'pending',
+            'resolved_at'  => null,
+            'created_at'   => '2026-07-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'pending-outside-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'pending',
+            'resolved_at'  => null,
+            'created_at'   => '2026-06-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'resolved-in-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'resolved',
+            'resolved_at'  => '2026-07-12 10:00:00',
+            'created_at'   => '2026-06-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'resolved-outside-period',
+            'company_uuid' => 'company-count-metrics',
+            'status'       => 'resolved',
+            'resolved_at'  => '2026-06-12 10:00:00',
+            'created_at'   => '2026-06-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'other-company',
+            'company_uuid' => 'other-company',
+            'status'       => 'pending',
+            'resolved_at'  => null,
+            'created_at'   => '2026-07-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+    ]);
+
+    $company = fleetopsCountMetricsCompany();
+    $start   = new DateTimeImmutable('2026-07-01 00:00:00');
+    $end     = new DateTimeImmutable('2026-07-31 23:59:59');
+
+    expect(OpenIssuesMetric::slug())->toBe('open_issues')
+        ->and(OpenIssuesMetric::forCompany($company)->between($start, $end)->format())->toBe('count')
+        ->and(OpenIssuesMetric::forCompany($company)->between($start, $end)->value())->toBe(1)
+        ->and(ResolvedIssuesMetric::slug())->toBe('resolved_issues')
+        ->and(ResolvedIssuesMetric::forCompany($company)->between($start, $end)->value())->toBe(1);
+});
+
+test('driver and customer count metrics use company membership and online state', function () {
+    $connection = fleetopsCountMetricsUseInMemoryConnection();
+    $connection->table('contacts')->insert([
+        [
+            'uuid'         => 'customer-one',
+            'company_uuid' => 'company-count-metrics',
+            'type'         => 'customer',
+            'created_at'   => '2026-07-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'vendor-ignored',
+            'company_uuid' => 'company-count-metrics',
+            'type'         => 'vendor',
+            'created_at'   => '2026-07-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'other-customer',
+            'company_uuid' => 'other-company',
+            'type'         => 'customer',
+            'created_at'   => '2026-07-10 10:00:00',
+            'deleted_at'   => null,
+        ],
+    ]);
+    $connection->table('drivers')->insert([
+        [
+            'uuid'             => 'online-working-driver',
+            'company_uuid'     => 'company-count-metrics',
+            'user_uuid'        => 'user-online-working',
+            'online'           => 1,
+            'current_job_uuid' => 'job-uuid',
+            'created_at'       => '2026-07-10 10:00:00',
+            'deleted_at'       => null,
+        ],
+        [
+            'uuid'             => 'online-idle-driver',
+            'company_uuid'     => 'company-count-metrics',
+            'user_uuid'        => 'user-online-idle',
+            'online'           => 1,
+            'current_job_uuid' => null,
+            'created_at'       => '2026-07-10 10:00:00',
+            'deleted_at'       => null,
+        ],
+        [
+            'uuid'             => 'offline-working-driver',
+            'company_uuid'     => 'company-count-metrics',
+            'user_uuid'        => 'user-offline-working',
+            'online'           => 0,
+            'current_job_uuid' => 'job-uuid',
+            'created_at'       => '2026-07-10 10:00:00',
+            'deleted_at'       => null,
+        ],
+        [
+            'uuid'             => 'other-driver',
+            'company_uuid'     => 'other-company',
+            'user_uuid'        => 'user-other',
+            'online'           => 1,
+            'current_job_uuid' => 'job-uuid',
+            'created_at'       => '2026-07-10 10:00:00',
+            'deleted_at'       => null,
+        ],
+    ]);
+    $connection->table('users')->insert([
+        ['uuid' => 'user-online-working', 'type' => 'driver', 'deleted_at' => null],
+        ['uuid' => 'user-online-idle', 'type' => 'driver', 'deleted_at' => null],
+        ['uuid' => 'user-offline-working', 'type' => 'driver', 'deleted_at' => null],
+        ['uuid' => 'user-other', 'type' => 'driver', 'deleted_at' => null],
+    ]);
+
+    $company = fleetopsCountMetricsCompany();
+
+    expect(TotalCustomersMetric::slug())->toBe('total_customers')
+        ->and(TotalCustomersMetric::forCompany($company)->format())->toBe('count')
+        ->and(TotalCustomersMetric::forCompany($company)->value())->toBe(1)
+        ->and(TotalDriversMetric::slug())->toBe('total_drivers')
+        ->and(TotalDriversMetric::forCompany($company)->value())->toBe(3)
+        ->and(DriversOnlineMetric::slug())->toBe('drivers_online')
+        ->and(DriversOnlineMetric::forCompany($company)->value())->toBe(1);
+});

package/server/tests/Unit/Support/Metrics/FuelCostsMetricTest.php

@@ -0,0 +1,102 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Metrics\FuelCostsMetric;
+use Fleetbase\Models\Company;
+
+class FleetOpsFuelCostsMetricQueryFake
+{
+    public array $wheres        = [];
+    public array $whereBetweens = [];
+    public float $sum           = 0;
+
+    public function where(string $column, mixed $value): self
+    {
+        $this->wheres[] = [$column, $value];
+
+        return $this;
+    }
+
+    public function whereBetween(string $column, array $range): self
+    {
+        $this->whereBetweens[] = [$column, $range];
+
+        return $this;
+    }
+
+    public function sum(string $column): float
+    {
+        expect($column)->toBe('amount');
+
+        return $this->sum;
+    }
+}
+
+class FleetOpsFuelCostsMetricProbe extends FuelCostsMetric
+{
+    public FleetOpsFuelCostsMetricQueryFake $query;
+    public array $companyLookups = [];
+
+    public function __construct()
+    {
+        $this->query = new FleetOpsFuelCostsMetricQueryFake();
+    }
+
+    public function queryForTest(?DateTimeInterface $start, ?DateTimeInterface $end): FleetOpsFuelCostsMetricQueryFake
+    {
+        return $this->query($start, $end);
+    }
+
+    public function aggregateForTest(FleetOpsFuelCostsMetricQueryFake $query): float
+    {
+        return $this->aggregate($query);
+    }
+
+    protected function fuelReportQuery(string $companyUuid): FleetOpsFuelCostsMetricQueryFake
+    {
+        $this->companyLookups[] = $companyUuid;
+
+        return $this->query;
+    }
+}
+
+test('fuel costs metric builds company currency and date range query', function () {
+    $company = new Company();
+    $company->setRawAttributes([
+        'uuid'     => 'company-uuid',
+        'currency' => 'SGD',
+    ], true);
+
+    $metric = FleetOpsFuelCostsMetricProbe::forCompany($company);
+    $start  = new DateTimeImmutable('2026-08-01 00:00:00');
+    $end    = new DateTimeImmutable('2026-08-31 23:59:59');
+
+    $query = $metric->queryForTest($start, $end);
+
+    expect($query)->toBe($metric->query)
+        ->and($metric->companyLookups)->toBe(['company-uuid'])
+        ->and($query->wheres)->toBe([
+            ['currency', 'SGD'],
+        ])
+        ->and($query->whereBetweens)->toBe([
+            ['created_at', [$start, $end]],
+        ]);
+});
+
+test('fuel costs metric skips date filter without complete range and sums amount', function () {
+    $company = new Company();
+    $company->setRawAttributes([
+        'uuid'     => 'company-uuid',
+        'currency' => 'USD',
+    ], true);
+
+    $metric             = FleetOpsFuelCostsMetricProbe::forCompany($company);
+    $metric->query->sum = 88.45;
+
+    $query = $metric->queryForTest(new DateTimeImmutable('2026-08-01'), null);
+
+    expect($query->wheres)->toBe([
+        ['currency', 'USD'],
+    ])
+        ->and($query->whereBetweens)->toBe([])
+        ->and($metric->aggregateForTest($query))->toBe(88.45);
+});

package/server/tests/Unit/Support/Metrics/MetricQuerySeamsTest.php

@@ -0,0 +1,129 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Metrics\ActiveLiveOrdersMetric;
+use Fleetbase\FleetOps\Support\Metrics\FuelCostsMetric;
+use Fleetbase\Models\Company;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+
+/**
+ * Covers the real query seams on the metrics. The behaviour tests override
+ * these one-line builders with recorders to keep their fixtures small, which
+ * leaves the actual query construction unexercised.
+ */
+function fleetopsMetricSeamBoot(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new class($connection) {
+        public function __construct(public SQLiteConnection $c)
+        {
+        }
+
+        public function connection($name = null): SQLiteConnection
+        {
+            return $this->c;
+        }
+
+        public function __call($method, $arguments)
+        {
+            return $this->c->{$method}(...$arguments);
+        }
+    });
+    app()->instance('db.schema', $connection->getSchemaBuilder());
+    Illuminate\Support\Facades\DB::clearResolvedInstance('db');
+    Illuminate\Support\Facades\Schema::clearResolvedInstance('db.schema');
+
+    // core-api registers this builder macro through its service provider, which
+    // does not boot in the harness. The permission directives themselves are
+    // core-api's concern; what matters here is that the metric's query reaches
+    // it with the live-order scoping already applied.
+    if (!Builder::hasGlobalMacro('applyDirectivesForPermissions')) {
+        Builder::macro('applyDirectivesForPermissions', function (string $permission) {
+            return $this;
+        });
+    }
+
+    return $connection;
+}
+
+function fleetopsMetricSeamCompany(): Company
+{
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-metric-seam', 'currency' => 'SGD'], true);
+
+    return $company;
+}
+
+function fleetopsMetricSeamInvoke(object $metric, string $method, array $arguments = []): mixed
+{
+    $reflection = new ReflectionMethod($metric, $method);
+    $reflection->setAccessible(true);
+
+    return $reflection->invoke($metric, ...$arguments);
+}
+
+test('the legacy bulk api resolves and values every registered metric', function () {
+    $connection = fleetopsMetricSeamBoot();
+    session(['company' => 'company-metric-seam']);
+
+    $schema  = $connection->getSchemaBuilder();
+    $columns = [
+        'uuid', 'public_id', 'company_uuid', 'user_uuid', 'driver_assigned_uuid', 'vehicle_assigned_uuid',
+        'customer_uuid', 'customer_type', 'payload_uuid', 'tracking_number_uuid', 'order_uuid',
+        'service_quote_uuid', 'transaction_uuid', 'status', 'type', 'currency', 'amount', 'distance',
+        'time', 'email', 'phone', 'name', 'resolved_at', 'scheduled_at', '_key',
+        // Revenue scoping walks transactions back to their subject/context order
+        'subject_uuid', 'subject_type', 'context_uuid', 'context_type',
+        'parent_transaction_uuid', 'direction', 'voided_at', 'reversed_at',
+        // Live-order scoping walks orders -> payload -> waypoints/pickup/dropoff
+        'place_uuid', 'pickup_uuid', 'dropoff_uuid', 'return_uuid',
+    ];
+    foreach ([
+        'orders', 'transactions', 'fuel_reports', 'issues', 'drivers', 'contacts', 'users',
+        'purchase_rates', 'payloads', 'waypoints', 'tracking_numbers', 'tracking_statuses',
+        'companies', 'company_users', 'places',
+    ] as $table) {
+        $schema->create($table, function ($blueprint) use ($columns) {
+            $blueprint->increments('id');
+            foreach ($columns as $column) {
+                $blueprint->string($column)->nullable();
+            }
+            $blueprint->timestamps();
+            $blueprint->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    // No argument means "every registered metric", which is the arm that reads
+    // the slug list off the registry instead of normalizing a caller's list.
+    $metrics = Fleetbase\FleetOps\Support\Metrics::forCompany(fleetopsMetricSeamCompany())->with()->get();
+
+    expect(array_keys($metrics))->toBe(Fleetbase\FleetOps\Support\Metrics\Registry::slugs())
+        ->and($metrics)->each->toBeNumeric();
+});
+
+test('fuel costs metric scopes its report query to the company', function () {
+    fleetopsMetricSeamBoot();
+
+    $metric = FuelCostsMetric::forCompany(fleetopsMetricSeamCompany());
+    $query  = fleetopsMetricSeamInvoke($metric, 'fuelReportQuery', ['company-metric-seam']);
+
+    expect($query)->toBeInstanceOf(Builder::class)
+        ->and($query->toSql())->toContain('"company_uuid" = ?')
+        ->and($query->getBindings())->toBe(['company-metric-seam']);
+});
+
+test('active live orders metric builds the live order query for its company', function () {
+    fleetopsMetricSeamBoot();
+    session(['company' => 'company-metric-seam']);
+
+    $metric = ActiveLiveOrdersMetric::forCompany(fleetopsMetricSeamCompany());
+    $query  = fleetopsMetricSeamInvoke($metric, 'query', [null, null]);
+
+    expect($query)->toBeInstanceOf(Builder::class)
+        ->and($query->getBindings())->toContain('company-metric-seam');
+});

package/server/tests/Unit/Support/Metrics/OrdersScheduledMetricTest.php

@@ -0,0 +1,146 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Metrics\OrdersScheduledMetric;
+use Fleetbase\Models\Company;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model as EloquentModel;
+use Illuminate\Database\SQLiteConnection;
+use Illuminate\Support\Carbon;
+
+class FleetOpsOrdersScheduledMetricProbe extends OrdersScheduledMetric
+{
+    public function queryForTest(?DateTimeInterface $start, ?DateTimeInterface $end): Builder
+    {
+        return $this->query($start, $end);
+    }
+
+    public function aggregateForTest($query): int
+    {
+        return $this->aggregate($query);
+    }
+}
+
+class FleetOpsOrdersScheduledMetricDatabaseProbe
+{
+    public function __construct(private SQLiteConnection $connection)
+    {
+    }
+
+    public function connection(): SQLiteConnection
+    {
+        return $this->connection;
+    }
+}
+
+function fleetopsOrdersScheduledMetricUseInMemoryConnection(): SQLiteConnection
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $connection->statement('create table orders (uuid varchar(64), company_uuid varchar(64), status varchar(64), scheduled_at datetime null, created_at datetime null, deleted_at datetime null)');
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+    app()->instance('db', new FleetOpsOrdersScheduledMetricDatabaseProbe($connection));
+
+    return $connection;
+}
+
+function fleetopsOrdersScheduledMetricCompany(): Company
+{
+    $company = new Company();
+    $company->setRawAttributes(['uuid' => 'company-scheduled'], true);
+
+    return $company;
+}
+
+test('orders scheduled metric counts future created orders for the company and period', function () {
+    Carbon::setTestNow('2026-07-26 10:00:00');
+    $connection = fleetopsOrdersScheduledMetricUseInMemoryConnection();
+    $connection->table('orders')->insert([
+        [
+            'uuid'         => 'scheduled-in-period',
+            'company_uuid' => 'company-scheduled',
+            'status'       => 'created',
+            'scheduled_at' => '2026-07-27 10:00:00',
+            'created_at'   => '2026-07-20 12:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'scheduled-outside-period',
+            'company_uuid' => 'company-scheduled',
+            'status'       => 'created',
+            'scheduled_at' => '2026-07-28 10:00:00',
+            'created_at'   => '2026-06-20 12:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'past-scheduled',
+            'company_uuid' => 'company-scheduled',
+            'status'       => 'created',
+            'scheduled_at' => '2026-07-25 10:00:00',
+            'created_at'   => '2026-07-20 12:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'wrong-status',
+            'company_uuid' => 'company-scheduled',
+            'status'       => 'dispatched',
+            'scheduled_at' => '2026-07-27 10:00:00',
+            'created_at'   => '2026-07-20 12:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'wrong-company',
+            'company_uuid' => 'other-company',
+            'status'       => 'created',
+            'scheduled_at' => '2026-07-27 10:00:00',
+            'created_at'   => '2026-07-20 12:00:00',
+            'deleted_at'   => null,
+        ],
+    ]);
+
+    $metric = FleetOpsOrdersScheduledMetricProbe::forCompany(fleetopsOrdersScheduledMetricCompany());
+    $query  = $metric->queryForTest(
+        new DateTimeImmutable('2026-07-01 00:00:00'),
+        new DateTimeImmutable('2026-07-31 23:59:59')
+    );
+
+    expect(OrdersScheduledMetric::slug())->toBe('orders_scheduled')
+        ->and($metric->format())->toBe('count')
+        ->and($metric->aggregateForTest($query))->toBe(1);
+
+    Carbon::setTestNow();
+});
+
+test('orders scheduled metric skips created range without complete boundaries', function () {
+    Carbon::setTestNow('2026-07-26 10:00:00');
+    $connection = fleetopsOrdersScheduledMetricUseInMemoryConnection();
+    $connection->table('orders')->insert([
+        [
+            'uuid'         => 'scheduled-one',
+            'company_uuid' => 'company-scheduled',
+            'status'       => 'created',
+            'scheduled_at' => '2026-07-27 10:00:00',
+            'created_at'   => '2026-07-20 12:00:00',
+            'deleted_at'   => null,
+        ],
+        [
+            'uuid'         => 'scheduled-two',
+            'company_uuid' => 'company-scheduled',
+            'status'       => 'created',
+            'scheduled_at' => '2026-08-27 10:00:00',
+            'created_at'   => '2026-06-20 12:00:00',
+            'deleted_at'   => null,
+        ],
+    ]);
+
+    $metric = FleetOpsOrdersScheduledMetricProbe::forCompany(fleetopsOrdersScheduledMetricCompany());
+
+    expect($metric->aggregateForTest($metric->queryForTest(new DateTimeImmutable('2026-07-01'), null)))->toBe(2);
+
+    Carbon::setTestNow();
+});