324 lines
27 KiB
PHP
324 lines
27 KiB
PHP
<?php
|
|
|
|
use App\Models\StockMovement;
|
|
use App\Models\SupplyRecord;
|
|
use App\Models\Tenant;
|
|
use App\Models\User;
|
|
use App\Models\Warehouse;
|
|
use App\Services\ReceiptWorkflow;
|
|
use App\Services\ReplenishmentProjection;
|
|
use App\Services\RequisitionCatalogue;
|
|
use App\Services\StockWorkflow;
|
|
use App\Services\SupplyHistory;
|
|
use App\Services\SupplyPlanning;
|
|
use Carbon\CarbonImmutable;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Str;
|
|
use Inertia\Testing\AssertableInertia as Assert;
|
|
|
|
require_once __DIR__.'/../Support/ReceiptFixture.php';
|
|
require_once __DIR__.'/../Support/SupplyFixture.php';
|
|
|
|
beforeEach(function () {
|
|
$this->travelTo(CarbonImmutable::parse('2026-09-30 12:00:00'));
|
|
$this->f = receiptFixture('1500.000');
|
|
supplyGrant($this->f['issuer'], ['procurement', 'supply_prepare', 'supply_history_prepare']);
|
|
supplyGrant($this->f['receiver'], ['warehouse', 'supply_review', 'supply_history_review', 'supply_reserve']);
|
|
$this->actingAs($this->f['receiver']);
|
|
app(ReceiptWorkflow::class)->confirm($this->f['receiver'], $this->f['order'], receiptPayload($this->f, '1200.000'));
|
|
historyIssue($this, '2026-10-10', '100.000');
|
|
historyIssue($this, '2026-10-20', '200.000');
|
|
$this->travelTo(CarbonImmutable::parse('2026-11-01 12:00:00'));
|
|
$this->actingAs($this->f['issuer']);
|
|
});
|
|
|
|
function historyIssue($test, string $date, string $quantity): object
|
|
{
|
|
$test->travelTo(CarbonImmutable::parse($date.' 12:00:00'));
|
|
$test->actingAs($test->f['receiver']);
|
|
|
|
return app(StockWorkflow::class)->record($test->f['receiver'], ['kind' => 'issue', 'reference' => 'HIST-'.Str::random(10), 'idempotency_key' => (string) Str::uuid(),
|
|
'responsible_id' => $test->f['receiver']->id, 'warehouse_id' => $test->f['warehouse']->id, 'stock_item_id' => $test->f['stock']->id, 'quantity' => $quantity, 'reason' => 'Consumo fictício para testar o período histórico.']);
|
|
}
|
|
|
|
function historyData(array $f): array
|
|
{
|
|
return ['stock_item_id' => $f['stock']->id, 'warehouse_id' => $f['warehouse']->id, 'purpose' => 'internal', 'period_from' => '2026-10-01', 'period_until' => '2026-10-30', 'quality' => 'complete', 'pattern' => 'regular'];
|
|
}
|
|
|
|
function approvedHistory($test, array $extra = []): SupplyRecord
|
|
{
|
|
$test->actingAs($test->f['issuer'])->postJson('/compras/fornecimento/history', supplyInput([...historyData($test->f), ...$extra]))->assertRedirect();
|
|
$draft = app(SupplyPlanning::class)->latest('history')->sole();
|
|
$test->actingAs($test->f['receiver'])->postJson('/compras/fornecimento/history', supplyInput(['confirm_scope' => true], 'approve', $draft))->assertRedirect();
|
|
|
|
return app(SupplyPlanning::class)->latest('history')->sole();
|
|
}
|
|
|
|
function historyPolicy($test, SupplyRecord $history, array $extra = []): SupplyRecord
|
|
{
|
|
$data = [...supplyPolicy($test->f), 'purpose' => 'internal', 'safety_milli' => 600000, 'minimum_stock_milli' => 600000, 'target_milli' => 900000, 'maximum_milli' => 1200000,
|
|
'forecast_method' => 'historical', 'history_key' => $history->record_key, 'history_min_days' => 30, 'history_max_age_days' => 90, 'daily_milli' => 999999, ...$extra];
|
|
$test->actingAs($test->f['issuer'])->postJson('/compras/fornecimento/policy', supplyInput($data))->assertRedirect();
|
|
$draft = app(SupplyPlanning::class)->latest('policy')->sole();
|
|
$test->actingAs($test->f['receiver'])->postJson('/compras/fornecimento/policy', supplyInput([], 'approve', $draft))->assertRedirect();
|
|
|
|
return app(SupplyPlanning::class)->latest('policy')->sole();
|
|
}
|
|
|
|
test('history source search finds an older approved period before the recent choice limit', function () {
|
|
$old = approvedHistory($this);
|
|
$this->actingAs($this->f['issuer']);
|
|
$draft = app(SupplyHistory::class)->save($this->f['issuer'], supplyInput([...historyData($this->f), 'period_from' => '2026-09-01', 'period_until' => '2026-09-30']));
|
|
$this->actingAs($this->f['receiver']);
|
|
$recent = app(SupplyHistory::class)->save($this->f['receiver'], supplyInput(['confirm_scope' => true], 'approve', $draft));
|
|
for ($i = 0; $i < 99; $i++) {
|
|
$copy = $recent->replicate();
|
|
$copy->record_key = (string) Str::uuid();
|
|
$copy->operation_key = (string) Str::uuid();
|
|
$copy->created_at = $recent->created_at;
|
|
$copy->save();
|
|
}
|
|
$query = '/compras/fornecimento?view=calendar&history_stock_item_id='.$this->f['stock']->id.'&history_warehouse_id='.$this->f['warehouse']->id.'&history_purpose=internal';
|
|
$before = [$old->fresh()->getAttributes(), DB::table('audit_logs')->count(), DB::table('stock_movements')->count()];
|
|
$this->actingAs($this->f['issuer'])->get('/compras/fornecimento?view=calendar')->assertInertia(fn (Assert $p) => $p->has('histories', 100)->where('histories', fn ($rows) => collect($rows)->where('key', $old->record_key)->isEmpty()));
|
|
$this->get($query.'&history_period_from=2026-10-01&history_period_until=2026-10-30')->assertInertia(fn (Assert $p) => $p->has('histories', 1)->where('histories.0.key', $old->record_key));
|
|
$this->get($query.'&history_period_until=2026-09-30&selected_history_key='.$old->record_key)->assertInertia(fn (Assert $p) => $p->has('histories', 101));
|
|
$this->get(str_replace('history_purpose=internal', 'history_purpose=resale', $query).'&selected_history_key='.$old->record_key)->assertInertia(fn (Assert $p) => $p->has('histories', 0));
|
|
expect([$old->fresh()->getAttributes(), DB::table('audit_logs')->count(), DB::table('stock_movements')->count()])->toBe($before);
|
|
$this->actingAs($this->f['receiver']);
|
|
app(SupplyHistory::class)->save($this->f['receiver'], supplyInput([], 'suspend', $old));
|
|
$this->actingAs($this->f['issuer'])->get($query.'&history_period_from=2026-10-01&selected_history_key='.$old->record_key)->assertInertia(fn (Assert $p) => $p->has('histories', 0));
|
|
});
|
|
|
|
test('history source search validates scope dates and preparation rights', function () {
|
|
$old = approvedHistory($this);
|
|
$query = '/compras/fornecimento?view=calendar&history_stock_item_id='.$this->f['stock']->id.'&history_warehouse_id='.$this->f['warehouse']->id.'&history_purpose=internal';
|
|
$this->actingAs($this->f['issuer'])->getJson($query.'&history_period_from=2026-10-30&history_period_until=2026-10-01')->assertUnprocessable();
|
|
$this->getJson('/compras/fornecimento?view=calendar&history_period_from=2026-10-01')->assertUnprocessable();
|
|
$tenant = Tenant::query()->create(['name' => 'Histórico isolado']);
|
|
$foreign = User::factory()->create(['tenant_id' => $tenant->id]);
|
|
supplyGrant($foreign, ['supply_prepare']);
|
|
$this->actingAs($foreign)->getJson($query.'&selected_history_key='.$old->record_key)->assertUnprocessable();
|
|
$this->actingAs($this->f['receiver'])->get($query)->assertInertia(fn (Assert $p) => $p->where('canPrepare', false)->has('histories', 0));
|
|
});
|
|
|
|
test('supply pagination preserves an approved historical source already selected outside the recent choices', function () {
|
|
$history = approvedHistory($this);
|
|
$policy = historyPolicy($this, $history);
|
|
for ($i = 0; $i < 100; $i++) {
|
|
$copy = $history->replicate();
|
|
$copy->record_key = (string) Str::uuid();
|
|
$copy->operation_key = (string) Str::uuid();
|
|
$copy->created_at = $history->created_at;
|
|
$copy->save();
|
|
}
|
|
$before = [$policy->fresh()->getAttributes(), $history->fresh()->getAttributes(), DB::table('audit_logs')->count()];
|
|
$this->actingAs($this->f['issuer'])->get('/compras/fornecimento?view=calendar&record_id='.$policy->id)->assertInertia(fn (Assert $page) => $page
|
|
->has('histories', 101)->where('histories', fn ($rows) => collect($rows)->where('key', $history->record_key)->count() === 1)
|
|
->where('records.0.data.history_key', $history->record_key));
|
|
expect([$policy->fresh()->getAttributes(), $history->fresh()->getAttributes(), DB::table('audit_logs')->count()])->toBe($before);
|
|
$this->actingAs($this->f['receiver']);
|
|
app(SupplyHistory::class)->save($this->f['receiver'], supplyInput([], 'suspend', $history));
|
|
$this->actingAs($this->f['issuer'])->get('/compras/fornecimento?view=calendar&record_id='.$policy->id)->assertInertia(fn (Assert $page) => $page
|
|
->has('histories', 100)->where('histories', fn ($rows) => collect($rows)->where('key', $history->record_key)->isEmpty())
|
|
->where('records.0.data.history_key', $history->record_key));
|
|
expect($policy->fresh()->getAttributes())->toBe($before[0])->and($history->fresh()->getAttributes())->toBe($before[1]);
|
|
});
|
|
|
|
test('historical mean includes all calendar days and policy reuses the approved period without accepting forged totals', function () {
|
|
$history = approvedHistory($this, ['total_milli' => 999999, 'daily_mean_milli' => '999']);
|
|
expect($history->snapshot['analysis']['total_milli'])->toBe(300000)->and($history->snapshot['analysis']['days'])->toBe(30)
|
|
->and($history->snapshot['analysis']['daily_mean_milli'])->toBe('10000.000000')->and($history->snapshot['analysis']['active_days'])->toBe(2);
|
|
$policy = historyPolicy($this, $history);
|
|
expect($policy->data['daily_milli'])->toBeNull()->and($policy->data['history_version'])->toBe($history->version);
|
|
$effective = app(SupplyHistory::class)->resolve($policy);
|
|
$projection = app(ReplenishmentProjection::class)->calculate($effective['data'], 900000, today()->toDateString());
|
|
expect($projection['method'])->toBe('historical_mean_calendar_days')->and($projection['daily_milli'])->toBe('10000.000000')->and($projection['series'][0]['demand_milli'])->toBe(10000);
|
|
$this->actingAs($this->f['issuer'])->get('/compras/fornecimento?view=calendar')->assertInertia(fn (Assert $page) => $page->where('projections.'.$policy->record_key.'.forecast_history.available', true));
|
|
});
|
|
|
|
test('transfers adjustments counts and receptions affect stock but never inflate consumption', function () {
|
|
$this->travelTo(CarbonImmutable::parse('2026-10-22 12:00:00'));
|
|
$this->actingAs($this->f['receiver']);
|
|
$other = Warehouse::query()->create(['tenant_id' => $this->f['tenant']->id, 'created_by' => $this->f['receiver']->id, 'code' => 'HIST-2', 'name' => 'Outro local do ensaio']);
|
|
$base = ['responsible_id' => $this->f['receiver']->id, 'warehouse_id' => $this->f['warehouse']->id, 'stock_item_id' => $this->f['stock']->id, 'reason' => 'Operação não representa consumo na análise.'];
|
|
app(StockWorkflow::class)->record($this->f['receiver'], [...$base, 'kind' => 'transfer', 'reference' => 'HIST-TRANS', 'idempotency_key' => (string) Str::uuid(), 'destination_warehouse_id' => $other->id, 'quantity' => '10.000']);
|
|
$version = app(StockWorkflow::class)->balance($this->f['stock']->id, $this->f['warehouse']->id)['version'];
|
|
$count = app(StockWorkflow::class)->record($this->f['receiver'], [...$base, 'kind' => 'count', 'reference' => 'HIST-COUNT', 'idempotency_key' => (string) Str::uuid(), 'quantity' => '905.000', 'ledger_version' => $version]);
|
|
app(StockWorkflow::class)->record($this->f['receiver'], [...$base, 'kind' => 'adjustment', 'reference' => 'HIST-ADJUST', 'idempotency_key' => (string) Str::uuid(), 'quantity' => '905.000', 'count_id' => $count->id]);
|
|
app(ReceiptWorkflow::class)->confirm($this->f['receiver'], $this->f['order'], receiptPayload($this->f, '50.000'));
|
|
$this->travelTo(CarbonImmutable::parse('2026-11-01 12:00:00'));
|
|
$analysis = app(SupplyHistory::class)->analyse($this->f['stock']->id, $this->f['warehouse']->id, '2026-10-01', '2026-10-30');
|
|
expect($analysis['total_milli'])->toBe(300000)->and($analysis['movement_types']['issue'])->toBe(2)->and($analysis['movement_types']['transfer_out'])->toBe(1)
|
|
->and($analysis['movement_types']['adjustment'])->toBe(1)->and($analysis['movement_types']['receipt_in'])->toBe(1);
|
|
});
|
|
|
|
test('unknown history remains unavailable whereas reviewed zero consumption is a genuine zero and known needs remain', function () {
|
|
$history = approvedHistory($this, ['period_from' => '2026-10-21']);
|
|
$policy = historyPolicy($this, $history, ['history_min_days' => 10]);
|
|
$effective = app(SupplyHistory::class)->resolve($policy);
|
|
$zero = app(ReplenishmentProjection::class)->calculate($effective['data'], 900000, today()->toDateString());
|
|
$unknown = app(ReplenishmentProjection::class)->calculate([...supplyPolicy($this->f), 'daily_milli' => null], 900000, today()->toDateString());
|
|
expect($zero['available'])->toBeTrue()->and($zero['daily_milli'])->toBe('0.000000')->and($zero['quantity_milli'])->toBe(0)->and($unknown['available'])->toBeFalse();
|
|
$known = app(ReplenishmentProjection::class)->calculate($effective['data'], 900000, today()->toDateString(), [['date' => today()->addDay()->toDateString(), 'quantity' => 350000, 'additional' => true]]);
|
|
expect($known['risk_date'])->toBe(today()->addDay()->toDateString())->and($known['quantity_milli'])->toBeGreaterThan(0);
|
|
});
|
|
|
|
test('fractional milliunit average is projected cumulatively instead of becoming false zero', function () {
|
|
historyIssue($this, '2026-10-28', '0.001');
|
|
$this->travelTo(CarbonImmutable::parse('2026-11-01 12:00:00'));
|
|
$history = approvedHistory($this, ['period_from' => '2026-10-28']);
|
|
$policy = historyPolicy($this, $history, ['history_min_days' => 3]);
|
|
$data = app(SupplyHistory::class)->resolve($policy)['data'];
|
|
$projection = app(ReplenishmentProjection::class)->calculate([...$data, 'horizon_days' => 3], 900000, today()->toDateString());
|
|
expect($projection['daily_milli'])->toBe('0.333333')->and(array_sum(array_column($projection['series'], 'demand_milli')))->toBe(1);
|
|
});
|
|
|
|
test('independent confirmation is mandatory and late historical entries invalidate rather than overwrite an approved analysis', function () {
|
|
$input = supplyInput(historyData($this->f));
|
|
$this->postJson('/compras/fornecimento/history', $input)->assertRedirect();
|
|
$this->postJson('/compras/fornecimento/history', $input)->assertRedirect();
|
|
$draft = app(SupplyPlanning::class)->latest('history')->sole();
|
|
supplyGrant($this->f['issuer'], ['supply_history_review']);
|
|
$this->postJson('/compras/fornecimento/history', supplyInput(['confirm_scope' => true], 'approve', $draft))->assertUnprocessable();
|
|
$this->actingAs($this->f['receiver'])->postJson('/compras/fornecimento/history', supplyInput([], 'approve', $draft))->assertUnprocessable();
|
|
$this->postJson('/compras/fornecimento/history', supplyInput(['confirm_scope' => true], 'approve', $draft))->assertRedirect();
|
|
$approved = app(SupplyPlanning::class)->latest('history')->sole();
|
|
$policy = historyPolicy($this, $approved);
|
|
historyIssue($this, '2026-10-25', '1.000');
|
|
$this->travelTo(CarbonImmutable::parse('2026-11-01 12:00:00'));
|
|
$result = app(SupplyHistory::class)->resolve($policy);
|
|
expect($result['history']['available'])->toBeFalse()->and($result['data']['daily_milli'])->toBeNull()->and($approved->fresh()->snapshot['analysis']['total_milli'])->toBe(300000);
|
|
});
|
|
|
|
test('insufficient coverage and nonregular patterns cannot silently feed a simple average', function (string $quality, string $pattern) {
|
|
$history = approvedHistory($this, ['quality' => $quality, 'pattern' => $pattern]);
|
|
$data = [...supplyPolicy($this->f), 'purpose' => 'internal', 'forecast_method' => 'historical', 'history_key' => $history->record_key, 'history_min_days' => 30, 'history_max_age_days' => 90];
|
|
$this->actingAs($this->f['issuer'])->postJson('/compras/fornecimento/policy', supplyInput($data))->assertUnprocessable();
|
|
})->with([['unknown', 'regular'], ['incomplete', 'regular'], ['stockout', 'regular'], ['complete', 'seasonal'], ['complete', 'intermittent']]);
|
|
|
|
test('minimum coverage purpose age and suspension remain explicit policy conditions', function () {
|
|
$history = approvedHistory($this);
|
|
$data = [...supplyPolicy($this->f), 'forecast_method' => 'historical', 'history_key' => $history->record_key, 'history_min_days' => 31, 'history_max_age_days' => 90];
|
|
$this->actingAs($this->f['issuer'])->postJson('/compras/fornecimento/policy', supplyInput([...$data, 'purpose' => 'internal']))->assertUnprocessable();
|
|
$this->postJson('/compras/fornecimento/policy', supplyInput([...$data, 'history_min_days' => 30]))->assertUnprocessable();
|
|
$policy = historyPolicy($this, $history);
|
|
$this->travelTo(CarbonImmutable::parse('2027-02-01 12:00:00'));
|
|
expect(app(SupplyHistory::class)->resolve($policy)['history']['available'])->toBeFalse();
|
|
$this->travelTo(CarbonImmutable::parse('2026-11-01 12:00:00'));
|
|
$this->actingAs($this->f['receiver'])->postJson('/compras/fornecimento/history', supplyInput([], 'suspend', $history))->assertRedirect();
|
|
expect(app(SupplyHistory::class)->resolve($policy)['history']['available'])->toBeFalse();
|
|
});
|
|
|
|
test('historical dates must be closed and the source ledger never crosses companies or changes through analysis', function () {
|
|
$before = StockMovement::query()->count();
|
|
$this->postJson('/compras/fornecimento/history', supplyInput([...historyData($this->f), 'period_until' => today()->toDateString()]))->assertUnprocessable();
|
|
$other = receiptFixture();
|
|
$this->actingAs($this->f['issuer'])->postJson('/compras/fornecimento/history', supplyInput([...historyData($this->f), 'stock_item_id' => $other['stock']->id]))->assertNotFound();
|
|
$this->get('/compras/fornecimento?view=history')->assertInertia(fn (Assert $page) => $page->component('supply/history')->where('canPrepare', true));
|
|
expect(StockMovement::query()->count())->toBe($before);
|
|
});
|
|
|
|
test('suggestions freeze the historical period and a suspended source cannot be used to convert an older approval', function () {
|
|
$history = approvedHistory($this);
|
|
$policy = historyPolicy($this, $history);
|
|
app(RequisitionCatalogue::class)->save($this->f['receiver'], $this->f['stock']->id, ['version' => 0, 'stock_basis' => app(RequisitionCatalogue::class)->basis($this->f['stock']),
|
|
'category' => 'Material', 'purchase_type' => 'consumable', 'published' => true, 'reason' => 'Reutilização do catálogo no percurso histórico.']);
|
|
supplyGrant($this->f['issuer'], ['supply_suggest_prepare', 'supply_suggest_convert', 'requester']);
|
|
supplyGrant($this->f['receiver'], ['supply_suggest_review']);
|
|
$this->actingAs($this->f['issuer'])->postJson('/compras/fornecimento/suggestion', supplyInput(['policy_key' => $policy->record_key, 'unit_price' => '10.00']))->assertRedirect();
|
|
$suggestion = app(SupplyPlanning::class)->latest('suggestion')->sole();
|
|
expect($suggestion->snapshot['forecast_history']['version'])->toBe($history->version)->and($suggestion->snapshot['forecast_history']['analysis']['total_milli'])->toBe(300000);
|
|
$this->actingAs($this->f['receiver'])->postJson('/compras/fornecimento/suggestion', supplyInput([], 'approve', $suggestion))->assertRedirect();
|
|
$approved = app(SupplyPlanning::class)->latest('suggestion')->sole();
|
|
$this->postJson('/compras/fornecimento/history', supplyInput([], 'suspend', $history))->assertRedirect();
|
|
$this->actingAs($this->f['issuer'])->postJson('/compras/fornecimento/suggestion', supplyInput(['cost_center_id' => $this->f['r']->cost_center_id], 'convert', $approved))->assertUnprocessable();
|
|
expect($approved->fresh()->snapshot['forecast_history']['version'])->toBe($history->version)->and($approved->fresh()->state)->toBe('approved');
|
|
});
|
|
|
|
test('replacement policy can reuse all approved parameters by reference while activation remains independent and unique', function () {
|
|
$history = approvedHistory($this);
|
|
$source = historyPolicy($this, $history);
|
|
$this->actingAs($this->f['issuer'])->postJson('/compras/fornecimento/policy', supplyInput(['predecessor_key' => $source->record_key, 'predecessor_version' => $source->version]))->assertRedirect();
|
|
$copy = app(SupplyPlanning::class)->latest('policy')->where('record_key', '!=', $source->record_key)->sole();
|
|
expect($copy->data['target_milli'])->toBe($source->data['target_milli'])->and($copy->data['history_key'])->toBe($history->record_key)->and($copy->data['predecessor_version'])->toBe($source->version);
|
|
$this->actingAs($this->f['receiver'])->postJson('/compras/fornecimento/policy', supplyInput([], 'approve', $copy))->assertUnprocessable();
|
|
$this->postJson('/compras/fornecimento/policy', supplyInput([], 'suspend', $source))->assertRedirect();
|
|
$this->postJson('/compras/fornecimento/policy', supplyInput([], 'approve', $copy))->assertRedirect();
|
|
expect(app(SupplyPlanning::class)->latest('policy')->where('state', 'approved')->count())->toBe(1)->and($source->fresh()->data['target_milli'])->toBe(900000);
|
|
});
|
|
test('history task routes the prepared analysis to an independent reviewer without changing scope or ledger', function () {
|
|
$draft = app(SupplyHistory::class)->save($this->f['issuer'], supplyInput(historyData($this->f)));
|
|
supplyGrant($this->f['issuer'], ['supply_history_review']);
|
|
$path = '/compras/fornecimento?view=history&record_id='.$draft->id;
|
|
$this->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 0));
|
|
$this->get($path)->assertInertia(fn (Assert $page) => $page->where('records.0.canApprove', false));
|
|
$this->actingAs($this->f['receiver'])->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 1)
|
|
->where('tasks.data.0.href', $path.'#supply-record-'.$draft->id)->where('tasks.data.0.due_on', null)->missing('tasks.data.0.snapshot'));
|
|
$before = [SupplyRecord::query()->count(), StockMovement::query()->count(), DB::table('audit_logs')->count()];
|
|
$this->get($path)->assertHeader('Cache-Control', 'max-age=0, no-store, private')->assertInertia(fn (Assert $page) => $page->has('records', 1)
|
|
->where('focusRecordId', $draft->id)->where('focusChanged', false)->where('records.0.canApprove', true)->where('records.0.canReturn', true));
|
|
expect([SupplyRecord::query()->count(), StockMovement::query()->count(), DB::table('audit_logs')->count()])->toBe($before);
|
|
$this->postJson('/compras/fornecimento/history', supplyInput(['confirm_scope' => false], 'approve', $draft))->assertUnprocessable();
|
|
$approved = app(SupplyHistory::class)->save($this->f['receiver'], supplyInput(['confirm_scope' => true], 'approve', $draft));
|
|
$this->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 0));
|
|
$this->get($path)->assertInertia(fn (Assert $page) => $page->where('focusChanged', true)->where('records.0.id', $approved->id)
|
|
->where('records.0.canApprove', false)->where('records.0.canSuspend', true));
|
|
});
|
|
|
|
test('history task excludes every previous preparer and uses the specific historical competence', function () {
|
|
$draft = app(SupplyHistory::class)->save($this->f['issuer'], supplyInput(historyData($this->f)));
|
|
supplyGrant($this->f['receiver'], ['supply_history_prepare']);
|
|
$this->actingAs($this->f['receiver']);
|
|
$updated = app(SupplyHistory::class)->save($this->f['receiver'], supplyInput(historyData($this->f), 'save', $draft));
|
|
supplyGrant($this->f['issuer'], ['supply_history_review']);
|
|
foreach ([$this->f['issuer'], $this->f['receiver']] as $user) {
|
|
$this->actingAs($user)->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 0));
|
|
expect(app(SupplyHistory::class)->canReview($user, $updated))->toBeFalse();
|
|
}
|
|
supplyGrant($this->f['otherReceiver'], ['supply_review']);
|
|
$this->actingAs($this->f['otherReceiver'])->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 0));
|
|
$this->get('/compras/fornecimento?view=history')->assertForbidden();
|
|
supplyGrant($this->f['otherReceiver'], ['supply_history_review']);
|
|
$this->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 1)->where('tasks.data.0.task', 'history_review'));
|
|
expect(app(SupplyHistory::class)->canReview($this->f['otherReceiver'], $draft))->toBeFalse()
|
|
->and(app(SupplyHistory::class)->canReview($this->f['otherReceiver'], $updated))->toBeTrue();
|
|
});
|
|
|
|
test('history task keeps changed sources available for return and never approves stale analysis silently', function () {
|
|
$draft = app(SupplyHistory::class)->save($this->f['issuer'], supplyInput(historyData($this->f)));
|
|
$this->f['stock']->update(['name' => 'Nome alterado depois da análise']);
|
|
$this->actingAs($this->f['receiver'])->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 1));
|
|
$this->postJson('/compras/fornecimento/history', supplyInput(['confirm_scope' => true], 'approve', $draft))->assertUnprocessable();
|
|
$returned = app(SupplyHistory::class)->save($this->f['receiver'], supplyInput([], 'return', $draft));
|
|
expect($returned->state)->toBe('returned')->and($returned->snapshot['item'])->toBe($draft->snapshot['item']);
|
|
});
|
|
|
|
test('history task preserves old pending analyses beyond the display cap and all task pages', function () {
|
|
$first = app(SupplyHistory::class)->save($this->f['issuer'], supplyInput(historyData($this->f)));
|
|
for ($index = 1; $index < 105; $index++) {
|
|
app(SupplyHistory::class)->save($this->f['issuer'], supplyInput(historyData($this->f)));
|
|
}
|
|
$this->actingAs($this->f['receiver'])->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 105)->has('tasks.data', 25)->where('tasks.data.0.id', 'supply:'.$first->id.':review'));
|
|
$this->get('/requisicoes/tarefas?module=supply&page=5')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 105)->has('tasks.data', 5));
|
|
$this->get('/compras/fornecimento?view=history')->assertInertia(fn (Assert $page) => $page->has('records', 25)->where('recordPagination.total', 105));
|
|
$this->get('/compras/fornecimento?view=history&record_id='.$first->id)->assertInertia(fn (Assert $page) => $page->has('records', 1)->where('records.0.id', $first->id));
|
|
});
|
|
|
|
test('history task preserves company isolation document type maintenance and grant expiry', function () {
|
|
$draft = app(SupplyHistory::class)->save($this->f['issuer'], supplyInput(historyData($this->f)));
|
|
$path = '/compras/fornecimento?view=history&record_id='.$draft->id;
|
|
$tenant = Tenant::query()->create(['name' => 'Outra empresa de ensaio']);
|
|
$foreign = User::factory()->create(['tenant_id' => $tenant->id]);
|
|
supplyGrant($foreign, ['supply_history_review']);
|
|
$this->actingAs($foreign)->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 0));
|
|
$this->getJson($path)->assertUnprocessable();
|
|
$this->actingAs($this->f['receiver'])->getJson('/compras/fornecimento?view=calendar&record_id='.$draft->id)->assertUnprocessable();
|
|
DB::table('organization_memberships')->where('user_id', $this->f['receiver']->id)->update(['maintenance' => true, 'expires_at' => now()->addHour()]);
|
|
$this->get('/requisicoes/tarefas?module=supply')->assertInertia(fn (Assert $page) => $page->where('tasks.total', 0));
|
|
$this->get($path)->assertForbidden();
|
|
DB::table('organization_memberships')->where('user_id', $this->f['receiver']->id)->update(['expires_at' => now()->subMinute()]);
|
|
$this->get('/requisicoes/tarefas?module=supply')->assertForbidden();
|
|
});
|