<?php

use App\Actions\ApplyPlanChange;
use App\Actions\BookAddon;
use App\Livewire\Billing;
use App\Livewire\ConfirmBookStorage;
use App\Models\Host;
use App\Models\Instance;
use App\Models\InstanceMetric;
use App\Models\Order;
use App\Models\ProvisioningRun;
use App\Models\SubscriptionAddon;
use App\Models\User;
use App\Provisioning\Steps\Customer\ApplyStorageQuota;
use App\Provisioning\Steps\Customer\GrowGuestFilesystem;
use App\Provisioning\Steps\Customer\ResizeVirtualMachine;
use App\Services\Billing\AddonCatalogue;
use App\Services\Billing\DowngradeCheck;
use App\Services\Billing\PlanCatalogue;
use App\Services\Billing\StorageAllowance;
use App\Services\Proxmox\ProxmoxClient;
use App\Support\ProvisioningSettings;
use Illuminate\Support\Facades\Queue;
use Livewire\Livewire;

/**
 * Extra storage, from the purchase to the byte.
 *
 * A booked pack was a row in `subscription_addons` and nothing else: charged
 * every month, and delivered nowhere. Nextcloud's quota came from the package
 * alone, the disk was sized for the package alone, and on the rare occasion a
 * disk did grow — a plan upgrade — the guest never saw it, because nothing
 * stretched the partition or the filesystem over the new space.
 *
 * These prove the whole chain: the allowance is one figure everything reads, the
 * machine really gets the space, the guest really sees it, and a customer whose
 * downgrade is blocked by their own data is offered a way out that works.
 */

/** A customer on a package, with a machine that is built, running and served. */
function storageFixture(string $plan = 'team', array $instanceAttributes = []): array
{
    // Sized well above anything this file books: since Task 3, BookAddon asks
    // the host before it books, and `active()`'s default 1000 GB is too small
    // for the grandfathered Enterprise machine some of these tests stand up —
    // placeableIn() would never have put one there.
    $host = Host::factory()->active()->create(['datacenter' => 'fsn', 'node' => 'pve', 'total_gb' => 2000]);
    $order = Order::factory()->withSubscription()->create(['datacenter' => 'fsn', 'plan' => $plan]);
    $subscription = $order->subscription;
    $customer = $order->customer;
    $user = User::factory()->create(['email' => $customer->email]);

    $instance = Instance::factory()->create(array_merge([
        'order_id' => $order->id,
        'customer_id' => $customer->id,
        'host_id' => $host->id,
        'vmid' => 101,
        'subdomain' => 'berger',
        'plan' => $plan,
        'quota_gb' => $subscription->quota_gb,
        'disk_gb' => $subscription->disk_gb,
        'ram_mb' => $subscription->ram_mb,
        'cores' => $subscription->cores,
        'status' => 'active',
        'route_written' => true,
        'routed_hostnames' => ['berger.'.ProvisioningSettings::dnsZone()],
        'cert_ok' => true,
    ], $instanceAttributes));

    $subscription->update(['instance_id' => $instance->id]);

    // Some of these tests book storage packs through Billing::purchase(),
    // which since Task 5 refuses outright without a Stripe key for the
    // active mode.
    withStripeSecret();

    return [
        'host' => $host,
        'order' => $order,
        'customer' => $customer,
        'user' => $user,
        'subscription' => $subscription->fresh(),
        'instance' => $instance,
    ];
}

/** A run of the storage pipeline against that machine, ready for a step. */
function storageRun(array $fixture): ProvisioningRun
{
    return ProvisioningRun::factory()->create([
        'subject_type' => Order::class,
        'subject_id' => $fixture['order']->id,
        'pipeline' => 'storage',
        'context' => [
            'instance_id' => $fixture['instance']->id,
            'host_id' => $fixture['host']->id,
            'node' => 'pve',
            'vmid' => 101,
            'subdomain' => $fixture['instance']->subdomain,
        ],
    ]);
}

/** What a guest answers when it is asked about its data filesystem. */
function scriptGuestFilesystem($pve, string $source = '/dev/sda1', string $type = 'ext4', string $target = '/'): void
{
    $pve->guestScript('findmnt', 0, "{$source} {$type} {$target}");
}

beforeEach(function () {
    fakeServices();
    // The delivery run is created and left for a worker: these tests are about
    // what the steps do when they run, not about the queue.
    Queue::fake();
});

// ─── A. one authority for the allowance ──────────────────────────────────────

it('raises the allowance with a booked pack and tells Nextcloud the larger figure', function () {
    $fixture = storageFixture('team'); // 85 GB package
    $pve = app(ProxmoxClient::class);

    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);

    // 85 + 20 (ein Block, Task 5).
    expect(StorageAllowance::for($fixture['instance']->fresh())->totalGb())->toBe(105);

    expect(app(ApplyStorageQuota::class)->execute(storageRun($fixture))->type)->toBe('advance');

    expect($pve->guestRan("files default_quota --value='105 GB'"))->toBeTrue()
        // Recorded as applied, so the sweep can tell an enforced machine from
        // one where the figure has only ever been a row in our database.
        ->and($fixture['instance']->fresh()->quota_applied_gb)->toBe(105)
        ->and($fixture['instance']->fresh()->quotaIsEnforced())->toBeTrue();
});

it('stacks two packs and lowers the allowance again when one is cancelled', function () {
    $fixture = storageFixture('team');
    $contract = $fixture['subscription'];

    $first = app(BookAddon::class)($contract, AddonCatalogue::STORAGE);
    app(BookAddon::class)($contract, AddonCatalogue::STORAGE);

    // 85 + 2 × 20 (Task 5).
    expect(StorageAllowance::for($fixture['instance']->fresh())->totalGb())->toBe(125);

    app(BookAddon::class)->cancel($first);

    expect(StorageAllowance::for($fixture['instance']->fresh())->totalGb())->toBe(105)
        // Cancelled, never deleted: what somebody was paying, and until when, is
        // evidence.
        ->and(SubscriptionAddon::query()->count())->toBe(2);
});

it('counts a pack booked with a quantity of more than one', function () {
    $fixture = storageFixture('team');

    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE, 3);

    // 85 + 3 × 20 (Task 5).
    expect(StorageAllowance::for($fixture['instance']->fresh())->totalGb())->toBe(145);
});

it('shows the whole allowance in the portal, not the package alone', function () {
    $fixture = storageFixture('team');
    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE, 2);

    Livewire::actingAs($fixture['user'])
        ->test(Billing::class)
        // 85 + 2 × 20.
        ->assertSee('125 GB')
        ->assertSee(__('billing.storage_includes_packs', ['count' => 2, 'gb' => 40]));
});

it('starts one delivery run when a pack is booked, and none while another is in flight', function () {
    $fixture = storageFixture('team');

    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);

    expect(ProvisioningRun::query()->where('pipeline', 'storage')->count())->toBe(1);

    // A second booking arrives while the first run is still pending. That run
    // reads the allowance when it reaches the quota step, which is this state or
    // newer — a second run beside it would resize the same disk twice.
    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);

    expect(ProvisioningRun::query()->where('pipeline', 'storage')->count())->toBe(1);
});

it('starts a delivery run when a pack is cancelled, so the quota comes back down', function () {
    $fixture = storageFixture('team');
    $addon = app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);

    ProvisioningRun::query()->update(['status' => ProvisioningRun::STATUS_COMPLETED]);

    app(BookAddon::class)->cancel($addon);

    expect(ProvisioningRun::query()->where('pipeline', 'storage')->count())->toBe(2);
});

// ─── B. the machine really gets the space ────────────────────────────────────

it('grows the disk to the allowance plus the package overhead, and the guest with it', function () {
    // Team is 85 GB sold on a 100 GB disk: 15 GB of overhead the package was
    // sized with, and the pack (Task 5: 22 GB on disk) comes ON TOP of it.
    $fixture = storageFixture('team');
    $pve = app(ProxmoxClient::class);
    scriptGuestFilesystem($pve);

    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);
    $run = storageRun($fixture);

    expect(app(ResizeVirtualMachine::class)->execute($run)->type)->toBe('advance')
        ->and($pve->resizeCalls)->toContain('101:scsi0:122G')
        ->and($fixture['instance']->fresh()->disk_gb)->toBe(122);

    expect(app(GrowGuestFilesystem::class)->execute($run)->type)->toBe('advance')
        ->and($pve->guestRan('/sys/class/block/sda/device/rescan'))->toBeTrue()
        ->and($pve->guestRan("growpart '/dev/sda' '1'"))->toBeTrue()
        ->and($pve->guestRan("resize2fs '/dev/sda1'"))->toBeTrue();
});

it('does nothing the second time round', function () {
    $fixture = storageFixture('team');
    $pve = app(ProxmoxClient::class);
    scriptGuestFilesystem($pve);

    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);
    $run = storageRun($fixture);

    app(ResizeVirtualMachine::class)->execute($run);
    app(GrowGuestFilesystem::class)->execute($run);

    // Everything is already the right size. growpart answers the way it answers
    // when the partition already fills the disk: a non-zero exit with NOCHANGE
    // on its output, which is not a failure and must not be read as one.
    $pve->resizeCalls = [];
    $pve->guestCommands = [];
    $pve->guestScript('growpart', 1, 'NOCHANGE: partition 1 is size 1342177280. it cannot be grown');

    expect(app(ResizeVirtualMachine::class)->execute($run->fresh())->type)->toBe('advance')
        ->and($pve->resizeCalls)->toBe([])
        ->and($fixture['instance']->fresh()->disk_gb)->toBe(122);

    expect(app(GrowGuestFilesystem::class)->execute($run->fresh())->type)->toBe('advance');
});

it('grows an xfs filesystem with its own tool, pointed at the mount point', function () {
    $fixture = storageFixture('team');
    $pve = app(ProxmoxClient::class);
    scriptGuestFilesystem($pve, '/dev/sda2', 'xfs', '/');

    expect(app(GrowGuestFilesystem::class)->execute(storageRun($fixture))->type)->toBe('advance')
        ->and($pve->guestRan("growpart '/dev/sda' '2'"))->toBeTrue()
        // The mount point, not the device: that is what xfs_growfs takes.
        ->and($pve->guestRan("xfs_growfs '/'"))->toBeTrue()
        ->and($pve->guestRan('resize2fs'))->toBeFalse();
});

it('fails loudly on a filesystem it does not know how to grow', function () {
    $fixture = storageFixture('team');
    $pve = app(ProxmoxClient::class);
    scriptGuestFilesystem($pve, '/dev/sda1', 'reiserfs', '/');

    $result = app(GrowGuestFilesystem::class)->execute(storageRun($fixture));

    // A failed run somebody can read, never a silent advance: a customer who has
    // paid for space that never appeared must not depend on anyone noticing.
    expect($result->type)->toBe('fail')
        ->and($result->reason)->toContain('reiserfs')
        ->and($pve->guestRan('resize2fs'))->toBeFalse()
        ->and($pve->guestRan('xfs_growfs'))->toBeFalse();
});

it('waits for a guest that is not answering rather than pretending it grew', function () {
    $fixture = storageFixture('team');
    $pve = app(ProxmoxClient::class);
    $pve->guestAgentUp = false;

    $result = app(GrowGuestFilesystem::class)->execute(storageRun($fixture));

    expect($result->type)->toBe('retry')
        ->and($pve->guestCommands)->toBe([]);
});

// ─── C. a blocked downgrade with a way out ───────────────────────────────────

/** A reading of what is actually stored, dated. */
function storedBytes(Instance $instance, int $gib, ?string $day = null): InstanceMetric
{
    return InstanceMetric::query()->updateOrCreate(
        ['instance_id' => $instance->id, 'day' => $day ?? now()->toDateString()],
        // Der Datenträger, den die Maschine wirklich hat — eine Messung kommt
        // von dort und nicht von einer festen Zahl, die mit jeder Paketleiter
        // wieder falsch wird.
        ['disk_used_bytes' => $gib * 1024 ** 3, 'disk_total_bytes' => $instance->disk_gb * 1024 ** 3],
    );
}

it('still blocks a downgrade the stored data does not fit, and says what would fix it', function () {
    $fixture = storageFixture('business'); // 175 GB package
    // Fünfzig Gigabyte zu viel: drei Blöcke à 20 GB decken sie, und das ist
    // genau der Deckel — der letzte Betrag, für den Kaufen überhaupt noch ein
    // Ausweg ist. 135 gegen Teams 85 ist derselbe Abstand, den vorher 550 gegen
    // 500 hatte; nur die Leiter darunter ist eine andere geworden.
    storedBytes($fixture['instance'], 135);

    $team = app(PlanCatalogue::class)->sellable()['team']; // 85 GB
    $check = DowngradeCheck::for($fixture['customer'], $fixture['instance'], $team, 'team');

    expect($check->allowed)->toBeFalse()
        ->and(collect($check->blockers)->pluck('key')->all())->toBe(['storage'])
        ->and($check->storageRemedy)->not->toBeNull()
        ->and($check->storageRemedy['limit'])->toBe('85 GB')
        ->and($check->storageRemedy['packs'])->toBe(3)
        ->and($check->storageRemedy['pack_gb'])->toBe(20)
        // Gedeckt, also kein Restbetrag — und damit der Satz, der zum Knopf
        // gehört, und nicht der, der ihn ersetzt.
        ->and($check->storageRemedy['short'])->toBeNull();
});

it('lets exactly that downgrade through once the offered packs are booked', function () {
    $fixture = storageFixture('business');
    // Vierzig Gigabyte über Teams 85 sind zwei Blöcke — innerhalb des Deckels
    // (Task 2: höchstens drei), und genug, um denselben Ablauf zu belegen.
    storedBytes($fixture['instance'], 125);

    $team = app(PlanCatalogue::class)->sellable()['team'];
    $packs = DowngradeCheck::for($fixture['customer'], $fixture['instance'], $team, 'team')->storageRemedy['packs'];

    expect($packs)->toBe(2);

    foreach (range(1, $packs) as $ignored) {
        app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);
    }

    $after = DowngradeCheck::for($fixture['customer'], $fixture['instance']->fresh(), $team, 'team');

    expect($after->allowed)->toBeTrue()
        ->and($after->blockers)->toBe([]);
});

/**
 * Der Ausweg muss auch kaufmännisch gehbar sein, nicht nur rechnerisch.
 *
 * `packsToCover()` rechnet, und die Rechnung kennt keinen Deckel: achtzig
 * Gigabyte zu viel sind vier Blöcke, und höchstens drei sind buchbar. Die
 * Karte bot „4 × Zusatzspeicher buchen“ an, das Modal klemmte still auf drei,
 * BookAddon hätte den vierten ohnehin abgelehnt — und der Kunde stand nach 45 €
 * im Monat genau dort, wo er vorher stand. Solange ein Block 100 GB brachte,
 * war das unerreichbar; seit Task 5 sind es 20, und jede Überschreitung über
 * 60 GB landet hier.
 */
it('verspricht keine Blöcke, die dieser Vertrag gar nicht buchen könnte', function () {
    $fixture = storageFixture('business');
    storedBytes($fixture['instance'], 165); // 80 GB zu viel für Teams 85 = vier Blöcke

    $team = app(PlanCatalogue::class)->sellable()['team'];
    $check = DowngradeCheck::for($fixture['customer'], $fixture['instance'], $team, 'team');

    expect($check->allowed)->toBeFalse()
        // Kein Angebot statt eines unerfüllbaren: die Karte hängt ihren Knopf
        // an diese Zahl.
        ->and($check->storageRemedy['packs'])->toBe(0)
        // Und was nach allen drei buchbaren Blöcken übrig bliebe, in Ziffern —
        // 20 GiB, nicht die vollen 80, die ohne Blöcke wegmüssten.
        ->and($check->storageRemedy['short'])->toBe('21,5 GB')
        ->and($check->storageRemedy['over'])->toBe('85,9 GB');
});

/**
 * Der Beleg, dass das alte Versprechen wirklich keines war: Kunde folgt dem
 * Rat, kauft das Höchstmaß — und der Wechsel bleibt gesperrt.
 */
it('bleibt gesperrt, auch wenn der Kunde das Höchstmaß an Blöcken bucht', function () {
    $fixture = storageFixture('business');
    storedBytes($fixture['instance'], 165);

    foreach (range(1, 3) as $ignored) {
        app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE);
    }

    // Der vierte, dem die alte Empfehlung entsprochen hätte, geht nicht.
    expect(fn () => app(BookAddon::class)($fixture['subscription']->refresh(), AddonCatalogue::STORAGE))
        ->toThrow(RuntimeException::class);

    $team = app(PlanCatalogue::class)->sellable()['team'];
    $after = DowngradeCheck::for($fixture['customer'], $fixture['instance']->fresh(), $team, 'team');

    expect($after->allowed)->toBeFalse()
        ->and($after->storageRemedy['packs'])->toBe(0)
        ->and($after->storageRemedy['short'])->toBe('21,5 GB');
});

/** Dieselbe Grenze in der Ansicht: kein Knopf, und der Satz sagt warum. */
it('bietet auf der Karte keinen Kauf an, den der Vertrag nicht abschließen kann', function () {
    $fixture = storageFixture('business');
    storedBytes($fixture['instance'], 165);

    Livewire::actingAs($fixture['user'])
        ->test(Billing::class)
        ->assertDontSee('confirm-book-storage')
        ->assertSee(__('billing.downgrade_escape.capped', [
            'used' => '177 GB',
            'limit' => '85 GB',
            'over' => '85,9 GB',
            'short' => '21,5 GB',
        ]))
        // Der andere Ausweg bleibt: löschen und neu messen.
        ->assertSee(__('billing.downgrade_escape.remeasure'));
});

/**
 * Der zweite Grund, aus dem BookAddon ablehnt, und derselbe Fehler wäre er
 * gewesen: Enterprise wird gar kein Zusatzspeicher verkauft. Der Deckel allein
 * hätte hier „3“ geantwortet und die Karte hätte Blöcke angeboten, die es für
 * dieses Paket nicht gibt.
 */
it('bietet einem Enterprise-Vertrag keine Blöcke an, den es dort nicht gibt', function () {
    // Enterprise wird seit der neuen Leiter angefragt statt gekauft; der
    // Vertrag, um den es hier geht, ist einer aus der Zeit davor.
    $fixture = asGrandfathered('enterprise', fn () => storageFixture('enterprise'));
    storedBytes($fixture['instance'], 375); // 200 GB zu viel für Business' 175

    $business = app(PlanCatalogue::class)->sellable()['business'];
    $check = DowngradeCheck::for($fixture['customer'], $fixture['instance'], $business, 'business');

    expect($check->allowed)->toBeFalse()
        ->and($check->storageRemedy['packs'])->toBe(0)
        // Nichts buchbar, also bleibt der volle Betrag stehen — der Satz nennt
        // dieselbe Zahl zweimal, und das ist die ehrliche Auskunft.
        ->and($check->storageRemedy['short'])->toBe('215 GB')
        ->and($check->storageRemedy['over'])->toBe('215 GB');
});

/**
 * Warum das Klemmen in ConfirmBookStorage (`max(1, min(…))`, das bei nichts
 * mehr Buchbarem auf einen Block hochzieht) bewusst stehen bleibt: der Weg
 * dahinter ist ohnehin zu. Ein Modal ist per `openModal` direkt erreichbar,
 * also wird das nicht angenommen, sondern belegt — beide Gründe, aus denen
 * BookAddon ablehnt, halten schon in `purchase()`, bevor eine Bestellzeile
 * entsteht.
 */
it('legt über den Bestätigungsweg keine Bestellzeile an, wenn nichts buchbar ist', function () {
    $amDeckel = storageFixture('business');
    app(BookAddon::class)($amDeckel['subscription'], AddonCatalogue::STORAGE, 3);

    // Eigene Adresse: `storageFixture()` vergibt sonst zweimal dieselbe, und
    // `instances.subdomain` ist eindeutig.
    $enterprise = asGrandfathered('enterprise', fn () => storageFixture('enterprise', ['subdomain' => 'huber']));

    withStripeSecret();

    foreach ([$amDeckel, $enterprise] as $fixture) {
        expect(app(AddonCatalogue::class)->bookableQuantity($fixture['subscription']->refresh(), AddonCatalogue::STORAGE))->toBe(0);

        Livewire::actingAs($fixture['user'])
            ->test(Billing::class)
            // Genau das, was ein direkt geöffnetes Modal auslöst.
            ->call('bookStoragePacks', 1);

        expect(Order::query()->where('customer_id', $fixture['customer']->id)->where('type', 'storage')->count())->toBe(0);
    }
});

it('offers the packs through a modal, and books exactly the number that was offered', function () {
    $fixture = storageFixture('business');
    // Sechzig Gigabyte über Teams 85, also genau drei Blöcke — der letzte
    // Betrag, für den die Karte überhaupt noch einen Knopf anbietet.
    storedBytes($fixture['instance'], 145);

    Livewire::actingAs($fixture['user'])
        ->test(Billing::class)
        ->assertSee(__('billing.downgrade_escape.remeasure'))
        // R23: the confirmation is this product's own dialog, never the
        // browser's — the card only opens it.
        ->assertSee('confirm-book-storage')
        ->call('bookStoragePacks', 3);

    expect(Order::query()->where('customer_id', $fixture['customer']->id)->where('type', 'storage')->count())->toBe(3);
});

it('confirms the packs in this product own dialog and raises the event with the number', function () {
    Livewire::test(ConfirmBookStorage::class, ['packs' => 3])
        ->assertSee(__('billing.storage_confirm_title', ['count' => 3]))
        ->call('proceed')
        ->assertDispatched('storage-packs-confirmed', packs: 3);
});

it('refuses to put more packs in the cart than the ceiling allows', function () {
    $fixture = storageFixture('team');

    Livewire::actingAs($fixture['user'])
        ->test(Billing::class)
        ->call('bookStoragePacks', 9999);

    // Die kaufmännische Grenze (drei Blöcke, Task 2) ist inzwischen die
    // engere Klemme — vor ihr war MAX_STORAGE_PACKS die einzige, und dieser
    // Test schrieb deren Zahl fest. Der Deckel ändert sich nicht dafür, dass
    // dieser Test vor ihm entstand.
    expect(Order::query()->where('customer_id', $fixture['customer']->id)->where('type', 'storage')->count())->toBe(3);
});

it('passes the check on a fresh reading after data was deleted, without waiting for the night', function () {
    $fixture = storageFixture('business');
    $pve = app(ProxmoxClient::class);

    // Last night's reading: 165 GB stored, which does not fit Team's 85.
    storedBytes($fixture['instance'], 165, now()->subDay()->toDateString());

    $team = app(PlanCatalogue::class)->sellable()['team'];
    expect(DowngradeCheck::for($fixture['customer'], $fixture['instance'], $team, 'team')->allowed)->toBeFalse();

    // The customer deletes over 100 GB and asks us to look now.
    $pve->guestScript('df -B1', 0, "size used\n".(200 * 1024 ** 3).' '.(60 * 1024 ** 3));

    Livewire::actingAs($fixture['user'])
        ->test(Billing::class)
        ->call('remeasureStorage')
        ->assertDispatched('notify', message: __('billing.storage_remeasured'));

    expect(DowngradeCheck::for($fixture['customer'], $fixture['instance']->fresh(), $team, 'team')->allowed)->toBeTrue();
});

it('says it could not look rather than reporting an unreachable cloud as empty', function () {
    $fixture = storageFixture('business');
    $pve = app(ProxmoxClient::class);
    storedBytes($fixture['instance'], 165, now()->subDay()->toDateString());
    $pve->guestAgentUp = false;

    Livewire::actingAs($fixture['user'])
        ->test(Billing::class)
        ->call('remeasureStorage')
        ->assertDispatched('notify', message: __('billing.storage_remeasure_unavailable'));

    $team = app(PlanCatalogue::class)->sellable()['team'];
    expect(DowngradeCheck::for($fixture['customer'], $fixture['instance']->fresh(), $team, 'team')->allowed)->toBeFalse();
});

// ─── the packs survive a change of package ───────────────────────────────────

it('keeps booked packs through a plan change and delivers them on the new package', function () {
    $fixture = storageFixture('team');
    $pve = app(ProxmoxClient::class);
    scriptGuestFilesystem($pve);

    app(BookAddon::class)($fixture['subscription'], AddonCatalogue::STORAGE, 2);

    // The packs were paid for separately and have nothing to do with which
    // package the customer is on, so nothing cancels them.
    app(ApplyPlanChange::class)($fixture['subscription']->fresh(), 'business');

    $instance = $fixture['instance']->fresh();

    expect(SubscriptionAddon::query()->where('addon_key', AddonCatalogue::STORAGE)->active()->sum('quantity'))->toBe(2)
        // Business is 175 GB; the two packs (Task 5: 20 GB each) are still
        // theirs on top of it.
        ->and(StorageAllowance::for($instance)->totalGb())->toBe(215);

    $run = ProvisioningRun::query()->where('pipeline', 'plan-change')->latest('id')->firstOrFail();

    app(ResizeVirtualMachine::class)->execute($run);
    app(GrowGuestFilesystem::class)->execute($run->fresh());
    app(ApplyStorageQuota::class)->execute($run->fresh());

    // 215 GB for the customer, on Business's own 25 GB of overhead (175 sold on
    // a 200 GB disk) plus the two packs' own 22 GB disk headroom each (44 GB).
    expect($pve->resizeCalls)->toContain('101:scsi0:244G')
        ->and($pve->guestRan("files default_quota --value='215 GB'"))->toBeTrue()
        ->and($instance->fresh()->quota_applied_gb)->toBe(215);
});