Files
predis/tests/Predis/Transaction/MultiExecStateTest.php
T
Andrei Fedoseev 1cc16c359c Discard a fluent transaction when Redis rejects a queued command (#1755)
When Redis rejected a command while queueing it (OOM, READONLY, NOPERM, MISCONF, wrong arity), MultiExec threw AbortedMultiExecException without sending DISCARD.

A transaction block discards on the way out, the fluent interface didn't, so the connection stayed in MULTI and every later command on the client returned QUEUED without running.

The fluent interface now discards the transaction, or closes the connection if DISCARD fails too.

Until discard() is called, the aborted MultiExec refuses new commands and execute(), so a caller that catches the exception can't commit only the commands queued after the failed one.

Cluster connections skip the abort path: their errors before execute()
come from the client and nothing is queued on a node yet. watch() refuses
to run on an aborted transaction and unwatch() sends nothing, so only
discard() makes it usable again. Every discard on the way out closes the
connection when DISCARD fails.
2026-11-12 11:01:48 -07:00

219 lines
5.8 KiB
PHP

<?php
/*
* This file is part of the Predis package.
*
* (c) 2009-2020 Daniele Alessandri
* (c) 2021-2026 Till Krüss
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Predis\Transaction;
use PredisTestCase;
/**
* @group realm-transaction
*/
class MultiExecStateTest extends PredisTestCase
{
/**
* @group disconnected
*/
public function testFlagsValues(): void
{
$this->assertSame(1, MultiExecState::INITIALIZED);
$this->assertSame(2, MultiExecState::INSIDEBLOCK);
$this->assertSame(4, MultiExecState::DISCARDED);
$this->assertSame(8, MultiExecState::CAS);
$this->assertSame(16, MultiExecState::WATCH);
$this->assertSame(32, MultiExecState::ABORTED);
}
/**
* @group disconnected
*/
public function testStateConstructorStartsWithResetState(): void
{
$state = new MultiExecState();
$this->assertSame(0, $state->get());
$this->assertTrue($state->isReset());
}
/**
* @group disconnected
*/
public function testCanCheckOneOrMoreStateFlags(): void
{
$flags = MultiExecState::INITIALIZED | MultiExecState::CAS;
$state = new MultiExecState();
$state->set($flags);
$this->assertSame($flags, $state->get());
$this->assertFalse($state->check(MultiExecState::INSIDEBLOCK));
$this->assertTrue($state->check(MultiExecState::INITIALIZED));
$this->assertTrue($state->check(MultiExecState::CAS));
$this->assertTrue($state->check($flags));
$this->assertFalse($state->check($flags | MultiExecState::INSIDEBLOCK));
}
/**
* @group disconnected
*/
public function testSettingAndGettingWholeFlags(): void
{
$flags = MultiExecState::INITIALIZED | MultiExecState::CAS;
$state = new MultiExecState();
$state->set($flags);
$this->assertFalse($state->check(MultiExecState::INSIDEBLOCK));
$this->assertTrue($state->check(MultiExecState::INITIALIZED));
$this->assertTrue($state->check(MultiExecState::CAS));
$this->assertSame($flags, $state->get());
}
/**
* @group disconnected
*/
public function testCanFlagSingleStates(): void
{
$flags = MultiExecState::INITIALIZED | MultiExecState::CAS;
$state = new MultiExecState();
$state->flag(MultiExecState::INITIALIZED);
$this->assertTrue($state->check(MultiExecState::INITIALIZED));
$this->assertFalse($state->check(MultiExecState::CAS));
$state->flag(MultiExecState::CAS);
$this->assertTrue($state->check(MultiExecState::INITIALIZED));
$this->assertTrue($state->check(MultiExecState::CAS));
$this->assertSame($flags, $state->get());
}
/**
* @group disconnected
*/
public function testCanUnflagSingleStates(): void
{
$state = new MultiExecState();
$state->set(MultiExecState::INITIALIZED | MultiExecState::CAS);
$this->assertTrue($state->check(MultiExecState::INITIALIZED));
$this->assertTrue($state->check(MultiExecState::CAS));
$state->unflag(MultiExecState::CAS);
$this->assertTrue($state->check(MultiExecState::INITIALIZED));
$this->assertFalse($state->check(MultiExecState::CAS));
$state->unflag(MultiExecState::INITIALIZED);
$this->assertFalse($state->check(MultiExecState::INITIALIZED));
$this->assertFalse($state->check(MultiExecState::CAS));
$this->assertTrue($state->isReset());
}
/**
* @group disconnected
*/
public function testIsInitializedMethod(): void
{
$state = new MultiExecState();
$this->assertFalse($state->isInitialized());
$state->set(MultiExecState::INITIALIZED);
$this->assertTrue($state->isInitialized());
}
/**
* @group disconnected
*/
public function testIsExecuting(): void
{
$state = new MultiExecState();
$this->assertFalse($state->isExecuting());
$state->set(MultiExecState::INSIDEBLOCK);
$this->assertTrue($state->isExecuting());
}
/**
* @group disconnected
*/
public function testIsCAS(): void
{
$state = new MultiExecState();
$this->assertFalse($state->isCAS());
$state->set(MultiExecState::CAS);
$this->assertTrue($state->isCAS());
}
/**
* @group disconnected
*/
public function testIsWatchAllowed(): void
{
$state = new MultiExecState();
$this->assertFalse($state->isWatchAllowed());
$state->flag(MultiExecState::INITIALIZED);
$this->assertTrue($state->isWatchAllowed());
$state->flag(MultiExecState::CAS);
$this->assertFalse($state->isWatchAllowed());
$state->unflag(MultiExecState::CAS);
$this->assertTrue($state->isWatchAllowed());
}
/**
* @group disconnected
*/
public function testIsWatching(): void
{
$state = new MultiExecState();
$this->assertFalse($state->isWatching());
$state->set(MultiExecState::WATCH);
$this->assertTrue($state->isWatching());
}
/**
* @group disconnected
*/
public function testIsDiscarded(): void
{
$state = new MultiExecState();
$this->assertFalse($state->isDiscarded());
$state->set(MultiExecState::DISCARDED);
$this->assertTrue($state->isDiscarded());
}
/**
* @group disconnected
*/
public function testIsAborted(): void
{
$state = new MultiExecState();
$this->assertFalse($state->isAborted());
$state->set(MultiExecState::ABORTED);
$this->assertTrue($state->isAborted());
$this->assertFalse($state->isReset());
}
}