860 lines
29 KiB
PHP
860 lines
29 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Tests\Integration\WithApp\App\Services;
|
|
|
|
use App\Attributes\Locked;
|
|
use App\Attributes\WithoutTransaction;
|
|
use App\Contracts\Action;
|
|
use App\Contracts\ActionInput;
|
|
use App\Contracts\HandlesFailure;
|
|
use App\Contracts\HandlesLockTimeout;
|
|
use App\Contracts\HandlesSuccess;
|
|
use App\Contracts\ProvidesLockKey;
|
|
use App\Models\Tag;
|
|
use App\Services\ActionExecutorService;
|
|
use Illuminate\Cache\ArrayStore;
|
|
use Illuminate\Cache\Repository;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Infrastructure\Adapters\Events\LaravelDomainEventDispatcher;
|
|
use Infrastructure\Adapters\Locks\LaravelCacheLock;
|
|
use Psr\Log\AbstractLogger;
|
|
use Psr\Log\LoggerInterface;
|
|
use Shared\Concurrency\Lock;
|
|
use Shared\Concurrency\LockTimeoutException;
|
|
use Shared\DDD\Event;
|
|
|
|
describe('ActionExecutorService', function (): void {
|
|
it('executes action in transaction and logs success', function (): void {
|
|
// GIVEN
|
|
$logger = new class () extends AbstractLogger
|
|
{
|
|
/** @var array<int, string> */
|
|
public array $logs = [];
|
|
|
|
#[\Override]
|
|
public function log($level, string | \Stringable $message, array $context = []): void
|
|
{
|
|
$this->logs[] = (string) $message;
|
|
}
|
|
};
|
|
|
|
$action = new class () implements Action
|
|
{
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
return 'done';
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$lock = new LaravelCacheLock(new Repository(new ArrayStore()));
|
|
$eventDispatcher = new LaravelDomainEventDispatcher();
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('done')
|
|
->and($logger->logs)->toHaveCount(2)
|
|
->and($logger->logs[0])->toContain('Executing')
|
|
->and($logger->logs[1])->toContain('Succeeded');
|
|
});
|
|
|
|
it('logs error and rethrows when action fails', function (): void {
|
|
// GIVEN
|
|
$logger = new class () extends AbstractLogger
|
|
{
|
|
/** @var array<int, string> */
|
|
public array $logs = [];
|
|
|
|
#[\Override]
|
|
public function log($level, string | \Stringable $message, array $context = []): void
|
|
{
|
|
$this->logs[] = (string) $message;
|
|
}
|
|
};
|
|
|
|
$action = new class () implements Action
|
|
{
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): never
|
|
{
|
|
throw new \RuntimeException('Database failure');
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$lock = new LaravelCacheLock(new Repository(new ArrayStore()));
|
|
$eventDispatcher = new LaravelDomainEventDispatcher();
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
expect(fn () => $executor->execute($action, $input))
|
|
// THEN
|
|
->toThrow(\RuntimeException::class, 'Database failure');
|
|
|
|
expect($logger->logs)->toHaveCount(2)
|
|
->and($logger->logs[0])->toContain('Executing')
|
|
->and($logger->logs[1])->toContain('Failed');
|
|
});
|
|
|
|
it('acquires lock before DB transaction starts and releases it after transaction commits', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
$store = new ArrayStore();
|
|
$innerLock = new LaravelCacheLock(new Repository($store));
|
|
$initialLevel = DB::transactionLevel();
|
|
$lvl1 = null;
|
|
$lvl2 = null;
|
|
$held2 = false;
|
|
$lvl3 = null;
|
|
$held3 = false;
|
|
$key = null;
|
|
$ttl = null;
|
|
$wait = null;
|
|
|
|
$recordingLock = new class ($innerLock, $store, $lvl1, $lvl3, $held3, $key, $ttl, $wait) implements Lock
|
|
{
|
|
public function __construct(
|
|
private readonly Lock $inner,
|
|
private readonly ArrayStore $store,
|
|
public ?int &$lvl1,
|
|
public ?int &$lvl3,
|
|
public bool &$held3,
|
|
public ?string &$key,
|
|
public ?int &$ttl,
|
|
public ?int &$wait,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function synchronize(
|
|
string $key,
|
|
callable $callback,
|
|
int $ttlSeconds = 30,
|
|
int $waitSeconds = 10,
|
|
): mixed {
|
|
$this->key = $key;
|
|
$this->ttl = $ttlSeconds;
|
|
$this->wait = $waitSeconds;
|
|
$this->lvl1 = DB::transactionLevel();
|
|
|
|
return $this->inner->synchronize(
|
|
key: $key,
|
|
callback: function () use ($callback, $key, $ttlSeconds): mixed {
|
|
$result = $callback();
|
|
|
|
$this->lvl3 = DB::transactionLevel();
|
|
$this->held3 = ! $this->store->lock($key, $ttlSeconds)->get();
|
|
|
|
return $result;
|
|
},
|
|
ttlSeconds: $ttlSeconds,
|
|
waitSeconds: $waitSeconds,
|
|
);
|
|
}
|
|
};
|
|
|
|
$action = new #[Locked(ttlSeconds: 45, waitSeconds: 7)] class ($store, $lvl2, $held2) implements Action, ProvidesLockKey
|
|
{
|
|
public function __construct(
|
|
private readonly ArrayStore $store,
|
|
public ?int &$lvl2,
|
|
public bool &$held2,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function lockKey(ActionInput $input): string
|
|
{
|
|
return 'test:lock:order';
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
$this->lvl2 = DB::transactionLevel();
|
|
$this->held2 = ! $this->store->lock('test:lock:order', 45)->get();
|
|
|
|
return 'committed';
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$eventDispatcher = new LaravelDomainEventDispatcher();
|
|
$executor = new ActionExecutorService($recordingLock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('committed')
|
|
->and($key)->toBe('test:lock:order')
|
|
->and($ttl)->toBe(45)
|
|
->and($wait)->toBe(7)
|
|
->and($lvl1)->toBe($initialLevel)
|
|
->and($lvl2)->toBe($initialLevel + 1)
|
|
->and($held2)->toBeTrue()
|
|
->and($lvl3)->toBe($initialLevel)
|
|
->and($held3)->toBeTrue()
|
|
->and($store->lock('test:lock:order', 45)->get())->toBeTrue();
|
|
});
|
|
|
|
it('uses Locked attribute key when ProvidesLockKey is not implemented', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
$lock = \Mockery::mock(Lock::class);
|
|
$lock->shouldReceive('synchronize')
|
|
->once()
|
|
->with('custom-key', \Mockery::type(\Closure::class), 30, 10)
|
|
->andReturnUsing(static fn (string $key, callable $callback): mixed => $callback());
|
|
|
|
$action = new #[Locked(key: 'custom-key')] class () implements Action
|
|
{
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
return 'custom-key-result';
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$eventDispatcher = new LaravelDomainEventDispatcher();
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('custom-key-result');
|
|
});
|
|
|
|
it('defaults lock key to action FQCN when neither Locked key nor ProvidesLockKey is provided', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
$action = new #[Locked] class () implements Action
|
|
{
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
return 'fqcn-key-result';
|
|
}
|
|
};
|
|
|
|
$lock = \Mockery::mock(Lock::class);
|
|
$lock->shouldReceive('synchronize')
|
|
->once()
|
|
->with($action::class, \Mockery::type(\Closure::class), 30, 10)
|
|
->andReturnUsing(static fn (string $key, callable $callback): mixed => $callback());
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$eventDispatcher = new LaravelDomainEventDispatcher();
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('fqcn-key-result');
|
|
});
|
|
|
|
it('returns onLockTimeout, logs warning, and skips action on LockTimeoutException when HandlesLockTimeout is implemented', function (): void {
|
|
// GIVEN
|
|
$logger = new class () extends AbstractLogger
|
|
{
|
|
/** @var array<int, array{level: mixed, message: string}> */
|
|
public array $entries = [];
|
|
|
|
#[\Override]
|
|
public function log($level, string | \Stringable $message, array $context = []): void
|
|
{
|
|
$this->entries[] = [
|
|
'level' => $level,
|
|
'message' => (string) $message,
|
|
];
|
|
}
|
|
};
|
|
|
|
$lock = \Mockery::mock(Lock::class);
|
|
$lock->shouldReceive('synchronize')
|
|
->once()
|
|
->with('test:lock:busy', \Mockery::type(\Closure::class), 30, 10)
|
|
->andThrow(new LockTimeoutException('Timed out waiting for lock'));
|
|
|
|
$invoked = false;
|
|
$action = new #[Locked(ttlSeconds: 30, waitSeconds: 10)] class ($invoked) implements Action, HandlesLockTimeout, ProvidesLockKey
|
|
{
|
|
public function __construct(
|
|
public bool &$invoked,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function lockKey(ActionInput $input): string
|
|
{
|
|
return 'test:lock:busy';
|
|
}
|
|
|
|
#[\Override]
|
|
public function onLockTimeout(ActionInput $input): string
|
|
{
|
|
return 'lock-timeout-output';
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
$this->invoked = true;
|
|
|
|
return 'should-not-run';
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$eventDispatcher = new LaravelDomainEventDispatcher();
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('lock-timeout-output')
|
|
->and($invoked)->toBeFalse()
|
|
->and($logger->entries)->toHaveCount(2)
|
|
->and($logger->entries[0]['message'])->toContain('Executing')
|
|
->and($logger->entries[1]['level'])->toBe('warning')
|
|
->and($logger->entries[1]['message'])->toContain('Lock timeout');
|
|
});
|
|
|
|
it('rethrows LockTimeoutException and logs error when HandlesLockTimeout is not implemented', function (): void {
|
|
// GIVEN
|
|
$logger = new class () extends AbstractLogger
|
|
{
|
|
/** @var array<int, array{level: mixed, message: string}> */
|
|
public array $entries = [];
|
|
|
|
#[\Override]
|
|
public function log($level, string | \Stringable $message, array $context = []): void
|
|
{
|
|
$this->entries[] = [
|
|
'level' => $level,
|
|
'message' => (string) $message,
|
|
];
|
|
}
|
|
};
|
|
|
|
$lock = \Mockery::mock(Lock::class);
|
|
$lock->shouldReceive('synchronize')
|
|
->once()
|
|
->with('test:lock:unhandled', \Mockery::type(\Closure::class), 30, 10)
|
|
->andThrow(new LockTimeoutException('Timed out waiting for lock'));
|
|
|
|
$action = new #[Locked(key: 'test:lock:unhandled')] class () implements Action
|
|
{
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
return 'should-not-run';
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$eventDispatcher = new LaravelDomainEventDispatcher();
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
expect(fn () => $executor->execute($action, $input))
|
|
// THEN
|
|
->toThrow(LockTimeoutException::class, 'Timed out waiting for lock');
|
|
|
|
expect($logger->entries)->toHaveCount(2)
|
|
->and($logger->entries[0]['level'])->toBe('info')
|
|
->and($logger->entries[0]['message'])->toContain('Executing')
|
|
->and($logger->entries[1]['level'])->toBe('error')
|
|
->and($logger->entries[1]['message'])->toContain('Failed');
|
|
});
|
|
|
|
it('flushes buffered events and calls onSucceeded only after transaction commit and lock release', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
|
|
$store = new ArrayStore();
|
|
$innerLock = new LaravelCacheLock(new Repository($store));
|
|
$sequence = [];
|
|
|
|
$recordingLock = new class ($innerLock, $sequence) implements Lock
|
|
{
|
|
/** @param list<string> $sequence */
|
|
public function __construct(
|
|
private readonly Lock $inner,
|
|
public array &$sequence,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function synchronize(
|
|
string $key,
|
|
callable $callback,
|
|
int $ttlSeconds = 30,
|
|
int $waitSeconds = 10,
|
|
): mixed {
|
|
$this->sequence[] = 'lock:acquire';
|
|
$result = $this->inner->synchronize($key, $callback, $ttlSeconds, $waitSeconds);
|
|
$this->sequence[] = 'lock:release';
|
|
|
|
return $result;
|
|
}
|
|
};
|
|
|
|
$eventDispatcher = new class ($sequence) extends LaravelDomainEventDispatcher
|
|
{
|
|
/** @param list<string> $sequence */
|
|
public function __construct(
|
|
public array &$sequence,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function beginBuffering(): void
|
|
{
|
|
$this->sequence[] = 'events:begin';
|
|
}
|
|
|
|
#[\Override]
|
|
public function dispatch(Event $event): void
|
|
{
|
|
$this->sequence[] = 'events:dispatch';
|
|
}
|
|
|
|
#[\Override]
|
|
public function flush(): void
|
|
{
|
|
$this->sequence[] = 'events:flush';
|
|
}
|
|
|
|
#[\Override]
|
|
public function discard(): void
|
|
{
|
|
$this->sequence[] = 'events:discard';
|
|
}
|
|
};
|
|
|
|
$action = new #[Locked(key: 'test:post-commit')] class ($sequence, $eventDispatcher) implements Action, HandlesSuccess
|
|
{
|
|
/** @param list<string> $sequence */
|
|
public function __construct(
|
|
public array &$sequence,
|
|
private readonly LaravelDomainEventDispatcher $eventDispatcher,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
$this->sequence[] = 'action:invoke';
|
|
$this->eventDispatcher->dispatch(new class () implements Event
|
|
{
|
|
});
|
|
|
|
return 'ok';
|
|
}
|
|
|
|
#[\Override]
|
|
public function onSuccess(ActionInput $input, mixed $result): void
|
|
{
|
|
assert(is_string($result));
|
|
$this->sequence[] = "action:onSuccess:{$result}";
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$executor = new ActionExecutorService($recordingLock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('ok')
|
|
->and($sequence)->toBe([
|
|
'lock:acquire',
|
|
'events:begin',
|
|
'action:invoke',
|
|
'events:dispatch',
|
|
'lock:release',
|
|
'events:flush',
|
|
'action:onSuccess:ok',
|
|
]);
|
|
});
|
|
|
|
it('discards buffered events and skips onSuccess when action throws', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
|
|
$lock = new LaravelCacheLock(new Repository(new ArrayStore()));
|
|
$eventDispatcher = \Mockery::mock(LaravelDomainEventDispatcher::class);
|
|
$eventDispatcher->shouldReceive('beginBuffering')->once();
|
|
$eventDispatcher->shouldReceive('discard')->once();
|
|
$eventDispatcher->shouldNotReceive('flush');
|
|
|
|
$onSuccessCalled = false;
|
|
$action = new class ($onSuccessCalled) implements Action, HandlesSuccess
|
|
{
|
|
public function __construct(
|
|
public bool &$onSuccessCalled,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): never
|
|
{
|
|
throw new \RuntimeException('Boom');
|
|
}
|
|
|
|
#[\Override]
|
|
public function onSuccess(ActionInput $input, mixed $result): void
|
|
{
|
|
$this->onSuccessCalled = true;
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
expect(fn () => $executor->execute($action, $input))
|
|
// THEN
|
|
->toThrow(\RuntimeException::class, 'Boom');
|
|
|
|
expect($onSuccessCalled)->toBeFalse();
|
|
});
|
|
|
|
it('skips flush and onSuccess when lock timeout occurs and HandlesLockTimeout handles it', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
|
|
$lock = \Mockery::mock(Lock::class);
|
|
$lock->shouldReceive('synchronize')
|
|
->once()
|
|
->andThrow(new LockTimeoutException('Busy'));
|
|
|
|
$eventDispatcher = \Mockery::mock(LaravelDomainEventDispatcher::class);
|
|
$eventDispatcher->shouldNotReceive('beginBuffering');
|
|
$eventDispatcher->shouldNotReceive('flush');
|
|
$eventDispatcher->shouldNotReceive('discard');
|
|
|
|
$onSuccessCalled = false;
|
|
$action = new #[Locked(key: 'test:timeout')] class ($onSuccessCalled) implements Action, HandlesLockTimeout, HandlesSuccess
|
|
{
|
|
public function __construct(
|
|
public bool &$onSuccessCalled,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function onLockTimeout(ActionInput $input): string
|
|
{
|
|
return 'timeout-result';
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
return 'never';
|
|
}
|
|
|
|
#[\Override]
|
|
public function onSuccess(ActionInput $input, mixed $result): void
|
|
{
|
|
$this->onSuccessCalled = true;
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('timeout-result')
|
|
->and($onSuccessCalled)->toBeFalse();
|
|
});
|
|
|
|
it('rolls back DB writes, discards events, runs onFailure, skips onSuccess, and rethrows when action fails', function (): void {
|
|
// GIVEN
|
|
$logger = new class () extends AbstractLogger
|
|
{
|
|
/** @var array<int, array{level: mixed, message: string}> */
|
|
public array $entries = [];
|
|
|
|
#[\Override]
|
|
public function log($level, string | \Stringable $message, array $context = []): void
|
|
{
|
|
$this->entries[] = [
|
|
'level' => $level,
|
|
'message' => (string) $message,
|
|
];
|
|
}
|
|
};
|
|
|
|
$lock = new LaravelCacheLock(new Repository(new ArrayStore()));
|
|
$eventDispatcher = \Mockery::mock(LaravelDomainEventDispatcher::class);
|
|
$eventDispatcher->shouldReceive('beginBuffering')->once();
|
|
$eventDispatcher->shouldReceive('discard')->once();
|
|
$eventDispatcher->shouldNotReceive('flush');
|
|
|
|
$onSuccessCalled = false;
|
|
$capturedException = null;
|
|
$action = new class ($onSuccessCalled, $capturedException) implements Action, HandlesFailure, HandlesSuccess
|
|
{
|
|
public function __construct(
|
|
public bool &$onSuccessCalled,
|
|
public ?\Throwable &$capturedException,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
Tag::query()->create([
|
|
'label' => 'Should be rolled back',
|
|
'status' => true,
|
|
]);
|
|
|
|
throw new \DomainException('Domain failure after DB write');
|
|
}
|
|
|
|
#[\Override]
|
|
public function onFailure(ActionInput $input, \Throwable $exception): void
|
|
{
|
|
$this->capturedException = $exception;
|
|
}
|
|
|
|
#[\Override]
|
|
public function onSuccess(ActionInput $input, mixed $result): void
|
|
{
|
|
$this->onSuccessCalled = true;
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
expect(fn () => $executor->execute($action, $input))
|
|
// THEN
|
|
->toThrow(\DomainException::class, 'Domain failure after DB write');
|
|
|
|
expect(Tag::query()->where('label', 'Should be rolled back')->exists())->toBeFalse()
|
|
->and($onSuccessCalled)->toBeFalse()
|
|
->and($capturedException)->toBeInstanceOf(\DomainException::class)
|
|
->and($logger->entries)->toHaveCount(2)
|
|
->and($logger->entries[1]['level'])->toBe('error');
|
|
});
|
|
|
|
it('rolls back DB writes and calls onFailure after releasing lock when Locked action implements HandlesFailure', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
|
|
$store = new ArrayStore();
|
|
$lock = new LaravelCacheLock(new Repository($store));
|
|
$eventDispatcher = \Mockery::mock(LaravelDomainEventDispatcher::class);
|
|
$eventDispatcher->shouldReceive('beginBuffering')->once();
|
|
$eventDispatcher->shouldReceive('discard')->once();
|
|
$eventDispatcher->shouldNotReceive('flush');
|
|
|
|
$ok = false;
|
|
$free = false;
|
|
$action = new #[Locked(key: 'test:locked:failure')] class ($ok, $free, $store) implements Action, HandlesFailure, HandlesSuccess
|
|
{
|
|
public function __construct(
|
|
public bool &$ok,
|
|
public bool &$free,
|
|
private readonly ArrayStore $store,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
Tag::query()->create([
|
|
'label' => 'Locked rollback test',
|
|
'status' => true,
|
|
]);
|
|
|
|
throw new \DomainException('Locked domain failure');
|
|
}
|
|
|
|
#[\Override]
|
|
public function onFailure(ActionInput $input, \Throwable $exception): void
|
|
{
|
|
$lock = $this->store->lock('test:locked:failure', 30);
|
|
$this->free = (bool) $lock->get();
|
|
|
|
if ($this->free) {
|
|
$lock->release();
|
|
}
|
|
}
|
|
|
|
#[\Override]
|
|
public function onSuccess(ActionInput $input, mixed $result): void
|
|
{
|
|
$this->ok = true;
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
expect(fn () => $executor->execute($action, $input))
|
|
// THEN
|
|
->toThrow(\DomainException::class, 'Locked domain failure');
|
|
|
|
expect(Tag::query()->where('label', 'Locked rollback test')->exists())->toBeFalse()
|
|
->and($ok)->toBeFalse()
|
|
->and($free)->toBeTrue()
|
|
->and($store->lock('test:locked:failure', 30)->get())->toBeTrue();
|
|
});
|
|
|
|
it('calls onFailure and rethrows LockTimeoutException when Locked action does not implement HandlesLockTimeout', function (): void {
|
|
// GIVEN
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
|
|
$lock = \Mockery::mock(Lock::class);
|
|
$lock->shouldReceive('synchronize')
|
|
->once()
|
|
->andThrow(new LockTimeoutException('Busy'));
|
|
|
|
$eventDispatcher = \Mockery::mock(LaravelDomainEventDispatcher::class);
|
|
$eventDispatcher->shouldNotReceive('beginBuffering');
|
|
$eventDispatcher->shouldNotReceive('flush');
|
|
$eventDispatcher->shouldNotReceive('discard');
|
|
|
|
$capturedException = null;
|
|
$action = new #[Locked(key: 'test:timeout:failure')] class ($capturedException) implements Action, HandlesFailure
|
|
{
|
|
public function __construct(
|
|
public ?\Throwable &$capturedException,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
return 'never';
|
|
}
|
|
|
|
#[\Override]
|
|
public function onFailure(ActionInput $input, \Throwable $exception): void
|
|
{
|
|
$this->capturedException = $exception;
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
|
|
// WHEN
|
|
expect(fn () => $executor->execute($action, $input))
|
|
// THEN
|
|
->toThrow(LockTimeoutException::class, 'Busy');
|
|
|
|
expect($capturedException)->toBeInstanceOf(LockTimeoutException::class);
|
|
});
|
|
|
|
it('runs WithoutTransaction action outside DB transaction and flushes events dispatched inside onSuccess', function (): void {
|
|
// GIVEN
|
|
$lock = \Mockery::mock(Lock::class);
|
|
$lock->shouldNotReceive('synchronize');
|
|
|
|
$logger = \Mockery::mock(LoggerInterface::class);
|
|
$logger->shouldIgnoreMissing();
|
|
|
|
$postHookEvent = new class () implements Event
|
|
{
|
|
};
|
|
|
|
$eventDispatcher = \Mockery::mock(LaravelDomainEventDispatcher::class);
|
|
$eventDispatcher->shouldReceive('beginBuffering')->once()->ordered();
|
|
$eventDispatcher->shouldReceive('flush')->once()->ordered();
|
|
$eventDispatcher->shouldReceive('dispatch')->once()->with($postHookEvent)->ordered();
|
|
|
|
$txLevel = null;
|
|
$action = new #[WithoutTransaction] class ($txLevel, $postHookEvent, $eventDispatcher) implements Action, HandlesSuccess
|
|
{
|
|
public function __construct(
|
|
public ?int &$txLevel,
|
|
private readonly Event $event,
|
|
private readonly LaravelDomainEventDispatcher $dispatcher,
|
|
) {
|
|
}
|
|
|
|
#[\Override]
|
|
public function __invoke(ActionInput $input): string
|
|
{
|
|
$this->txLevel = DB::transactionLevel();
|
|
|
|
return 'exported';
|
|
}
|
|
|
|
#[\Override]
|
|
public function onSuccess(ActionInput $input, mixed $result): void
|
|
{
|
|
$this->dispatcher->dispatch($this->event);
|
|
}
|
|
};
|
|
|
|
$input = new class () implements ActionInput
|
|
{
|
|
};
|
|
|
|
$executor = new ActionExecutorService($lock, $logger, $eventDispatcher);
|
|
$baseTx = DB::transactionLevel();
|
|
|
|
// WHEN
|
|
$result = $executor->execute($action, $input);
|
|
|
|
// THEN
|
|
expect($result)->toBe('exported')
|
|
->and($txLevel)->toBe($baseTx);
|
|
});
|
|
});
|