You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
10 KiB
PHP
245 lines
10 KiB
PHP
<?php
|
|
|
|
// Exercise the reply transaction without booting the application or reading a
|
|
// live configuration. SQLite cannot prove InnoDB lock blocking, but it does
|
|
// verify that the root/reply/attachment rows and newly-created files share the
|
|
// same failure boundary.
|
|
require dirname(__DIR__) . '/vendor/autoload.php';
|
|
|
|
use App\Services\TicketAttachmentService;
|
|
use App\Services\Ticket\OpenTicketCommand;
|
|
use App\Services\Ticket\ReplyTicketCommand;
|
|
use App\Services\Ticket\TicketThreadService;
|
|
use Illuminate\Database\Capsule\Manager as Capsule;
|
|
use Illuminate\Database\Schema\Blueprint;
|
|
|
|
if (!defined('BASE_PATH')) {
|
|
define('BASE_PATH', sys_get_temp_dir() . '/virt-cloud-ticket-test-' . bin2hex(random_bytes(6)));
|
|
}
|
|
if (!is_dir(BASE_PATH . '/storage/ticket-attachments')
|
|
&& !mkdir(BASE_PATH . '/storage/ticket-attachments', 0700, true)
|
|
&& !is_dir(BASE_PATH . '/storage/ticket-attachments')) {
|
|
throw new RuntimeException('Could not create ticket attachment test directory.');
|
|
}
|
|
|
|
$assert = static function ($condition, string $message): void {
|
|
if (!$condition) {
|
|
throw new RuntimeException($message);
|
|
}
|
|
};
|
|
|
|
$capsule = new Capsule();
|
|
$capsule->addConnection(['driver' => 'sqlite', 'database' => ':memory:'], 'default');
|
|
$capsule->setAsGlobal();
|
|
$capsule->bootEloquent();
|
|
$schema = $capsule->getConnection('default')->getSchemaBuilder();
|
|
$schema->create('ticket', static function (Blueprint $table): void {
|
|
$table->increments('id');
|
|
$table->text('title');
|
|
$table->text('content');
|
|
$table->integer('rootid')->default(0);
|
|
$table->integer('userid');
|
|
$table->integer('datetime');
|
|
$table->integer('status')->default(1);
|
|
$table->string('ticket_type')->default('technical');
|
|
$table->string('priority')->default('medium');
|
|
$table->integer('instance_id')->nullable();
|
|
});
|
|
$schema->create('ticket_attachments', static function (Blueprint $table): void {
|
|
$table->increments('id');
|
|
$table->integer('ticket_id');
|
|
$table->integer('message_id');
|
|
$table->integer('user_id');
|
|
$table->string('storage_key');
|
|
$table->string('original_name');
|
|
$table->string('mime_type');
|
|
$table->integer('bytes');
|
|
$table->string('sha256');
|
|
$table->integer('created_at');
|
|
});
|
|
$schema->create('ticket_write_requests', static function (Blueprint $table): void {
|
|
$table->increments('id');
|
|
$table->integer('actor_user_id');
|
|
$table->string('request_key');
|
|
$table->string('request_hash');
|
|
$table->string('operation');
|
|
$table->integer('ticket_id')->nullable();
|
|
$table->integer('message_id')->nullable();
|
|
$table->integer('created_at');
|
|
$table->unique(['actor_user_id', 'request_key']);
|
|
});
|
|
$schema->create('ticket_user_guards', static function (Blueprint $table): void {
|
|
$table->integer('user_id')->primary();
|
|
$table->integer('updated_at');
|
|
});
|
|
$schema->create('cloud_instances', static function (Blueprint $table): void {
|
|
$table->increments('id');
|
|
$table->integer('user_id');
|
|
$table->string('status');
|
|
});
|
|
|
|
$service = new TicketThreadService();
|
|
|
|
Capsule::table('ticket')->insert([
|
|
'id' => 1,
|
|
'title' => 'Root ticket',
|
|
'content' => 'Initial message',
|
|
'rootid' => 0,
|
|
'userid' => 7,
|
|
'datetime' => time(),
|
|
'status' => 1,
|
|
'ticket_type' => 'technical',
|
|
'priority' => 'medium',
|
|
]);
|
|
|
|
$png = base64_decode(
|
|
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk'
|
|
. 'YAAAAAYAAjCB0C8AAAAASUVORK5CYII=',
|
|
true
|
|
);
|
|
$uploaded = static function (string $name, string $bytes): array {
|
|
$path = tempnam(sys_get_temp_dir(), 'ticket-upload-');
|
|
if ($path === false || file_put_contents($path, $bytes) === false) {
|
|
throw new RuntimeException('Could not create uploaded fixture.');
|
|
}
|
|
return [
|
|
'name' => $name,
|
|
'tmp_name' => $path,
|
|
'error' => UPLOAD_ERR_OK,
|
|
'size' => filesize($path),
|
|
'type' => 'image/png',
|
|
];
|
|
};
|
|
$request = static function (array $files): object {
|
|
return new class($files) {
|
|
public function __construct(private array $files) {}
|
|
public function getUploadedFiles(): array { return ['attachments' => $this->files]; }
|
|
};
|
|
};
|
|
|
|
// A user may only mutate a thread that they own. The missing result is the
|
|
// public behavior used by the HTTP adapter to return "ticket not found"
|
|
// without revealing another user's ticket.
|
|
$foreignResult = $service->reply(new ReplyTicketCommand(
|
|
1, 8, 'must not be saved', 0, $request([]), 8, false, 'foreign-reply-1234'
|
|
));
|
|
$assert($foreignResult === null, 'A foreign user was able to reply to the ticket.');
|
|
$assert(Capsule::table('ticket')->where('rootid', 1)->count() === 0,
|
|
'The rejected foreign reply wrote a message row.');
|
|
|
|
// A later invalid attachment must roll back the root status and reply and
|
|
// remove the first file that was already moved into private storage.
|
|
$first = $uploaded('first.png', $png);
|
|
$secondPath = tempnam(sys_get_temp_dir(), 'ticket-upload-invalid-');
|
|
if ($secondPath === false || file_put_contents($secondPath, 'not an image') === false) {
|
|
throw new RuntimeException('Could not create invalid upload fixture.');
|
|
}
|
|
$second = [
|
|
'name' => 'second.png', 'tmp_name' => $secondPath, 'error' => UPLOAD_ERR_OK,
|
|
'size' => filesize($secondPath), 'type' => 'image/png',
|
|
];
|
|
try {
|
|
$service->reply(new ReplyTicketCommand(
|
|
1, 7, 'reply that must roll back', 0, $request([$first, $second]), 7,
|
|
false, 'rollback-reply-1234'
|
|
));
|
|
throw new RuntimeException('Invalid attachment unexpectedly succeeded.');
|
|
} catch (InvalidArgumentException $exception) {
|
|
// Expected validation failure; the assertions below verify the rollback.
|
|
}
|
|
$assert((int) Capsule::table('ticket')->where('id', 1)->value('status') === 1,
|
|
'Root status changed after attachment validation failure.');
|
|
$assert(Capsule::table('ticket')->where('rootid', 1)->count() === 0,
|
|
'Reply row survived attachment validation failure.');
|
|
$assert(Capsule::table('ticket_attachments')->count() === 0,
|
|
'Attachment row survived transaction rollback.');
|
|
$assert(glob(BASE_PATH . '/storage/ticket-attachments/*') === [],
|
|
'A partially stored attachment file survived rollback.');
|
|
@unlink($secondPath);
|
|
|
|
$result = $service->reply(new ReplyTicketCommand(
|
|
1, 7, 'successful reply', 0, $request([$uploaded('ok.png', $png)]), 7,
|
|
false, 'success-reply-1234'
|
|
));
|
|
$assert($result !== null && $result->message->rootid == 1, 'Successful reply was not created.');
|
|
$assert((int) Capsule::table('ticket')->where('id', 1)->value('status') === 0,
|
|
'Root status was not updated by a successful reply.');
|
|
$assert(Capsule::table('ticket')->where('rootid', 1)->count() === 1,
|
|
'Successful reply row is missing.');
|
|
$assert(Capsule::table('ticket_attachments')->count() === 1,
|
|
'Successful attachment row is missing.');
|
|
$attachment = Capsule::table('ticket_attachments')->first();
|
|
$assert((string) $attachment->original_name === 'ok.png',
|
|
'Successful attachment did not preserve its sanitized original name.');
|
|
$assert(is_file(BASE_PATH . '/storage/ticket-attachments/' . $attachment->storage_key),
|
|
'Successful attachment file is missing.');
|
|
|
|
// Closing and reopening are observable thread behaviors. Reopening a closed
|
|
// thread has its own event so notification adapters can explain the change.
|
|
$reopened = $service->reply(new ReplyTicketCommand(
|
|
1, 7, 'reopen', 1, $request([]), 7, false, 'reopen-reply-1234'
|
|
));
|
|
$assert($reopened !== null && $reopened->event === '工单重新开启',
|
|
'A closed ticket did not emit the reopen event.');
|
|
$assert((int) Capsule::table('ticket')->where('id', 1)->value('status') === 1,
|
|
'The reopened ticket root is not open.');
|
|
|
|
// The lock must be acquired in the transaction, not by a preflight query.
|
|
$serviceSource = file_get_contents(dirname(__DIR__) . '/app/Services/Ticket/TicketThreadService.php');
|
|
$assert(str_contains($serviceSource, 'transaction(function')
|
|
&& str_contains($serviceSource, 'lockForUpdate()->first()')
|
|
&& str_contains($serviceSource, 'TicketAttachmentService::store'),
|
|
'Reply service does not keep root locking and attachment persistence in one transaction.');
|
|
$attachmentSource = file_get_contents(dirname(__DIR__) . '/app/Services/TicketAttachmentService.php');
|
|
$assert(str_contains($attachmentSource, '$paths[] = $path')
|
|
&& str_contains($attachmentSource, 'self::discardPaths($paths)'),
|
|
'Attachment writes do not register and clean up every newly-created path.');
|
|
foreach ([
|
|
dirname(__DIR__) . '/app/Controllers/UserController.php',
|
|
dirname(__DIR__) . '/app/Controllers/Admin/TicketController.php',
|
|
] as $controllerPath) {
|
|
$controllerSource = file_get_contents($controllerPath);
|
|
$assert(str_contains($controllerSource, 'TicketThreadService')
|
|
&& !str_contains($controllerSource, '$previousStatus'),
|
|
'A ticket controller still uses the stale-status compensation flow.');
|
|
}
|
|
|
|
Capsule::table('cloud_instances')->insert(['id' => 31, 'user_id' => 7, 'status' => 'running']);
|
|
$opened = $service->open(new OpenTicketCommand(
|
|
7,
|
|
'<b>Provisioning issue</b>',
|
|
'<script>alert(1)</script>Cannot boot',
|
|
'technical',
|
|
'high',
|
|
31,
|
|
$request([]),
|
|
'open-ticket-123456'
|
|
));
|
|
$assert($opened->root->rootid == 0 && $opened->message->id === $opened->root->id,
|
|
'Opening a ticket did not create the root thread message.');
|
|
$assert((int) $opened->root->instance_id === 31,
|
|
'Opening a ticket lost the owned instance association.');
|
|
$assert(!str_contains((string) $opened->root->content, '<script>'),
|
|
'Opening a ticket did not sanitize active content.');
|
|
try {
|
|
$service->open(new OpenTicketCommand(
|
|
8, 'Foreign instance', 'Must fail', 'technical', 'medium', 31, $request([]),
|
|
'foreign-open-12345'
|
|
));
|
|
throw new RuntimeException('Foreign instance association unexpectedly succeeded.');
|
|
} catch (InvalidArgumentException $exception) {
|
|
$assert($exception->getMessage() === '关联实例不存在或无权访问',
|
|
'Foreign instance rejection returned the wrong public error.');
|
|
}
|
|
|
|
TicketAttachmentService::discardPaths([
|
|
BASE_PATH . '/storage/ticket-attachments/' . $attachment->storage_key,
|
|
]);
|
|
Capsule::table('ticket_attachments')->delete();
|
|
Capsule::table('ticket')->where('rootid', 1)->delete();
|
|
@rmdir(BASE_PATH . '/storage/ticket-attachments');
|
|
@rmdir(BASE_PATH . '/storage');
|
|
@rmdir(BASE_PATH);
|
|
|
|
echo "Ticket reply transaction and attachment cleanup checks passed.\n";
|