repo stringlengths 7 63 | file_url stringlengths 81 284 | file_path stringlengths 5 200 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:02:33 2026-01-05 05:24:06 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/SqlTest.php | test/unit/Sql/SqlTest.php | <?php
namespace LaminasTest\Db\Sql;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\ConnectionInterface;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\ResultInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Sql\Delete;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\Insert;
use Laminas\Db\Sql\Select;
use Laminas\Db\Sql\Sql;
use Laminas\Db\Sql\Update;
use LaminasTest\Db\TestAsset;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
class SqlTest extends TestCase
{
/** @var Adapter&MockObject */
protected $mockAdapter;
/**
* Sql object
*
* @var Sql
*/
protected $sql;
protected function setUp(): void
{
// mock the adapter, driver, and parts
$mockResult = $this->getMockBuilder(ResultInterface::class)->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$mockStatement->expects($this->any())->method('execute')->will($this->returnValue($mockResult));
$mockConnection = $this->getMockBuilder(ConnectionInterface::class)->getMock();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('createStatement')->will($this->returnValue($mockStatement));
$mockDriver->expects($this->any())->method('getConnection')->will($this->returnValue($mockConnection));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
// setup mock adapter
$this->mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver, new TestAsset\TrustingSql92Platform()])
->getMock();
$this->sql = new Sql($this->mockAdapter, 'foo');
}
/**
* @covers \Laminas\Db\Sql\Sql::__construct
*/
// @codingStandardsIgnoreStart
public function test__construct()
{
// @codingStandardsIgnoreEnd
$sql = new Sql($this->mockAdapter);
self::assertFalse($sql->hasTable());
$sql->setTable('foo');
self::assertSame('foo', $sql->getTable());
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Table must be a string, array or instance of TableIdentifier.');
$sql->setTable(null);
}
/**
* @covers \Laminas\Db\Sql\Sql::select
*/
public function testSelect()
{
$select = $this->sql->select();
self::assertInstanceOf(Select::class, $select);
self::assertSame('foo', $select->getRawState('table'));
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'This Sql object is intended to work with only the table "foo" provided at construction time.'
);
$this->sql->select('bar');
}
/**
* @covers \Laminas\Db\Sql\Sql::insert
*/
public function testInsert()
{
$insert = $this->sql->insert();
self::assertInstanceOf(Insert::class, $insert);
self::assertSame('foo', $insert->getRawState('table'));
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'This Sql object is intended to work with only the table "foo" provided at construction time.'
);
$this->sql->insert('bar');
}
/**
* @covers \Laminas\Db\Sql\Sql::update
*/
public function testUpdate()
{
$update = $this->sql->update();
self::assertInstanceOf(Update::class, $update);
self::assertSame('foo', $update->getRawState('table'));
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'This Sql object is intended to work with only the table "foo" provided at construction time.'
);
$this->sql->update('bar');
}
/**
* @covers \Laminas\Db\Sql\Sql::delete
*/
public function testDelete()
{
$delete = $this->sql->delete();
self::assertInstanceOf(Delete::class, $delete);
self::assertSame('foo', $delete->getRawState('table'));
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'This Sql object is intended to work with only the table "foo" provided at construction time.'
);
$this->sql->delete('bar');
}
/**
* @covers \Laminas\Db\Sql\Sql::prepareStatementForSqlObject
*/
public function testPrepareStatementForSqlObject()
{
$insert = $this->sql->insert()->columns(['foo'])->values(['foo' => 'bar']);
$stmt = $this->sql->prepareStatementForSqlObject($insert);
self::assertInstanceOf(StatementInterface::class, $stmt);
}
/**
* @group 6890
*/
public function testForDifferentAdapters()
{
$adapterSql92 = $this->getAdapterForPlatform('sql92');
$adapterMySql = $this->getAdapterForPlatform('MySql');
$adapterOracle = $this->getAdapterForPlatform('Oracle');
$adapterSqlServer = $this->getAdapterForPlatform('SqlServer');
$select = $this->sql->select()->offset(10);
// Default
self::assertEquals(
'SELECT "foo".* FROM "foo" OFFSET \'10\'',
$this->sql->buildSqlString($select)
);
$this->mockAdapter->getDriver()->createStatement()->expects($this->any())->method('setSql')
->with($this->equalTo('SELECT "foo".* FROM "foo" OFFSET ?'));
$this->sql->prepareStatementForSqlObject($select);
// Sql92
self::assertEquals(
'SELECT "foo".* FROM "foo" OFFSET \'10\'',
$this->sql->buildSqlString($select, $adapterSql92)
);
$adapterSql92->getDriver()->createStatement()->expects($this->any())->method('setSql')
->with($this->equalTo('SELECT "foo".* FROM "foo" OFFSET ?'));
$this->sql->prepareStatementForSqlObject($select, null, $adapterSql92);
// MySql
self::assertEquals(
'SELECT `foo`.* FROM `foo` LIMIT 18446744073709551615 OFFSET 10',
$this->sql->buildSqlString($select, $adapterMySql)
);
$adapterMySql->getDriver()->createStatement()->expects($this->any())->method('setSql')
->with($this->equalTo('SELECT `foo`.* FROM `foo` LIMIT 18446744073709551615 OFFSET ?'));
$this->sql->prepareStatementForSqlObject($select, null, $adapterMySql);
// Oracle
self::assertEquals(
'SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "foo".* FROM "foo" ) b ) WHERE b_rownum > (10)',
$this->sql->buildSqlString($select, $adapterOracle)
);
// @codingStandardsIgnoreStart
$adapterOracle->getDriver()->createStatement()->expects($this->any())->method('setSql')
->with($this->equalTo('SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "foo".* FROM "foo" ) b ) WHERE b_rownum > (:offset)'));
// @codingStandardsIgnoreEnd
$this->sql->prepareStatementForSqlObject($select, null, $adapterOracle);
// SqlServer
self::assertStringContainsString(
'WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN 10+1 AND 0+10',
$this->sql->buildSqlString($select, $adapterSqlServer)
);
$adapterSqlServer->getDriver()->createStatement()->expects($this->any())->method('setSql')
->with($this->stringContains(
'WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN ?+1 AND ?+?'
));
$this->sql->prepareStatementForSqlObject($select, null, $adapterSqlServer);
}
/**
* Data provider
*
* @param string $platform
* @return Adapter
*/
protected function getAdapterForPlatform($platform)
{
switch ($platform) {
case 'sql92':
$platform = new TestAsset\TrustingSql92Platform();
break;
case 'MySql':
$platform = new TestAsset\TrustingMysqlPlatform();
break;
case 'Oracle':
$platform = new TestAsset\TrustingOraclePlatform();
break;
case 'SqlServer':
$platform = new TestAsset\TrustingSqlServerPlatform();
break;
default:
$platform = null;
}
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockDriver->expects($this->any())->method('createStatement')->will($this->returnValue($mockStatement));
return new Adapter($mockDriver, $platform);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/SelectTest.php | test/unit/Sql/SelectTest.php | <?php
namespace LaminasTest\Db\Sql;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\Platform\Sql92;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\ExpressionInterface;
use Laminas\Db\Sql\Having;
use Laminas\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\In;
use Laminas\Db\Sql\Predicate\IsNotNull;
use Laminas\Db\Sql\Predicate\Literal;
use Laminas\Db\Sql\Predicate\Operator;
use Laminas\Db\Sql\Select;
use Laminas\Db\Sql\TableIdentifier;
use Laminas\Db\Sql\Where;
use LaminasTest\Db\TestAsset\TrustingSql92Platform;
use PHPUnit\Framework\TestCase;
use ReflectionObject;
class SelectTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Select::__construct
*/
public function testConstruct()
{
$select = new Select('foo');
self::assertEquals('foo', $select->getRawState('table'));
}
/**
* @testdox unit test: Test from() returns Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::from
*/
public function testFrom(): Select
{
$select = new Select();
$return = $select->from('foo', 'bar');
self::assertSame($select, $return);
return $return;
}
/**
* @testdox unit test: Test getRawState() returns information populated via from()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testFrom
*/
public function testGetRawStateViaFrom(Select $select)
{
self::assertEquals('foo', $select->getRawState('table'));
}
/**
* @testdox unit test: Test quantifier() returns Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::quantifier
*/
public function testQuantifier(): Select
{
$select = new Select();
$return = $select->quantifier($select::QUANTIFIER_DISTINCT);
self::assertSame($select, $return);
return $return;
}
/**
* @testdox unit test: Test getRawState() returns information populated via quantifier()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testQuantifier
*/
public function testGetRawStateViaQuantifier(Select $select)
{
self::assertEquals(Select::QUANTIFIER_DISTINCT, $select->getRawState('quantifier'));
}
/**
* @testdox unit test: Test quantifier() accepts expression
* @covers \Laminas\Db\Sql\Select::quantifier
*/
public function testQuantifierParameterExpressionInterface()
{
$expr = $this->getMockBuilder(ExpressionInterface::class)->getMock();
$select = new Select();
$select->quantifier($expr);
self::assertSame(
$expr,
$select->getRawState(Select::QUANTIFIER)
);
}
/**
* @testdox unit test: Test columns() returns Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::columns
*/
public function testColumns(): Select
{
$select = new Select();
$return = $select->columns(['foo', 'bar']);
self::assertSame($select, $return);
return $select;
}
/**
* @testdox unit test: Test isTableReadOnly() returns correct state for read only
* @covers \Laminas\Db\Sql\Select::isTableReadOnly
*/
public function testIsTableReadOnly()
{
$select = new Select('foo');
self::assertTrue($select->isTableReadOnly());
$select = new Select();
self::assertFalse($select->isTableReadOnly());
}
/**
* @testdox unit test: Test getRawState() returns information populated via columns()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testColumns
*/
public function testGetRawStateViaColumns(Select $select)
{
self::assertEquals(['foo', 'bar'], $select->getRawState('columns'));
}
/**
* @testdox unit test: Test join() returns same Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::join
*/
public function testJoin(): Select
{
$select = new Select();
$return = $select->join('foo', 'x = y', Select::SQL_STAR, Select::JOIN_INNER);
self::assertSame($select, $return);
return $return;
}
/**
* @testdox unit test: Test join() exception with bad join
* @covers \Laminas\Db\Sql\Select::join
*/
public function testBadJoin()
{
$select = new Select();
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage("expects 'foo' as");
$select->join(['foo'], 'x = y', Select::SQL_STAR, Select::JOIN_INNER);
}
/**
* @testdox unit test: Test processJoins() exception with bad join name
* @covers \Laminas\Db\Sql\Select::processJoins
*/
public function testBadJoinName()
{
$mockExpression = $this->getMockBuilder(ExpressionInterface::class)
->getMock();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$parameterContainer = new ParameterContainer();
$select = new Select();
$select->join(['foo' => $mockExpression], 'x = y', Select::SQL_STAR, Select::JOIN_INNER);
$sr = new ReflectionObject($select);
$mr = $sr->getMethod('processJoins');
$mr->setAccessible(true);
$this->expectException(InvalidArgumentException::class);
$mr->invokeArgs($select, [new Sql92(), $mockDriver, $parameterContainer]);
}
/**
* @testdox unit test: Test getRawState() returns information populated via join()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testJoin
*/
public function testGetRawStateViaJoin(Select $select)
{
self::assertEquals(
[
[
'name' => 'foo',
'on' => 'x = y',
'columns' => [Select::SQL_STAR],
'type' => Select::JOIN_INNER,
],
],
$select->getRawState('joins')->getJoins()
);
}
/**
* @testdox unit test: Test where() returns Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereReturnsSameSelectObject()
{
$select = new Select();
self::assertSame($select, $select->where('x = y'));
}
/**
* @testdox unit test: Test where() will accept a string for the predicate to create an expression predicate
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsString()
{
$select = new Select();
$select->where('x = ?');
/** @var Where $where */
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertCount(1, $predicates);
self::assertInstanceOf(\Laminas\Db\Sql\Predicate\Expression::class, $predicates[0][1]);
self::assertEquals(Where::OP_AND, $predicates[0][0]);
self::assertEquals('x = ?', $predicates[0][1]->getExpression());
$select = new Select();
$select->where('x = y');
/** @var Where $where */
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertInstanceOf(Literal::class, $predicates[0][1]);
}
/**
* @testdox unit test: Test where() will accept an array with a string key (containing ?) used as an
* expression with placeholder
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsAssociativeArrayContainingReplacementCharacter()
{
$select = new Select();
$select->where(['foo > ?' => 5]);
/** @var Where $where */
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertCount(1, $predicates);
self::assertInstanceOf(\Laminas\Db\Sql\Predicate\Expression::class, $predicates[0][1]);
self::assertEquals(Where::OP_AND, $predicates[0][0]);
self::assertEquals('foo > ?', $predicates[0][1]->getExpression());
self::assertEquals([5], $predicates[0][1]->getParameters());
}
/**
* @testdox unit test: Test where() will accept any array with string key (without ?) to be used
* as Operator predicate
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsAssociativeArrayNotContainingReplacementCharacter()
{
$select = new Select();
$select->where(['name' => 'Ralph', 'age' => 33]);
/** @var Where $where */
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertCount(2, $predicates);
self::assertInstanceOf(Operator::class, $predicates[0][1]);
self::assertEquals(Where::OP_AND, $predicates[0][0]);
self::assertEquals('name', $predicates[0][1]->getLeft());
self::assertEquals('Ralph', $predicates[0][1]->getRight());
self::assertInstanceOf(Operator::class, $predicates[1][1]);
self::assertEquals(Where::OP_AND, $predicates[1][0]);
self::assertEquals('age', $predicates[1][1]->getLeft());
self::assertEquals(33, $predicates[1][1]->getRight());
$select = new Select();
$select->where(['x = y']);
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertInstanceOf(Literal::class, $predicates[0][1]);
}
/**
* @testdox unit test: Test where() will accept any array with string key (without ?) with Predicate throw Exception
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsAssociativeArrayIsPredicate()
{
$select = new Select();
$where = [
'name' => new Predicate\Literal("name = 'Ralph'"),
'age' => new Predicate\Expression('age = ?', 33),
];
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Using Predicate must not use string keys');
$select->where($where);
}
/**
* @testdox unit test: Test where() will accept an indexed array to be used by joining string expressions
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsIndexedArray()
{
$select = new Select();
$select->where(['name = "Ralph"']);
/** @var Where $where */
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertCount(1, $predicates);
self::assertInstanceOf(Literal::class, $predicates[0][1]);
self::assertEquals(Where::OP_AND, $predicates[0][0]);
self::assertEquals('name = "Ralph"', $predicates[0][1]->getLiteral());
}
/**
* @testdox unit test: Test where() will accept an indexed array to be used by joining string expressions,
* combined by OR
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsIndexedArrayArgument2IsOr()
{
$select = new Select();
$select->where(['name = "Ralph"'], Where::OP_OR);
/** @var Where $where */
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertCount(1, $predicates);
self::assertInstanceOf(Literal::class, $predicates[0][1]);
self::assertEquals(Where::OP_OR, $predicates[0][0]);
self::assertEquals('name = "Ralph"', $predicates[0][1]->getLiteral());
}
/**
* @testdox unit test: Test where() will accept a closure to be executed with Where object as argument
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsClosure()
{
$select = new Select();
$where = $select->getRawState('where');
$select->where(function ($what) use ($where) {
self::assertSame($where, $what);
});
}
/**
* @testdox unit test: Test where() will accept any Predicate object as-is
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsPredicate()
{
$select = new Select();
$predicate = new Predicate\Predicate([
new Predicate\Expression('name = ?', 'Ralph'),
new Predicate\Expression('age = ?', 33),
]);
$select->where($predicate);
/** @var Where $where */
$where = $select->getRawState('where');
$predicates = $where->getPredicates();
self::assertSame($predicate, $predicates[0][1]);
}
/**
* @testdox unit test: Test where() will accept a Where object
* @covers \Laminas\Db\Sql\Select::where
*/
public function testWhereArgument1IsWhereObject()
{
$select = new Select();
$select->where($newWhere = new Where());
self::assertSame($newWhere, $select->getRawState('where'));
}
/**
* @testdox unit test: Test order()
* @covers \Laminas\Db\Sql\Select::order
*/
public function testOrder()
{
$select = new Select();
$return = $select->order('id DESC');
self::assertSame($select, $return); // test fluent interface
self::assertEquals(['id DESC'], $select->getRawState('order'));
$select = new Select();
$select->order('id DESC')
->order('name ASC, age DESC');
self::assertEquals(['id DESC', 'name ASC', 'age DESC'], $select->getRawState('order'));
$select = new Select();
$select->order(['name ASC', 'age DESC']);
self::assertEquals(['name ASC', 'age DESC'], $select->getRawState('order'));
$select = new Select();
$select->order(new Expression('RAND()'));
$sr = new ReflectionObject($select);
$method = $sr->getMethod('processOrder');
$method->setAccessible(true);
self::assertEquals(
[[['RAND()']]],
$method->invokeArgs($select, [new TrustingSql92Platform()])
);
$select = new Select();
$select->order(
$this->getMockBuilder(Operator::class)
->setMethods()
->setConstructorArgs(['rating', '<', '10'])
->getMock()
);
$sr = new ReflectionObject($select);
$method = $sr->getMethod('processOrder');
$method->setAccessible(true);
self::assertEquals(
[[['"rating" < \'10\'']]],
$method->invokeArgs($select, [new TrustingSql92Platform()])
);
}
/**
* @testdox unit test: Test order() correctly splits parameters.
* @covers \Laminas\Db\Sql\Select::order
*/
public function testOrderCorrectlySplitsParameter()
{
$select = new Select();
$select->order('name desc');
self::assertEquals(
'SELECT * ORDER BY "name" DESC',
$select->getSqlString(new TrustingSql92Platform())
);
}
/**
* @testdox: unit test: test limit()
* @covers \Laminas\Db\Sql\Select::limit
*/
public function testLimit(): Select
{
$select = new Select();
self::assertSame($select, $select->limit(5));
return $select;
}
/**
* @testdox: unit test: Test getRawState() returns information populated via limit()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testLimit
*/
public function testGetRawStateViaLimit(Select $select)
{
self::assertEquals(5, $select->getRawState($select::LIMIT));
}
/**
* @testdox: unit test: test limit() throws execption when invalid parameter passed
* @covers \Laminas\Db\Sql\Select::limit
*/
public function testLimitExceptionOnInvalidParameter()
{
$select = new Select();
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Laminas\Db\Sql\Select::limit expects parameter to be numeric');
$select->limit('foobar');
}
/**
* @testdox: unit test: test offset()
* @covers \Laminas\Db\Sql\Select::offset
*/
public function testOffset(): Select
{
$select = new Select();
self::assertSame($select, $select->offset(10));
return $select;
}
/**
* @testdox: unit test: Test getRawState() returns information populated via offset()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testOffset
*/
public function testGetRawStateViaOffset(Select $select)
{
self::assertEquals(10, $select->getRawState($select::OFFSET));
}
/**
* @testdox: unit test: test offset() throws exception when invalid parameter passed
* @covers \Laminas\Db\Sql\Select::offset
*/
public function testOffsetExceptionOnInvalidParameter()
{
$select = new Select();
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Laminas\Db\Sql\Select::offset expects parameter to be numeric');
$select->offset('foobar');
}
/**
* @testdox unit test: Test group() returns same Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::group
*/
public function testGroup(): Select
{
$select = new Select();
$return = $select->group(['col1', 'col2']);
self::assertSame($select, $return);
return $return;
}
/**
* @testdox unit test: Test getRawState() returns information populated via group()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testGroup
*/
public function testGetRawStateViaGroup(Select $select)
{
self::assertEquals(
['col1', 'col2'],
$select->getRawState('group')
);
}
/**
* @testdox unit test: Test having() returns same Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::having
*/
public function testHaving(): Select
{
$select = new Select();
$return = $select->having(['x = ?' => 5]);
self::assertSame($select, $return);
return $return;
}
/**
* @testdox unit test: Test having() returns same Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::having
*/
public function testHavingArgument1IsHavingObject(): Select
{
$select = new Select();
$having = new Having();
$return = $select->having($having);
self::assertSame($select, $return);
self::assertSame($having, $select->getRawState('having'));
return $return;
}
/**
* @testdox unit test: Test getRawState() returns information populated via having()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testHaving
*/
public function testGetRawStateViaHaving(Select $select)
{
self::assertInstanceOf(Having::class, $select->getRawState('having'));
}
/**
* @testdox unit test: Test combine() returns same Select object (is chainable)
* @covers \Laminas\Db\Sql\Select::combine
*/
public function testCombine(): Select
{
$select = new Select();
$combine = new Select();
$return = $select->combine($combine, $select::COMBINE_UNION, 'ALL');
self::assertSame($select, $return);
return $return;
}
/**
* @testdox unit test: Test getRawState() returns information populated via combine()
* @covers \Laminas\Db\Sql\Select::getRawState
* @depends testCombine
*/
public function testGetRawStateViaCombine(Select $select)
{
$state = $select->getRawState('combine');
self::assertInstanceOf(Select::class, $state['select']);
self::assertNotSame($select, $state['select']);
self::assertEquals(Select::COMBINE_UNION, $state['type']);
self::assertEquals('ALL', $state['modifier']);
}
/**
* @testdox unit test: Test reset() resets internal stat of Select object, based on input
* @covers \Laminas\Db\Sql\Select::reset
*/
public function testReset()
{
$select = new Select();
// table
$select->from('foo');
self::assertEquals('foo', $select->getRawState(Select::TABLE));
$select->reset(Select::TABLE);
self::assertNull($select->getRawState(Select::TABLE));
// columns
$select->columns(['foo']);
self::assertEquals(['foo'], $select->getRawState(Select::COLUMNS));
$select->reset(Select::COLUMNS);
self::assertEmpty($select->getRawState(Select::COLUMNS));
// joins
$select->join('foo', 'id = boo');
self::assertEquals(
[['name' => 'foo', 'on' => 'id = boo', 'columns' => ['*'], 'type' => 'inner']],
$select->getRawState(Select::JOINS)->getJoins()
);
$select->reset(Select::JOINS);
self::assertEmpty($select->getRawState(Select::JOINS)->getJoins());
// where
$select->where('foo = bar');
$where1 = $select->getRawState(Select::WHERE);
self::assertEquals(1, $where1->count());
$select->reset(Select::WHERE);
$where2 = $select->getRawState(Select::WHERE);
self::assertEquals(0, $where2->count());
self::assertNotSame($where1, $where2);
// group
$select->group(['foo']);
self::assertEquals(['foo'], $select->getRawState(Select::GROUP));
$select->reset(Select::GROUP);
self::assertEmpty($select->getRawState(Select::GROUP));
// having
$select->having('foo = bar');
$having1 = $select->getRawState(Select::HAVING);
self::assertEquals(1, $having1->count());
$select->reset(Select::HAVING);
$having2 = $select->getRawState(Select::HAVING);
self::assertEquals(0, $having2->count());
self::assertNotSame($having1, $having2);
// limit
$select->limit(5);
self::assertEquals(5, $select->getRawState(Select::LIMIT));
$select->reset(Select::LIMIT);
self::assertNull($select->getRawState(Select::LIMIT));
// offset
$select->offset(10);
self::assertEquals(10, $select->getRawState(Select::OFFSET));
$select->reset(Select::OFFSET);
self::assertNull($select->getRawState(Select::OFFSET));
// order
$select->order('foo asc');
self::assertEquals(['foo asc'], $select->getRawState(Select::ORDER));
$select->reset(Select::ORDER);
self::assertEmpty($select->getRawState(Select::ORDER));
}
/**
* @testdox unit test: Test prepareStatement() will produce expected sql and parameters based on
* a variety of provided arguments [uses data provider]
* @covers \Laminas\Db\Sql\Select::prepareStatement
* @dataProvider providerData
* @param mixed $unused1
* @param mixed $unused2
*/
public function testPrepareStatement(
Select $select,
string $expectedSqlString,
array $expectedParameters,
$unused1,
$unused2,
bool $useNamedParameters = false
) {
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnCallback(
function ($name) use ($useNamedParameters) {
return $useNamedParameters ? ':' . $name : '?';
}
));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$parameterContainer = new ParameterContainer();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$mockStatement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$mockStatement->expects($this->any())->method('setSql')->with($this->equalTo($expectedSqlString));
$select->prepareStatement($mockAdapter, $mockStatement);
if ($expectedParameters) {
self::assertEquals($expectedParameters, $parameterContainer->getNamedArray());
}
}
/**
* @group Laminas-5192
*/
public function testSelectUsingTableIdentifierWithEmptyScheme()
{
$select = new Select();
$select->from(new TableIdentifier('foo'));
$select->join(new TableIdentifier('bar'), 'foo.id = bar.fooid');
self::assertEquals(
'SELECT "foo".*, "bar".* FROM "foo" INNER JOIN "bar" ON "foo"."id" = "bar"."fooid"',
$select->getSqlString(new TrustingSql92Platform())
);
}
/**
* @testdox unit test: Test getSqlString() will produce expected sql and parameters based on
* a variety of provided arguments [uses data provider]
* @covers \Laminas\Db\Sql\Select::getSqlString
* @dataProvider providerData
* @param mixed $unused
* @param mixed $unused2
*/
public function testGetSqlString(Select $select, $unused, $unused2, string $expectedSqlString)
{
self::assertEquals($expectedSqlString, $select->getSqlString(new TrustingSql92Platform()));
}
/**
* @testdox unit test: Test __get() returns expected objects magically
* @covers \Laminas\Db\Sql\Select::__get
*/
public function testMagicAccessor()
{
$select = new Select();
self::assertInstanceOf(Where::class, $select->where);
}
/**
* @testdox unit test: Test __clone() will clone the where object so that this select can be used
* in multiple contexts
* @covers \Laminas\Db\Sql\Select::__clone
*/
public function testCloning()
{
$select = new Select();
$select1 = clone $select;
$select1->where('id = foo');
$select1->having('id = foo');
self::assertEquals(0, $select->where->count());
self::assertEquals(1, $select1->where->count());
self::assertEquals(0, $select->having->count());
self::assertEquals(1, $select1->having->count());
}
/**
* @testdox unit test: Text process*() methods will return proper array when internally called,
* part of extension API
* @dataProvider providerData
* @covers \Laminas\Db\Sql\Select::processSelect
* @covers \Laminas\Db\Sql\Select::processJoins
* @covers \Laminas\Db\Sql\Select::processWhere
* @covers \Laminas\Db\Sql\Select::processGroup
* @covers \Laminas\Db\Sql\Select::processHaving
* @covers \Laminas\Db\Sql\Select::processOrder
* @covers \Laminas\Db\Sql\Select::processLimit
* @covers \Laminas\Db\Sql\Select::processOffset
* @covers \Laminas\Db\Sql\Select::processCombine
* @param mixed $unused
* @param mixed $unused2
* @param mixed $unused3
*/
public function testProcessMethods(Select $select, $unused, $unused2, $unused3, array $internalTests)
{
if (! $internalTests) {
return;
}
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$parameterContainer = new ParameterContainer();
$sr = new ReflectionObject($select);
foreach ($internalTests as $method => $expected) {
$mr = $sr->getMethod($method);
$mr->setAccessible(true);
$return = $mr->invokeArgs($select, [new Sql92(), $mockDriver, $parameterContainer]);
self::assertEquals($expected, $return);
}
}
/**
* @psalm-return array<array-key, array{
* 0: Select,
* 1: string,
* 2: array<string, mixed>,
* 3 string,
* 4: array,
* 5: bool,
* }
*/
public function providerData(): array
{
// phpcs:disable Generic.Files.LineLength.TooLong
// basic table
$select0 = new Select();
$select0->from('foo');
$sqlPrep0 = // same
$sqlStr0 = 'SELECT "foo".* FROM "foo"';
$internalTests0 = [
'processSelect' => [[['"foo".*']], '"foo"'],
];
// table as TableIdentifier
$select1 = new Select();
$select1->from(new TableIdentifier('foo', 'bar'));
$sqlPrep1 = // same
$sqlStr1 = 'SELECT "bar"."foo".* FROM "bar"."foo"';
$internalTests1 = [
'processSelect' => [[['"bar"."foo".*']], '"bar"."foo"'],
];
// table with alias
$select2 = new Select();
$select2->from(['f' => 'foo']);
$sqlPrep2 = // same
$sqlStr2 = 'SELECT "f".* FROM "foo" AS "f"';
$internalTests2 = [
'processSelect' => [[['"f".*']], '"foo" AS "f"'],
];
// table with alias with table as TableIdentifier
$select3 = new Select();
$select3->from(['f' => new TableIdentifier('foo')]);
$sqlPrep3 = // same
$sqlStr3 = 'SELECT "f".* FROM "foo" AS "f"';
$internalTests3 = [
'processSelect' => [[['"f".*']], '"foo" AS "f"'],
];
// columns
$select4 = new Select();
$select4->from('foo')->columns(['bar', 'baz']);
$sqlPrep4 = // same
$sqlStr4 = 'SELECT "foo"."bar" AS "bar", "foo"."baz" AS "baz" FROM "foo"';
$internalTests4 = [
'processSelect' => [[['"foo"."bar"', '"bar"'], ['"foo"."baz"', '"baz"']], '"foo"'],
];
// columns with AS associative array
$select5 = new Select();
$select5->from('foo')->columns(['bar' => 'baz']);
$sqlPrep5 = // same
$sqlStr5 = 'SELECT "foo"."baz" AS "bar" FROM "foo"';
$internalTests5 = [
'processSelect' => [[['"foo"."baz"', '"bar"']], '"foo"'],
];
// columns with AS associative array mixed
$select6 = new Select();
$select6->from('foo')->columns(['bar' => 'baz', 'bam']);
$sqlPrep6 = // same
$sqlStr6 = 'SELECT "foo"."baz" AS "bar", "foo"."bam" AS "bam" FROM "foo"';
$internalTests6 = [
'processSelect' => [[['"foo"."baz"', '"bar"'], ['"foo"."bam"', '"bam"']], '"foo"'],
];
// columns where value is Expression, with AS
$select7 = new Select();
$select7->from('foo')->columns(['bar' => new Expression('COUNT(some_column)')]);
$sqlPrep7 = // same
$sqlStr7 = 'SELECT COUNT(some_column) AS "bar" FROM "foo"';
$internalTests7 = [
'processSelect' => [[['COUNT(some_column)', '"bar"']], '"foo"'],
];
// columns where value is Expression
$select8 = new Select();
$select8->from('foo')->columns([new Expression('COUNT(some_column) AS bar')]);
$sqlPrep8 = // same
$sqlStr8 = 'SELECT COUNT(some_column) AS bar FROM "foo"';
$internalTests8 = [
'processSelect' => [[['COUNT(some_column) AS bar']], '"foo"'],
];
// columns where value is Expression with parameters
$select9 = new Select();
$select9->from('foo')->columns(
[
new Expression(
'(COUNT(?) + ?) AS ?',
['some_column', 5, 'bar'],
[Expression::TYPE_IDENTIFIER, Expression::TYPE_VALUE, Expression::TYPE_IDENTIFIER]
),
]
);
$sqlPrep9 = 'SELECT (COUNT("some_column") + ?) AS "bar" FROM "foo"';
$sqlStr9 = 'SELECT (COUNT("some_column") + \'5\') AS "bar" FROM "foo"';
$params9 = ['column1' => 5];
$internalTests9 = [
'processSelect' => [[['(COUNT("some_column") + ?) AS "bar"']], '"foo"'],
];
// joins (plain)
$select10 = new Select();
$select10->from('foo')->join('zac', 'm = n');
$sqlPrep10 = // same
$sqlStr10 = 'SELECT "foo".*, "zac".* FROM "foo" INNER JOIN "zac" ON "m" = "n"';
$internalTests10 = [
'processSelect' => [[['"foo".*'], ['"zac".*']], '"foo"'],
'processJoins' => [[['INNER', '"zac"', '"m" = "n"']]],
];
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | true |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/TableIdentifierTest.php | test/unit/Sql/TableIdentifierTest.php | <?php
namespace LaminasTest\Db\Sql;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\TableIdentifier;
use PHPUnit\Framework\TestCase;
use stdClass;
use function array_merge;
/**
* Tests for {@see \Laminas\Db\Sql\TableIdentifier}
*
* @covers \Laminas\Db\Sql\TableIdentifier
*/
class TableIdentifierTest extends TestCase
{
public function testGetTable()
{
$tableIdentifier = new TableIdentifier('foo');
self::assertSame('foo', $tableIdentifier->getTable());
}
public function testGetDefaultSchema()
{
$tableIdentifier = new TableIdentifier('foo');
self::assertNull($tableIdentifier->getSchema());
}
public function testGetSchema()
{
$tableIdentifier = new TableIdentifier('foo', 'bar');
self::assertSame('bar', $tableIdentifier->getSchema());
}
public function testGetTableFromObjectStringCast()
{
$table = $this->getMockBuilder('stdClass')->setMethods(['__toString'])->getMock();
$table->expects($this->once())->method('__toString')->will($this->returnValue('castResult'));
$tableIdentifier = new TableIdentifier($table);
self::assertSame('castResult', $tableIdentifier->getTable());
self::assertSame('castResult', $tableIdentifier->getTable());
}
public function testGetSchemaFromObjectStringCast()
{
$schema = $this->getMockBuilder('stdClass')->setMethods(['__toString'])->getMock();
$schema->expects($this->once())->method('__toString')->will($this->returnValue('castResult'));
$tableIdentifier = new TableIdentifier('foo', $schema);
self::assertSame('castResult', $tableIdentifier->getSchema());
self::assertSame('castResult', $tableIdentifier->getSchema());
}
/**
* @dataProvider invalidTableProvider
* @param mixed $invalidTable
*/
public function testRejectsInvalidTable($invalidTable)
{
$this->expectException(InvalidArgumentException::class);
new TableIdentifier($invalidTable);
}
/**
* @dataProvider invalidSchemaProvider
* @param mixed $invalidSchema
*/
public function testRejectsInvalidSchema($invalidSchema)
{
$this->expectException(InvalidArgumentException::class);
new TableIdentifier('foo', $invalidSchema);
}
/**
* Data provider
*
* @return mixed[][]
*/
public function invalidTableProvider()
{
return array_merge(
[[null]],
$this->invalidSchemaProvider()
);
}
/**
* Data provider
*
* @return mixed[][]
*/
public function invalidSchemaProvider()
{
return [
[''],
[new stdClass()],
[[]],
];
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/ExpressionTest.php | test/unit/Sql/ExpressionTest.php | <?php
namespace LaminasTest\Db\Sql;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\Expression;
use PHPUnit\Framework\TestCase;
/**
* This is a unit testing test case.
* A unit here is a method, there will be at least one test per method
*
* Expression is a value object with no dependencies/collaborators, therefore, no fixure needed
*/
class ExpressionTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Expression::setExpression
* @return Expression
*/
public function testSetExpression()
{
$expression = new Expression();
$return = $expression->setExpression('Foo Bar');
self::assertSame($expression, $return);
return $return;
}
/**
* @covers \Laminas\Db\Sql\Expression::setExpression
*/
public function testSetExpressionException()
{
$expression = new Expression();
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Supplied expression must be a string.');
$expression->setExpression(null);
}
/**
* @covers \Laminas\Db\Sql\Expression::getExpression
* @depends testSetExpression
*/
public function testGetExpression(Expression $expression)
{
self::assertEquals('Foo Bar', $expression->getExpression());
}
/**
* @covers \Laminas\Db\Sql\Expression::setParameters
*/
public function testSetParameters(): Expression
{
$expression = new Expression();
$return = $expression->setParameters('foo');
self::assertSame($expression, $return);
return $return;
}
/**
* @covers \Laminas\Db\Sql\Expression::setParameters
*/
public function testSetParametersException()
{
$expression = new Expression('', 'foo');
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Expression parameters must be a scalar or array.');
$expression->setParameters(null);
}
/**
* @covers \Laminas\Db\Sql\Expression::getParameters
* @depends testSetParameters
*/
public function testGetParameters(Expression $expression)
{
self::assertEquals('foo', $expression->getParameters());
}
/**
* @covers \Laminas\Db\Sql\Expression::setTypes
*/
public function testSetTypes(): Expression
{
$expression = new Expression();
$return = $expression->setTypes([
Expression::TYPE_IDENTIFIER,
Expression::TYPE_VALUE,
Expression::TYPE_LITERAL,
]);
self::assertSame($expression, $return);
return $expression;
}
/**
* @covers \Laminas\Db\Sql\Expression::getTypes
* @depends testSetTypes
*/
public function testGetTypes(Expression $expression)
{
self::assertEquals(
[Expression::TYPE_IDENTIFIER, Expression::TYPE_VALUE, Expression::TYPE_LITERAL],
$expression->getTypes()
);
}
/**
* @covers \Laminas\Db\Sql\Expression::getExpressionData
*/
public function testGetExpressionData()
{
$expression = new Expression(
'X SAME AS ? AND Y = ? BUT LITERALLY ?',
['foo', 5, 'FUNC(FF%X)'],
[Expression::TYPE_IDENTIFIER, Expression::TYPE_VALUE, Expression::TYPE_LITERAL]
);
self::assertEquals(
[
[
'X SAME AS %s AND Y = %s BUT LITERALLY %s',
['foo', 5, 'FUNC(FF%X)'],
[Expression::TYPE_IDENTIFIER, Expression::TYPE_VALUE, Expression::TYPE_LITERAL],
],
],
$expression->getExpressionData()
);
$expression = new Expression(
'X SAME AS ? AND Y = ? BUT LITERALLY ?',
[
['foo' => Expression::TYPE_IDENTIFIER],
[5 => Expression::TYPE_VALUE],
['FUNC(FF%X)' => Expression::TYPE_LITERAL],
]
);
$expected = [
[
'X SAME AS %s AND Y = %s BUT LITERALLY %s',
['foo', 5, 'FUNC(FF%X)'],
[Expression::TYPE_IDENTIFIER, Expression::TYPE_VALUE, Expression::TYPE_LITERAL],
],
];
self::assertEquals($expected, $expression->getExpressionData());
}
public function testGetExpressionDataWillEscapePercent()
{
$expression = new Expression('X LIKE "foo%"');
self::assertEquals(
['X LIKE "foo%%"'],
$expression->getExpressionData()
);
}
public function testConstructorWithLiteralZero()
{
$expression = new Expression('0');
self::assertSame('0', $expression->getExpression());
}
/**
* @group 7407
*/
public function testGetExpressionPreservesPercentageSignInFromUnixtime()
{
$expressionString = 'FROM_UNIXTIME(date, "%Y-%m")';
$expression = new Expression($expressionString);
self::assertSame($expressionString, $expression->getExpression());
}
public function testNumberOfReplacementsConsidersWhenSameVariableIsUsedManyTimes()
{
$expression = new Expression('uf.user_id = :user_id OR uf.friend_id = :user_id', ['user_id' => 1]);
self::assertSame(
[
[
'uf.user_id = :user_id OR uf.friend_id = :user_id',
[1],
['value'],
],
],
$expression->getExpressionData()
);
}
/**
* @dataProvider falsyExpressionParametersProvider
* @param mixed $falsyParameter
*/
public function testConstructorWithFalsyValidParameters($falsyParameter)
{
$expression = new Expression('?', $falsyParameter);
self::assertSame($falsyParameter, $expression->getParameters());
}
public function testConstructorWithInvalidParameter()
{
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Expression parameters must be a scalar or array.');
new Expression('?', (object) []);
}
/** @psalm-return array<array-key, array{0: mixed}> */
public function falsyExpressionParametersProvider(): array
{
return [
[''],
['0'],
[0],
[0.0],
[false],
[[]],
];
}
public function testNumberOfReplacementsForExpressionWithParameters()
{
$expression = new Expression(':a + :b', ['a' => 1, 'b' => 2]);
self::assertSame(
[
[
':a + :b',
[1, 2],
['value', 'value'],
],
],
$expression->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/InsertTest.php | test/unit/Sql/InsertTest.php | <?php
namespace LaminasTest\Db\Sql;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\StatementContainer;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\Insert;
use Laminas\Db\Sql\Select;
use Laminas\Db\Sql\TableIdentifier;
use LaminasTest\Db\DeprecatedAssertionsTrait;
use LaminasTest\Db\TestAsset\Replace;
use LaminasTest\Db\TestAsset\TrustingSql92Platform;
use PHPUnit\Framework\TestCase;
class InsertTest extends TestCase
{
use DeprecatedAssertionsTrait;
/** @var Insert */
protected $insert;
/**
* Sets up the fixture, for example, opens a network connection.
* This method is called before a test is executed.
*/
protected function setUp(): void
{
$this->insert = new Insert();
}
/**
* @covers \Laminas\Db\Sql\Insert::into
*/
public function testInto()
{
$this->insert->into('table', 'schema');
self::assertEquals('table', $this->insert->getRawState('table'));
$tableIdentifier = new TableIdentifier('table', 'schema');
$this->insert->into($tableIdentifier);
self::assertEquals($tableIdentifier, $this->insert->getRawState('table'));
}
/**
* @covers \Laminas\Db\Sql\Insert::columns
*/
public function testColumns()
{
$columns = ['foo', 'bar'];
$this->insert->columns($columns);
self::assertEquals($columns, $this->insert->getRawState('columns'));
}
/**
* @covers \Laminas\Db\Sql\Insert::values
*/
public function testValues()
{
$this->insert->values(['foo' => 'bar']);
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bar'], $this->insert->getRawState('values'));
// test will merge cols and values of previously set stuff
$this->insert->values(['foo' => 'bax'], Insert::VALUES_MERGE);
$this->insert->values(['boom' => 'bam'], Insert::VALUES_MERGE);
self::assertEquals(['foo', 'boom'], $this->insert->getRawState('columns'));
self::assertEquals(['bax', 'bam'], $this->insert->getRawState('values'));
$this->insert->values(['foo' => 'bax']);
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bax'], $this->insert->getRawState('values'));
}
/**
* @covers \Laminas\Db\Sql\Insert::values
*/
public function testValuesThrowsExceptionWhenNotArrayOrSelect()
{
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('values() expects an array of values or Laminas\Db\Sql\Select instance');
$this->insert->values(5);
}
/**
* @covers \Laminas\Db\Sql\Insert::values
*/
public function testValuesThrowsExceptionWhenSelectMergeOverArray()
{
$this->insert->values(['foo' => 'bar']);
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('A Laminas\Db\Sql\Select instance cannot be provided with the merge flag');
$this->insert->values(new Select(), Insert::VALUES_MERGE);
}
/**
* @covers \Laminas\Db\Sql\Insert::values
*/
public function testValuesThrowsExceptionWhenArrayMergeOverSelect()
{
$this->insert->values(new Select());
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'An array of values cannot be provided with the merge flag when a Laminas\Db\Sql\Select instance already '
. 'exists as the value source'
);
$this->insert->values(['foo' => 'bar'], Insert::VALUES_MERGE);
}
/**
* @covers \Laminas\Db\Sql\Insert::values
* @group Laminas-4926
*/
public function testEmptyArrayValues()
{
$this->insert->values([]);
self::assertEquals([], $this->readAttribute($this->insert, 'columns'));
}
/**
* @covers \Laminas\Db\Sql\Insert::prepareStatement
*/
public function testPrepareStatement()
{
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('INSERT INTO "foo" ("bar", "boo") VALUES (?, NOW())'));
$this->insert->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$this->insert->prepareStatement($mockAdapter, $mockStatement);
// with TableIdentifier
$this->insert = new Insert();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('INSERT INTO "sch"."foo" ("bar", "boo") VALUES (?, NOW())'));
$this->insert->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$this->insert->prepareStatement($mockAdapter, $mockStatement);
}
/**
* @covers \Laminas\Db\Sql\Insert::prepareStatement
*/
public function testPrepareStatementWithSelect()
{
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = new StatementContainer();
$select = new Select('bar');
$this->insert
->into('foo')
->columns(['col1'])
->select($select->where(['x' => 5]))
->prepareStatement($mockAdapter, $mockStatement);
self::assertEquals(
'INSERT INTO "foo" ("col1") SELECT "bar".* FROM "bar" WHERE "x" = ?',
$mockStatement->getSql()
);
$parameters = $mockStatement->getParameterContainer()->getNamedArray();
self::assertSame(['subselect1where1' => 5], $parameters);
}
/**
* @covers \Laminas\Db\Sql\Insert::getSqlString
*/
public function testGetSqlString()
{
$this->insert->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'INSERT INTO "foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$this->insert->getSqlString(new TrustingSql92Platform())
);
// with TableIdentifier
$this->insert = new Insert();
$this->insert->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'INSERT INTO "sch"."foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$this->insert->getSqlString(new TrustingSql92Platform())
);
// with Select
$this->insert = new Insert();
$select = new Select();
$this->insert->into('foo')->select($select->from('bar'));
self::assertEquals(
'INSERT INTO "foo" SELECT "bar".* FROM "bar"',
$this->insert->getSqlString(new TrustingSql92Platform())
);
// with Select and columns
$this->insert->columns(['col1', 'col2']);
self::assertEquals(
'INSERT INTO "foo" ("col1", "col2") SELECT "bar".* FROM "bar"',
$this->insert->getSqlString(new TrustingSql92Platform())
);
}
public function testGetSqlStringUsingColumnsAndValuesMethods()
{
// With columns() and values()
$this->insert
->into('foo')
->columns(['col1', 'col2', 'col3'])
->values(['val1', 'val2', 'val3']);
self::assertEquals(
'INSERT INTO "foo" ("col1", "col2", "col3") VALUES (\'val1\', \'val2\', \'val3\')',
$this->insert->getSqlString(new TrustingSql92Platform())
);
}
/**
* @covers \Laminas\Db\Sql\Insert::__set
*/
// @codingStandardsIgnoreStart
public function test__set()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bar'], $this->insert->getRawState('values'));
}
/**
* @covers \Laminas\Db\Sql\Insert::__unset
*/
// @codingStandardsIgnoreStart
public function test__unset()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bar'], $this->insert->getRawState('values'));
unset($this->insert->foo);
self::assertEquals([], $this->insert->getRawState('columns'));
self::assertEquals([], $this->insert->getRawState('values'));
$this->insert->foo = null;
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals([null], $this->insert->getRawState('values'));
unset($this->insert->foo);
self::assertEquals([], $this->insert->getRawState('columns'));
self::assertEquals([], $this->insert->getRawState('values'));
}
/**
* @covers \Laminas\Db\Sql\Insert::__isset
*/
// @codingStandardsIgnoreStart
public function test__isset()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertTrue(isset($this->insert->foo));
$this->insert->foo = null;
self::assertTrue(isset($this->insert->foo));
}
/**
* @covers \Laminas\Db\Sql\Insert::__get
*/
// @codingStandardsIgnoreStart
public function test__get()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertEquals('bar', $this->insert->foo);
$this->insert->foo = null;
self::assertNull($this->insert->foo);
}
/**
* @group Laminas-536
*/
public function testValuesMerge()
{
$this->insert->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
$this->insert->into('foo')
->values(['qux' => 100], Insert::VALUES_MERGE);
self::assertEquals(
'INSERT INTO "foo" ("bar", "boo", "bam", "qux") VALUES (\'baz\', NOW(), NULL, \'100\')',
$this->insert->getSqlString(new TrustingSql92Platform())
);
}
/**
* @coversNothing
*/
public function testSpecificationconstantsCouldBeOverridedByExtensionInPrepareStatement()
{
$replace = new Replace();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('REPLACE INTO "foo" ("bar", "boo") VALUES (?, NOW())'));
$replace->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$replace->prepareStatement($mockAdapter, $mockStatement);
// with TableIdentifier
$replace = new Replace();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('REPLACE INTO "sch"."foo" ("bar", "boo") VALUES (?, NOW())'));
$replace->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$replace->prepareStatement($mockAdapter, $mockStatement);
}
/**
* @coversNothing
*/
public function testSpecificationconstantsCouldBeOverridedByExtensionInGetSqlString()
{
$replace = new Replace();
$replace->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'REPLACE INTO "foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$replace->getSqlString(new TrustingSql92Platform())
);
// with TableIdentifier
$replace = new Replace();
$replace->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'REPLACE INTO "sch"."foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$replace->getSqlString(new TrustingSql92Platform())
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/InsertIgnoreTest.php | test/unit/Sql/InsertIgnoreTest.php | <?php
namespace LaminasTest\Db\Sql;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\StatementContainer;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\InsertIgnore;
use Laminas\Db\Sql\Select;
use Laminas\Db\Sql\TableIdentifier;
use LaminasTest\Db\DeprecatedAssertionsTrait;
use LaminasTest\Db\TestAsset\Replace;
use LaminasTest\Db\TestAsset\TrustingSql92Platform;
use PHPUnit\Framework\TestCase;
class InsertIgnoreTest extends TestCase
{
use DeprecatedAssertionsTrait;
/** @var InsertIgnore */
protected $insert;
/**
* Sets up the fixture, for example, opens a network connection.
* This method is called before a test is executed.
*/
protected function setUp(): void
{
$this->insert = new InsertIgnore();
}
public function testInto()
{
$this->insert->into('table');
self::assertEquals('table', $this->insert->getRawState('table'));
$tableIdentifier = new TableIdentifier('table', 'schema');
$this->insert->into($tableIdentifier);
self::assertEquals($tableIdentifier, $this->insert->getRawState('table'));
}
public function testColumns()
{
$columns = ['foo', 'bar'];
$this->insert->columns($columns);
self::assertEquals($columns, $this->insert->getRawState('columns'));
}
public function testValues()
{
$this->insert->values(['foo' => 'bar']);
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bar'], $this->insert->getRawState('values'));
// test will merge cols and values of previously set stuff
$this->insert->values(['foo' => 'bax'], InsertIgnore::VALUES_MERGE);
$this->insert->values(['boom' => 'bam'], InsertIgnore::VALUES_MERGE);
self::assertEquals(['foo', 'boom'], $this->insert->getRawState('columns'));
self::assertEquals(['bax', 'bam'], $this->insert->getRawState('values'));
$this->insert->values(['foo' => 'bax']);
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bax'], $this->insert->getRawState('values'));
}
public function testValuesThrowsExceptionWhenNotArrayOrSelect()
{
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('values() expects an array of values or Laminas\Db\Sql\Select instance');
$this->insert->values(5);
}
public function testValuesThrowsExceptionWhenSelectMergeOverArray()
{
$this->insert->values(['foo' => 'bar']);
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('A Laminas\Db\Sql\Select instance cannot be provided with the merge flag');
$this->insert->values(new Select(), InsertIgnore::VALUES_MERGE);
}
public function testValuesThrowsExceptionWhenArrayMergeOverSelect()
{
$this->insert->values(new Select());
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'An array of values cannot be provided with the merge flag when a Laminas\Db\Sql\Select instance already '
. 'exists as the value source'
);
$this->insert->values(['foo' => 'bar'], InsertIgnore::VALUES_MERGE);
}
/**
* @group Laminas-4926
*/
public function testEmptyArrayValues()
{
$this->insert->values([]);
self::assertEquals([], $this->readAttribute($this->insert, 'columns'));
}
public function testPrepareStatement()
{
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('INSERT IGNORE INTO "foo" ("bar", "boo") VALUES (?, NOW())'));
$this->insert->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$this->insert->prepareStatement($mockAdapter, $mockStatement);
// with TableIdentifier
$this->insert = new InsertIgnore();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('INSERT IGNORE INTO "sch"."foo" ("bar", "boo") VALUES (?, NOW())'));
$this->insert->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$this->insert->prepareStatement($mockAdapter, $mockStatement);
}
public function testPrepareStatementWithSelect()
{
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = new StatementContainer();
$select = new Select('bar');
$this->insert
->into('foo')
->columns(['col1'])
->select($select->where(['x' => 5]))
->prepareStatement($mockAdapter, $mockStatement);
self::assertEquals(
'INSERT IGNORE INTO "foo" ("col1") SELECT "bar".* FROM "bar" WHERE "x" = ?',
$mockStatement->getSql()
);
$parameters = $mockStatement->getParameterContainer()->getNamedArray();
self::assertSame(['subselect1where1' => 5], $parameters);
}
public function testGetSqlString()
{
$this->insert->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'INSERT IGNORE INTO "foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$this->insert->getSqlString(new TrustingSql92Platform())
);
// with TableIdentifier
$this->insert = new InsertIgnore();
$this->insert->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'INSERT IGNORE INTO "sch"."foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$this->insert->getSqlString(new TrustingSql92Platform())
);
// with Select
$this->insert = new InsertIgnore();
$select = new Select();
$this->insert->into('foo')->select($select->from('bar'));
self::assertEquals(
'INSERT IGNORE INTO "foo" SELECT "bar".* FROM "bar"',
$this->insert->getSqlString(new TrustingSql92Platform())
);
// with Select and columns
$this->insert->columns(['col1', 'col2']);
self::assertEquals(
'INSERT IGNORE INTO "foo" ("col1", "col2") SELECT "bar".* FROM "bar"',
$this->insert->getSqlString(new TrustingSql92Platform())
);
}
public function testGetSqlStringUsingColumnsAndValuesMethods()
{
// With columns() and values()
$this->insert
->into('foo')
->columns(['col1', 'col2', 'col3'])
->values(['val1', 'val2', 'val3']);
self::assertEquals(
'INSERT IGNORE INTO "foo" ("col1", "col2", "col3") VALUES (\'val1\', \'val2\', \'val3\')',
$this->insert->getSqlString(new TrustingSql92Platform())
);
}
// @codingStandardsIgnoreStart
public function test__set()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bar'], $this->insert->getRawState('values'));
}
// @codingStandardsIgnoreStart
public function test__unset()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals(['bar'], $this->insert->getRawState('values'));
unset($this->insert->foo);
self::assertEquals([], $this->insert->getRawState('columns'));
self::assertEquals([], $this->insert->getRawState('values'));
$this->insert->foo = null;
self::assertEquals(['foo'], $this->insert->getRawState('columns'));
self::assertEquals([null], $this->insert->getRawState('values'));
unset($this->insert->foo);
self::assertEquals([], $this->insert->getRawState('columns'));
self::assertEquals([], $this->insert->getRawState('values'));
}
// @codingStandardsIgnoreStart
public function test__isset()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertTrue(isset($this->insert->foo));
$this->insert->foo = null;
self::assertTrue(isset($this->insert->foo));
}
// @codingStandardsIgnoreStart
public function test__get()
{
// @codingStandardsIgnoreEnd
$this->insert->foo = 'bar';
self::assertEquals('bar', $this->insert->foo);
$this->insert->foo = null;
self::assertNull($this->insert->foo);
}
/**
* @group Laminas-536
*/
public function testValuesMerge()
{
$this->insert->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
$this->insert->into('foo')
->values(['qux' => 100], InsertIgnore::VALUES_MERGE);
self::assertEquals(
'INSERT IGNORE INTO "foo" ("bar", "boo", "bam", "qux") VALUES (\'baz\', NOW(), NULL, \'100\')',
$this->insert->getSqlString(new TrustingSql92Platform())
);
}
public function testSpecificationconstantsCouldBeOverridedByExtensionInPrepareStatement()
{
$replace = new Replace();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('REPLACE INTO "foo" ("bar", "boo") VALUES (?, NOW())'));
$replace->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$replace->prepareStatement($mockAdapter, $mockStatement);
// with TableIdentifier
$replace = new Replace();
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('getPrepareType')->will($this->returnValue('positional'));
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$pContainer = new ParameterContainer([]);
$mockStatement->expects($this->any())->method('getParameterContainer')->will($this->returnValue($pContainer));
$mockStatement->expects($this->at(1))
->method('setSql')
->with($this->equalTo('REPLACE INTO "sch"."foo" ("bar", "boo") VALUES (?, NOW())'));
$replace->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()')]);
$replace->prepareStatement($mockAdapter, $mockStatement);
}
public function testSpecificationconstantsCouldBeOverridedByExtensionInGetSqlString()
{
$replace = new Replace();
$replace->into('foo')
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'REPLACE INTO "foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$replace->getSqlString(new TrustingSql92Platform())
);
// with TableIdentifier
$replace = new Replace();
$replace->into(new TableIdentifier('foo', 'sch'))
->values(['bar' => 'baz', 'boo' => new Expression('NOW()'), 'bam' => null]);
self::assertEquals(
'REPLACE INTO "sch"."foo" ("bar", "boo", "bam") VALUES (\'baz\', NOW(), NULL)',
$replace->getSqlString(new TrustingSql92Platform())
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/CombineTest.php | test/unit/Sql/CombineTest.php | <?php
namespace LaminasTest\Db\Sql;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\StatementContainer;
use Laminas\Db\Adapter\StatementContainerInterface;
use Laminas\Db\Sql\Combine;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\Predicate\Expression;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
class CombineTest extends TestCase
{
/** @var Combine */
protected $combine;
/**
* Sets up the fixture, for example, opens a network connection.
* This method is called before a test is executed.
*/
protected function setUp(): void
{
$this->combine = new Combine();
}
public function testRejectsInvalidStatement()
{
$this->expectException(InvalidArgumentException::class);
$this->combine->combine('foo');
}
public function testGetSqlString()
{
$this->combine
->union(new Select('t1'))
->intersect(new Select('t2'))
->except(new Select('t3'))
->union(new Select('t4'));
self::assertEquals(
// @codingStandardsIgnoreStart
'(SELECT "t1".* FROM "t1") INTERSECT (SELECT "t2".* FROM "t2") EXCEPT (SELECT "t3".* FROM "t3") UNION (SELECT "t4".* FROM "t4")',
// @codingStandardsIgnoreEnd
$this->combine->getSqlString()
);
}
public function testGetSqlStringWithModifier()
{
$this->combine
->union(new Select('t1'))
->union(new Select('t2'), 'ALL');
self::assertEquals(
'(SELECT "t1".* FROM "t1") UNION ALL (SELECT "t2".* FROM "t2")',
$this->combine->getSqlString()
);
}
public function testGetSqlStringFromArray()
{
$this->combine->combine([
[new Select('t1')],
[new Select('t2'), Combine::COMBINE_INTERSECT, 'ALL'],
[new Select('t3'), Combine::COMBINE_EXCEPT],
]);
self::assertEquals(
'(SELECT "t1".* FROM "t1") INTERSECT ALL (SELECT "t2".* FROM "t2") EXCEPT (SELECT "t3".* FROM "t3")',
$this->combine->getSqlString()
);
$this->combine = new Combine();
$this->combine->combine([
new Select('t1'),
new Select('t2'),
new Select('t3'),
]);
self::assertEquals(
'(SELECT "t1".* FROM "t1") UNION (SELECT "t2".* FROM "t2") UNION (SELECT "t3".* FROM "t3")',
$this->combine->getSqlString()
);
}
public function testGetSqlStringEmpty()
{
self::assertNull($this->combine->getSqlString());
}
public function testPrepareStatementWithModifier()
{
$select1 = new Select('t1');
$select1->where(['x1' => 10]);
$select2 = new Select('t2');
$select2->where(['x2' => 20]);
$this->combine->combine([
$select1,
$select2,
]);
$adapter = $this->getMockAdapter();
$statement = $this->combine->prepareStatement($adapter, new StatementContainer());
self::assertInstanceOf(StatementContainerInterface::class, $statement);
self::assertEquals(
'(SELECT "t1".* FROM "t1" WHERE "x1" = ?) UNION (SELECT "t2".* FROM "t2" WHERE "x2" = ?)',
$statement->getSql()
);
}
public function testAlignColumns()
{
$select1 = new Select('t1');
$select1->columns([
'c0' => 'c0',
'c1' => 'c1',
]);
$select2 = new Select('t2');
$select2->columns([
'c1' => 'c1',
'c2' => 'c2',
]);
$this->combine
->union([$select1, $select2])
->alignColumns();
self::assertEquals(
[
'c0' => 'c0',
'c1' => 'c1',
'c2' => new Expression('NULL'),
],
$select1->getRawState('columns')
);
self::assertEquals(
[
'c0' => new Expression('NULL'),
'c1' => 'c1',
'c2' => 'c2',
],
$select2->getRawState('columns')
);
}
public function testGetRawState()
{
$select = new Select('t1');
$this->combine->combine($select);
self::assertSame(
[
'combine' => [
[
'select' => $select,
'type' => Combine::COMBINE_UNION,
'modifier' => '',
],
],
'columns' => [
'0' => '*',
],
],
$this->combine->getRawState()
);
}
/**
* @return MockObject|Adapter
*/
protected function getMockAdapter()
{
$parameterContainer = new ParameterContainer();
$mockStatement = $this->getMockBuilder(StatementInterface::class)->getMock();
$mockStatement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$setGetSqlFunction = function ($sql = null) use ($mockStatement) {
static $sqlValue;
if ($sql) {
$sqlValue = $sql;
return $mockStatement;
}
return $sqlValue;
};
$mockStatement->expects($this->any())->method('setSql')->will($this->returnCallback($setGetSqlFunction));
$mockStatement->expects($this->any())->method('getSql')->will($this->returnCallback($setGetSqlFunction));
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockDriver->expects($this->any())->method('createStatement')->will($this->returnValue($mockStatement));
return $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([$mockDriver])
->getMock();
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/DropTableTest.php | test/unit/Sql/Ddl/DropTableTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl;
use Laminas\Db\Sql\Ddl\DropTable;
use Laminas\Db\Sql\TableIdentifier;
use PHPUnit\Framework\TestCase;
class DropTableTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\DropTable::getSqlString
*/
public function testGetSqlString()
{
$dt = new DropTable('foo');
self::assertEquals('DROP TABLE "foo"', $dt->getSqlString());
$dt = new DropTable(new TableIdentifier('foo'));
self::assertEquals('DROP TABLE "foo"', $dt->getSqlString());
$dt = new DropTable(new TableIdentifier('bar', 'foo'));
self::assertEquals('DROP TABLE "foo"."bar"', $dt->getSqlString());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/CreateTableTest.php | test/unit/Sql/Ddl/CreateTableTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl;
use Laminas\Db\Sql\Ddl\Column\Column;
use Laminas\Db\Sql\Ddl\Column\ColumnInterface;
use Laminas\Db\Sql\Ddl\Constraint;
use Laminas\Db\Sql\Ddl\Constraint\ConstraintInterface;
use Laminas\Db\Sql\Ddl\CreateTable;
use Laminas\Db\Sql\TableIdentifier;
use PHPUnit\Framework\TestCase;
use function array_pop;
class CreateTableTest extends TestCase
{
/**
* test object construction
*
* @covers \Laminas\Db\Sql\Ddl\CreateTable::__construct
*/
public function testObjectConstruction()
{
$ct = new CreateTable('foo', true);
self::assertEquals('foo', $ct->getRawState($ct::TABLE));
self::assertTrue($ct->isTemporary());
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::setTemporary
*/
public function testSetTemporary()
{
$ct = new CreateTable();
self::assertSame($ct, $ct->setTemporary(false));
self::assertFalse($ct->isTemporary());
$ct->setTemporary(true);
self::assertTrue($ct->isTemporary());
$ct->setTemporary('yes');
self::assertTrue($ct->isTemporary());
self::assertStringStartsWith("CREATE TEMPORARY TABLE", $ct->getSqlString());
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::isTemporary
*/
public function testIsTemporary()
{
$ct = new CreateTable();
self::assertFalse($ct->isTemporary());
$ct->setTemporary(true);
self::assertTrue($ct->isTemporary());
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::setTable
*/
public function testSetTable(): CreateTable
{
$ct = new CreateTable();
self::assertEquals('', $ct->getRawState('table'));
$ct->setTable('test');
return $ct;
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::getRawState
* @depends testSetTable
*/
public function testRawStateViaTable(CreateTable $ct)
{
self::assertEquals('test', $ct->getRawState('table'));
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::addColumn
*/
public function testAddColumn(): CreateTable
{
$column = $this->getMockBuilder(ColumnInterface::class)->getMock();
$ct = new CreateTable();
self::assertSame($ct, $ct->addColumn($column));
return $ct;
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::getRawState
* @depends testAddColumn
*/
public function testRawStateViaColumn(CreateTable $ct)
{
$state = $ct->getRawState('columns');
self::assertIsArray($state);
$column = array_pop($state);
self::assertInstanceOf(ColumnInterface::class, $column);
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::addConstraint
*/
public function testAddConstraint(): CreateTable
{
$constraint = $this->getMockBuilder(ConstraintInterface::class)->getMock();
$ct = new CreateTable();
self::assertSame($ct, $ct->addConstraint($constraint));
return $ct;
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::getRawState
* @depends testAddConstraint
*/
public function testRawStateViaConstraint(CreateTable $ct)
{
$state = $ct->getRawState('constraints');
self::assertIsArray($state);
$constraint = array_pop($state);
self::assertInstanceOf(ConstraintInterface::class, $constraint);
}
/**
* @covers \Laminas\Db\Sql\Ddl\CreateTable::getSqlString
*/
public function testGetSqlString()
{
$ct = new CreateTable('foo');
self::assertEquals("CREATE TABLE \"foo\" ( \n)", $ct->getSqlString());
$ct = new CreateTable('foo', true);
self::assertEquals("CREATE TEMPORARY TABLE \"foo\" ( \n)", $ct->getSqlString());
$ct = new CreateTable('foo');
$ct->addColumn(new Column('bar'));
self::assertEquals("CREATE TABLE \"foo\" ( \n \"bar\" INTEGER NOT NULL \n)", $ct->getSqlString());
$ct = new CreateTable('foo', true);
$ct->addColumn(new Column('bar'));
self::assertEquals("CREATE TEMPORARY TABLE \"foo\" ( \n \"bar\" INTEGER NOT NULL \n)", $ct->getSqlString());
$ct = new CreateTable('foo', true);
$ct->addColumn(new Column('bar'));
$ct->addColumn(new Column('baz'));
self::assertEquals(
"CREATE TEMPORARY TABLE \"foo\" ( \n \"bar\" INTEGER NOT NULL,\n \"baz\" INTEGER NOT NULL \n)",
$ct->getSqlString()
);
$ct = new CreateTable('foo');
$ct->addColumn(new Column('bar'));
$ct->addConstraint(new Constraint\PrimaryKey('bat'));
self::assertEquals(
"CREATE TABLE \"foo\" ( \n \"bar\" INTEGER NOT NULL , \n PRIMARY KEY (\"bat\") \n)",
$ct->getSqlString()
);
$ct = new CreateTable('foo');
$ct->addConstraint(new Constraint\PrimaryKey('bar'));
$ct->addConstraint(new Constraint\PrimaryKey('bat'));
self::assertEquals(
"CREATE TABLE \"foo\" ( \n PRIMARY KEY (\"bar\"),\n PRIMARY KEY (\"bat\") \n)",
$ct->getSqlString()
);
$ct = new CreateTable(new TableIdentifier('foo'));
$ct->addColumn(new Column('bar'));
self::assertEquals("CREATE TABLE \"foo\" ( \n \"bar\" INTEGER NOT NULL \n)", $ct->getSqlString());
$ct = new CreateTable(new TableIdentifier('bar', 'foo'));
$ct->addColumn(new Column('baz'));
self::assertEquals("CREATE TABLE \"foo\".\"bar\" ( \n \"baz\" INTEGER NOT NULL \n)", $ct->getSqlString());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/AlterTableTest.php | test/unit/Sql/Ddl/AlterTableTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl;
use Laminas\Db\Sql\Ddl\AlterTable;
use Laminas\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\ColumnInterface;
use Laminas\Db\Sql\Ddl\Constraint;
use Laminas\Db\Sql\Ddl\Constraint\ConstraintInterface;
use Laminas\Db\Sql\TableIdentifier;
use PHPUnit\Framework\TestCase;
use function str_replace;
class AlterTableTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::setTable
*/
public function testSetTable()
{
$at = new AlterTable();
self::assertEquals('', $at->getRawState('table'));
self::assertSame($at, $at->setTable('test'));
self::assertEquals('test', $at->getRawState('table'));
}
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::addColumn
*/
public function testAddColumn()
{
$at = new AlterTable();
/** @var ColumnInterface $colMock */
$colMock = $this->getMockBuilder(ColumnInterface::class)->getMock();
self::assertSame($at, $at->addColumn($colMock));
self::assertEquals([$colMock], $at->getRawState($at::ADD_COLUMNS));
}
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::changeColumn
*/
public function testChangeColumn()
{
$at = new AlterTable();
/** @var ColumnInterface $colMock */
$colMock = $this->getMockBuilder(ColumnInterface::class)->getMock();
self::assertSame($at, $at->changeColumn('newname', $colMock));
self::assertEquals(['newname' => $colMock], $at->getRawState($at::CHANGE_COLUMNS));
}
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::dropColumn
*/
public function testDropColumn()
{
$at = new AlterTable();
self::assertSame($at, $at->dropColumn('foo'));
self::assertEquals(['foo'], $at->getRawState($at::DROP_COLUMNS));
}
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::dropConstraint
*/
public function testDropConstraint()
{
$at = new AlterTable();
self::assertSame($at, $at->dropConstraint('foo'));
self::assertEquals(['foo'], $at->getRawState($at::DROP_CONSTRAINTS));
}
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::addConstraint
*/
public function testAddConstraint()
{
$at = new AlterTable();
/** @var ConstraintInterface $conMock */
$conMock = $this->getMockBuilder(ConstraintInterface::class)->getMock();
self::assertSame($at, $at->addConstraint($conMock));
self::assertEquals([$conMock], $at->getRawState($at::ADD_CONSTRAINTS));
}
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::dropIndex
*/
public function testDropIndex()
{
$at = new AlterTable();
self::assertSame($at, $at->dropIndex('foo'));
self::assertEquals(['foo'], $at->getRawState($at::DROP_INDEXES));
}
/**
* @covers \Laminas\Db\Sql\Ddl\AlterTable::getSqlString
* @todo Implement testGetSqlString().
*/
public function testGetSqlString()
{
$at = new AlterTable('foo');
$at->addColumn(new Column\Varchar('another', 255));
$at->changeColumn('name', new Column\Varchar('new_name', 50));
$at->dropColumn('foo');
$at->addConstraint(new Constraint\ForeignKey('my_fk', 'other_id', 'other_table', 'id', 'CASCADE', 'CASCADE'));
$at->dropConstraint('my_constraint');
$at->dropIndex('my_index');
$expected = <<<EOS
ALTER TABLE "foo"
ADD COLUMN "another" VARCHAR(255) NOT NULL,
CHANGE COLUMN "name" "new_name" VARCHAR(50) NOT NULL,
DROP COLUMN "foo",
ADD CONSTRAINT "my_fk" FOREIGN KEY ("other_id") REFERENCES "other_table" ("id") ON DELETE CASCADE ON UPDATE CASCADE,
DROP CONSTRAINT "my_constraint",
DROP INDEX "my_index"
EOS;
$actual = $at->getSqlString();
self::assertEquals(
str_replace(["\r", "\n"], "", $expected),
str_replace(["\r", "\n"], "", $actual)
);
$at = new AlterTable(new TableIdentifier('foo'));
$at->addColumn(new Column\Column('bar'));
$this->assertEquals("ALTER TABLE \"foo\"\n ADD COLUMN \"bar\" INTEGER NOT NULL", $at->getSqlString());
$at = new AlterTable(new TableIdentifier('bar', 'foo'));
$at->addColumn(new Column\Column('baz'));
$this->assertEquals("ALTER TABLE \"foo\".\"bar\"\n ADD COLUMN \"baz\" INTEGER NOT NULL", $at->getSqlString());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/ColumnTest.php | test/unit/Sql/Ddl/Column/ColumnTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Column;
use PHPUnit\Framework\TestCase;
class ColumnTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::setName
*/
public function testSetName(): Column
{
$column = new Column();
self::assertSame($column, $column->setName('foo'));
return $column;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::getName
* @depends testSetName
*/
public function testGetName(Column $column)
{
self::assertEquals('foo', $column->getName());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::setNullable
*/
public function testSetNullable(): Column
{
$column = new Column();
self::assertSame($column, $column->setNullable(true));
return $column;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::isNullable
* @depends testSetNullable
*/
public function testIsNullable(Column $column)
{
self::assertTrue($column->isNullable());
$column->setNullable(false);
self::assertFalse($column->isNullable());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::setDefault
*/
public function testSetDefault(): Column
{
$column = new Column();
self::assertSame($column, $column->setDefault('foo bar'));
return $column;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::getDefault
* @depends testSetDefault
*/
public function testGetDefault(Column $column)
{
self::assertEquals('foo bar', $column->getDefault());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::setOptions
*/
public function testSetOptions(): Column
{
$column = new Column();
self::assertSame($column, $column->setOptions(['autoincrement' => true]));
return $column;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::setOption
*/
public function testSetOption()
{
$column = new Column();
self::assertSame($column, $column->setOption('primary', true));
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::getOptions
* @depends testSetOptions
*/
public function testGetOptions(Column $column)
{
self::assertEquals(['autoincrement' => true], $column->getOptions());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Column();
$column->setName('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'INTEGER'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
$column->setNullable(true);
self::assertEquals(
[['%s %s', ['foo', 'INTEGER'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
$column->setDefault('bar');
self::assertEquals(
[
[
'%s %s DEFAULT %s',
['foo', 'INTEGER', 'bar'],
[$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL, $column::TYPE_VALUE],
],
],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/TimestampTest.php | test/unit/Sql/Ddl/Column/TimestampTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Timestamp;
use PHPUnit\Framework\TestCase;
class TimestampTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Timestamp::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Timestamp('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'TIMESTAMP'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/BlobTest.php | test/unit/Sql/Ddl/Column/BlobTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Blob;
use PHPUnit\Framework\TestCase;
class BlobTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Blob::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Blob('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'BLOB'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/FloatingTest.php | test/unit/Sql/Ddl/Column/FloatingTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Floating;
use PHPUnit\Framework\TestCase;
class FloatingTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Floating::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Floating('foo', 10, 5);
self::assertEquals(
[
[
'%s %s NOT NULL',
['foo', 'FLOAT(10,5)'],
[$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL],
],
],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/AbstractPrecisionColumnTest.php | test/unit/Sql/Ddl/Column/AbstractPrecisionColumnTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\AbstractPrecisionColumn;
use PHPUnit\Framework\TestCase;
class AbstractPrecisionColumnTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractPrecisionColumn::setDigits
*/
public function testSetDigits()
{
$column = $this->getMockForAbstractClass(AbstractPrecisionColumn::class, ['foo', 10]);
self::assertEquals(10, $column->getDigits());
self::assertSame($column, $column->setDigits(12));
self::assertEquals(12, $column->getDigits());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractPrecisionColumn::getDigits
*/
public function testGetDigits()
{
$column = $this->getMockForAbstractClass(AbstractPrecisionColumn::class, ['foo', 10]);
self::assertEquals(10, $column->getDigits());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractPrecisionColumn::setDecimal
*/
public function testSetDecimal()
{
$column = $this->getMockForAbstractClass(AbstractPrecisionColumn::class, ['foo', 10, 5]);
self::assertEquals(5, $column->getDecimal());
self::assertSame($column, $column->setDecimal(2));
self::assertEquals(2, $column->getDecimal());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractPrecisionColumn::getDecimal
*/
public function testGetDecimal()
{
$column = $this->getMockForAbstractClass(AbstractPrecisionColumn::class, ['foo', 10, 5]);
self::assertEquals(5, $column->getDecimal());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractPrecisionColumn::getExpressionData
*/
public function testGetExpressionData()
{
$column = $this->getMockForAbstractClass(AbstractPrecisionColumn::class, ['foo', 10, 5]);
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'INTEGER(10,5)'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/BigIntegerTest.php | test/unit/Sql/Ddl/Column/BigIntegerTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\BigInteger;
use PHPUnit\Framework\TestCase;
class BigIntegerTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\BigInteger::__construct
*/
public function testObjectConstruction()
{
$integer = new BigInteger('foo');
self::assertEquals('foo', $integer->getName());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::getExpressionData
*/
public function testGetExpressionData()
{
$column = new BigInteger('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'BIGINT'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/DateTest.php | test/unit/Sql/Ddl/Column/DateTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Date;
use PHPUnit\Framework\TestCase;
class DateTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Date::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Date('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'DATE'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/BinaryTest.php | test/unit/Sql/Ddl/Column/BinaryTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Binary;
use PHPUnit\Framework\TestCase;
class BinaryTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Binary::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Binary('foo', 10000000);
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'BINARY(10000000)'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/AbstractLengthColumnTest.php | test/unit/Sql/Ddl/Column/AbstractLengthColumnTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\AbstractLengthColumn;
use PHPUnit\Framework\TestCase;
class AbstractLengthColumnTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractLengthColumn::setLength
*/
public function testSetLength()
{
$column = $this->getMockForAbstractClass(AbstractLengthColumn::class, ['foo', 55]);
self::assertEquals(55, $column->getLength());
self::assertSame($column, $column->setLength(20));
self::assertEquals(20, $column->getLength());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractLengthColumn::getLength
*/
public function testGetLength()
{
$column = $this->getMockForAbstractClass(AbstractLengthColumn::class, ['foo', 55]);
self::assertEquals(55, $column->getLength());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\AbstractLengthColumn::getExpressionData
*/
public function testGetExpressionData()
{
$column = $this->getMockForAbstractClass(AbstractLengthColumn::class, ['foo', 4]);
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'INTEGER(4)'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/VarbinaryTest.php | test/unit/Sql/Ddl/Column/VarbinaryTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Varbinary;
use PHPUnit\Framework\TestCase;
class VarbinaryTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Varbinary::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Varbinary('foo', 20);
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'VARBINARY(20)'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/DatetimeTest.php | test/unit/Sql/Ddl/Column/DatetimeTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Datetime;
use PHPUnit\Framework\TestCase;
class DatetimeTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Datetime::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Datetime('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'DATETIME'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/CharTest.php | test/unit/Sql/Ddl/Column/CharTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Char;
use PHPUnit\Framework\TestCase;
class CharTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Char::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Char('foo', 20);
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'CHAR(20)'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/DecimalTest.php | test/unit/Sql/Ddl/Column/DecimalTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Decimal;
use PHPUnit\Framework\TestCase;
class DecimalTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Decimal::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Decimal('foo', 10, 5);
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'DECIMAL(10,5)'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/IntegerTest.php | test/unit/Sql/Ddl/Column/IntegerTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Integer;
use Laminas\Db\Sql\Ddl\Constraint\PrimaryKey;
use PHPUnit\Framework\TestCase;
class IntegerTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Integer::__construct
*/
public function testObjectConstruction()
{
$integer = new Integer('foo');
self::assertEquals('foo', $integer->getName());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Column::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Integer('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'INTEGER'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
$column = new Integer('foo');
$column->addConstraint(new PrimaryKey());
self::assertEquals(
[
['%s %s NOT NULL', ['foo', 'INTEGER'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]],
' ',
['PRIMARY KEY', [], []],
],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/VarcharTest.php | test/unit/Sql/Ddl/Column/VarcharTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Varchar;
use PHPUnit\Framework\TestCase;
class VarcharTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Varchar::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Varchar('foo', 20);
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'VARCHAR(20)'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
$column->setDefault('bar');
self::assertEquals(
[
[
'%s %s NOT NULL DEFAULT %s',
['foo', 'VARCHAR(20)', 'bar'],
[$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL, $column::TYPE_VALUE],
],
],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/TextTest.php | test/unit/Sql/Ddl/Column/TextTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Text;
use PHPUnit\Framework\TestCase;
class TextTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Text::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Text('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'TEXT'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/BooleanTest.php | test/unit/Sql/Ddl/Column/BooleanTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Boolean;
use PHPUnit\Framework\TestCase;
class BooleanTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Boolean::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Boolean('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'BOOLEAN'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Boolean
* @group 6257
*/
public function testIsAlwaysNotNullable()
{
$column = new Boolean('foo', true);
self::assertFalse($column->isNullable());
$column->setNullable(true);
self::assertFalse($column->isNullable());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Column/TimeTest.php | test/unit/Sql/Ddl/Column/TimeTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Column;
use Laminas\Db\Sql\Ddl\Column\Time;
use PHPUnit\Framework\TestCase;
class TimeTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Column\Time::getExpressionData
*/
public function testGetExpressionData()
{
$column = new Time('foo');
self::assertEquals(
[['%s %s NOT NULL', ['foo', 'TIME'], [$column::TYPE_IDENTIFIER, $column::TYPE_LITERAL]]],
$column->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Index/IndexTest.php | test/unit/Sql/Ddl/Index/IndexTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Index;
use Laminas\Db\Sql\Ddl\Index\Index;
use PHPUnit\Framework\TestCase;
class IndexTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Index\Index::getExpressionData
*/
public function testGetExpressionData()
{
$uk = new Index('foo', 'my_uk');
self::assertEquals(
[
[
'INDEX %s(%s)',
['my_uk', 'foo'],
[$uk::TYPE_IDENTIFIER, $uk::TYPE_IDENTIFIER],
],
],
$uk->getExpressionData()
);
}
/**
* @covers \Laminas\Db\Sql\Ddl\Index\Index::getExpressionData
*/
public function testGetExpressionDataWithLength()
{
$key = new Index(['foo', 'bar'], 'my_uk', [10, 5]);
self::assertEquals(
[
[
'INDEX %s(%s(10), %s(5))',
['my_uk', 'foo', 'bar'],
[$key::TYPE_IDENTIFIER, $key::TYPE_IDENTIFIER, $key::TYPE_IDENTIFIER],
],
],
$key->getExpressionData()
);
}
/**
* @covers \Laminas\Db\Sql\Ddl\Index\Index::getExpressionData
*/
public function testGetExpressionDataWithLengthUnmatched()
{
$key = new Index(['foo', 'bar'], 'my_uk', [10]);
self::assertEquals(
[
[
'INDEX %s(%s(10), %s)',
['my_uk', 'foo', 'bar'],
[$key::TYPE_IDENTIFIER, $key::TYPE_IDENTIFIER, $key::TYPE_IDENTIFIER],
],
],
$key->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Constraint/ForeignKeyTest.php | test/unit/Sql/Ddl/Constraint/ForeignKeyTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Constraint;
use Laminas\Db\Sql\Ddl\Constraint\ForeignKey;
use PHPUnit\Framework\TestCase;
class ForeignKeyTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::setName
*/
public function testSetName(): ForeignKey
{
$fk = new ForeignKey('foo', 'bar', 'baz', 'bam');
self::assertSame($fk, $fk->setName('xxxx'));
return $fk;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::getName
* @depends testSetName
*/
public function testGetName(ForeignKey $fk)
{
self::assertEquals('xxxx', $fk->getName());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::setReferenceTable
*/
public function testSetReferenceTable(): ForeignKey
{
$fk = new ForeignKey('foo', 'bar', 'baz', 'bam');
self::assertSame($fk, $fk->setReferenceTable('xxxx'));
return $fk;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::getReferenceTable
* @depends testSetReferenceTable
*/
public function testGetReferenceTable(ForeignKey $fk)
{
self::assertEquals('xxxx', $fk->getReferenceTable());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::setReferenceColumn
*/
public function testSetReferenceColumn(): ForeignKey
{
$fk = new ForeignKey('foo', 'bar', 'baz', 'bam');
self::assertSame($fk, $fk->setReferenceColumn('xxxx'));
return $fk;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::getReferenceColumn
* @depends testSetReferenceColumn
*/
public function testGetReferenceColumn(ForeignKey $fk)
{
self::assertEquals(['xxxx'], $fk->getReferenceColumn());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::setOnDeleteRule
*/
public function testSetOnDeleteRule(): ForeignKey
{
$fk = new ForeignKey('foo', 'bar', 'baz', 'bam');
self::assertSame($fk, $fk->setOnDeleteRule('CASCADE'));
return $fk;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::getOnDeleteRule
* @depends testSetOnDeleteRule
*/
public function testGetOnDeleteRule(ForeignKey $fk)
{
self::assertEquals('CASCADE', $fk->getOnDeleteRule());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::setOnUpdateRule
*/
public function testSetOnUpdateRule(): ForeignKey
{
$fk = new ForeignKey('foo', 'bar', 'baz', 'bam');
self::assertSame($fk, $fk->setOnUpdateRule('CASCADE'));
return $fk;
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::getOnUpdateRule
* @depends testSetOnUpdateRule
*/
public function testGetOnUpdateRule(ForeignKey $fk)
{
self::assertEquals('CASCADE', $fk->getOnUpdateRule());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\ForeignKey::getExpressionData
*/
public function testGetExpressionData()
{
$fk = new ForeignKey('foo', 'bar', 'baz', 'bam', 'CASCADE', 'SET NULL');
self::assertEquals(
[
[
'CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s) ON DELETE %s ON UPDATE %s',
['foo', 'bar', 'baz', 'bam', 'CASCADE', 'SET NULL'],
[
$fk::TYPE_IDENTIFIER,
$fk::TYPE_IDENTIFIER,
$fk::TYPE_IDENTIFIER,
$fk::TYPE_IDENTIFIER,
$fk::TYPE_LITERAL,
$fk::TYPE_LITERAL,
],
],
],
$fk->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Constraint/AbstractConstraintTest.php | test/unit/Sql/Ddl/Constraint/AbstractConstraintTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Constraint;
use Laminas\Db\Sql\Ddl\Constraint\AbstractConstraint;
use PHPUnit\Framework\TestCase;
class AbstractConstraintTest extends TestCase
{
/** @var AbstractConstraint */
protected $ac;
protected function setUp(): void
{
$this->ac = $this->getMockForAbstractClass(AbstractConstraint::class);
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\AbstractConstraint::setColumns
*/
public function testSetColumns()
{
self::assertSame($this->ac, $this->ac->setColumns(['foo', 'bar']));
self::assertEquals(['foo', 'bar'], $this->ac->getColumns());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\AbstractConstraint::addColumn
*/
public function testAddColumn()
{
self::assertSame($this->ac, $this->ac->addColumn('foo'));
self::assertEquals(['foo'], $this->ac->getColumns());
}
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\AbstractConstraint::getColumns
*/
public function testGetColumns()
{
$this->ac->setColumns(['foo', 'bar']);
self::assertEquals(['foo', 'bar'], $this->ac->getColumns());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Constraint/CheckTest.php | test/unit/Sql/Ddl/Constraint/CheckTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Constraint;
use Laminas\Db\Sql\Ddl\Constraint\Check;
use PHPUnit\Framework\TestCase;
class CheckTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\Check::getExpressionData
*/
public function testGetExpressionData()
{
$check = new Check('id>0', 'foo');
self::assertEquals(
[
[
'CONSTRAINT %s CHECK (%s)',
['foo', 'id>0'],
[$check::TYPE_IDENTIFIER, $check::TYPE_LITERAL],
],
],
$check->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Constraint/UniqueKeyTest.php | test/unit/Sql/Ddl/Constraint/UniqueKeyTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Constraint;
use Laminas\Db\Sql\Ddl\Constraint\UniqueKey;
use PHPUnit\Framework\TestCase;
class UniqueKeyTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\UniqueKey::getExpressionData
*/
public function testGetExpressionData()
{
$uk = new UniqueKey('foo', 'my_uk');
self::assertEquals(
[
[
'CONSTRAINT %s UNIQUE (%s)',
['my_uk', 'foo'],
[$uk::TYPE_IDENTIFIER, $uk::TYPE_IDENTIFIER],
],
],
$uk->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Ddl/Constraint/PrimaryKeyTest.php | test/unit/Sql/Ddl/Constraint/PrimaryKeyTest.php | <?php
namespace LaminasTest\Db\Sql\Ddl\Constraint;
use Laminas\Db\Sql\Ddl\Constraint\PrimaryKey;
use PHPUnit\Framework\TestCase;
class PrimaryKeyTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Ddl\Constraint\PrimaryKey::getExpressionData
*/
public function testGetExpressionData()
{
$pk = new PrimaryKey('foo');
self::assertEquals(
[
[
'PRIMARY KEY (%s)',
['foo'],
[$pk::TYPE_IDENTIFIER],
],
],
$pk->getExpressionData()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/NotLikeTest.php | test/unit/Sql/Predicate/NotLikeTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\Like;
use Laminas\Db\Sql\Predicate\NotLike;
use PHPUnit\Framework\TestCase;
class NotLikeTest extends TestCase
{
public function testConstructEmptyArgs()
{
$notLike = new NotLike();
self::assertEquals('', $notLike->getIdentifier());
self::assertEquals('', $notLike->getLike());
}
public function testConstructWithArgs()
{
$notLike = new NotLike('bar', 'Foo%');
self::assertEquals('bar', $notLike->getIdentifier());
self::assertEquals('Foo%', $notLike->getLike());
}
public function testAccessorsMutators()
{
$notLike = new NotLike();
$notLike->setIdentifier('bar');
self::assertEquals('bar', $notLike->getIdentifier());
$notLike->setLike('foo%');
self::assertEquals('foo%', $notLike->getLike());
$notLike->setSpecification('target = target');
self::assertEquals('target = target', $notLike->getSpecification());
}
public function testGetExpressionData()
{
$notLike = new NotLike('bar', 'Foo%');
self::assertEquals(
[
[
'%1$s NOT LIKE %2$s',
['bar', 'Foo%'],
[$notLike::TYPE_IDENTIFIER, $notLike::TYPE_VALUE],
],
],
$notLike->getExpressionData()
);
}
public function testInstanceOfPerSetters()
{
$notLike = new NotLike();
self::assertInstanceOf(Like::class, $notLike->setIdentifier('bar'));
self::assertInstanceOf(Like::class, $notLike->setSpecification('%1$s NOT LIKE %2$s'));
self::assertInstanceOf(Like::class, $notLike->setLike('foo%'));
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/IsNullTest.php | test/unit/Sql/Predicate/IsNullTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\IsNotNull;
use PHPUnit\Framework\TestCase;
class IsNullTest extends TestCase
{
public function testEmptyConstructorYieldsNullIdentifier()
{
$isNotNull = new IsNotNull();
self::assertNull($isNotNull->getIdentifier());
}
public function testSpecificationHasSaneDefaultValue()
{
$isNotNull = new IsNotNull();
self::assertEquals('%1$s IS NOT NULL', $isNotNull->getSpecification());
}
public function testCanPassIdentifierToConstructor()
{
$isNotNull = new IsNotNull();
$isnull = new IsNotNull('foo.bar');
self::assertEquals('foo.bar', $isnull->getIdentifier());
}
public function testIdentifierIsMutable()
{
$isNotNull = new IsNotNull();
$isNotNull->setIdentifier('foo.bar');
self::assertEquals('foo.bar', $isNotNull->getIdentifier());
}
public function testSpecificationIsMutable()
{
$isNotNull = new IsNotNull();
$isNotNull->setSpecification('%1$s NOT NULL');
self::assertEquals('%1$s NOT NULL', $isNotNull->getSpecification());
}
public function testRetrievingWherePartsReturnsSpecificationArrayOfIdentifierAndArrayOfTypes()
{
$isNotNull = new IsNotNull();
$isNotNull->setIdentifier('foo.bar');
$expected = [
[
$isNotNull->getSpecification(),
['foo.bar'],
[IsNotNull::TYPE_IDENTIFIER],
],
];
self::assertEquals($expected, $isNotNull->getExpressionData());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/NotInTest.php | test/unit/Sql/Predicate/NotInTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\NotIn;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
class NotInTest extends TestCase
{
public function testRetrievingWherePartsReturnsSpecificationArrayOfIdentifierAndValuesAndArrayOfTypes()
{
$in = new NotIn();
$in->setIdentifier('foo.bar')
->setValueSet([1, 2, 3]);
$expected = [
[
'%s NOT IN (%s, %s, %s)',
['foo.bar', 1, 2, 3],
[NotIn::TYPE_IDENTIFIER, NotIn::TYPE_VALUE, NotIn::TYPE_VALUE, NotIn::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
}
public function testGetExpressionDataWithSubselect()
{
$select = new Select();
$in = new NotIn('foo', $select);
$expected = [
[
'%s NOT IN %s',
['foo', $select],
[$in::TYPE_IDENTIFIER, $in::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
}
public function testGetExpressionDataWithSubselectAndIdentifier()
{
$select = new Select();
$in = new NotIn('foo', $select);
$expected = [
[
'%s NOT IN %s',
['foo', $select],
[$in::TYPE_IDENTIFIER, $in::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
}
public function testGetExpressionDataWithSubselectAndArrayIdentifier()
{
$select = new Select();
$in = new NotIn(['foo', 'bar'], $select);
$expected = [
[
'(%s, %s) NOT IN %s',
['foo', 'bar', $select],
[$in::TYPE_IDENTIFIER, $in::TYPE_IDENTIFIER, $in::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/InTest.php | test/unit/Sql/Predicate/InTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\In;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
class InTest extends TestCase
{
public function testEmptyConstructorYieldsNullIdentifierAndValueSet()
{
$in = new In();
self::assertNull($in->getIdentifier());
self::assertNull($in->getValueSet());
}
public function testCanPassIdentifierAndValueSetToConstructor()
{
$in = new In('foo.bar', [1, 2]);
self::assertEquals('foo.bar', $in->getIdentifier());
self::assertEquals([1, 2], $in->getValueSet());
}
public function testCanPassIdentifierAndEmptyValueSetToConstructor()
{
$in = new In('foo.bar', []);
$this->assertEquals('foo.bar', $in->getIdentifier());
$this->assertEquals([], $in->getValueSet());
}
public function testIdentifierIsMutable()
{
$in = new In();
$in->setIdentifier('foo.bar');
self::assertEquals('foo.bar', $in->getIdentifier());
}
public function testValueSetIsMutable()
{
$in = new In();
$in->setValueSet([1, 2]);
self::assertEquals([1, 2], $in->getValueSet());
}
public function testRetrievingWherePartsReturnsSpecificationArrayOfIdentifierAndValuesAndArrayOfTypes()
{
$in = new In();
$in->setIdentifier('foo.bar')
->setValueSet([1, 2, 3]);
$expected = [
[
'%s IN (%s, %s, %s)',
['foo.bar', 1, 2, 3],
[In::TYPE_IDENTIFIER, In::TYPE_VALUE, In::TYPE_VALUE, In::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
$in->setIdentifier('foo.bar')
->setValueSet([
[1 => In::TYPE_LITERAL],
[2 => In::TYPE_VALUE],
[3 => In::TYPE_LITERAL],
]);
$expected = [
[
'%s IN (%s, %s, %s)',
['foo.bar', 1, 2, 3],
[In::TYPE_IDENTIFIER, In::TYPE_LITERAL, In::TYPE_VALUE, In::TYPE_LITERAL],
],
];
$qqq = $in->getExpressionData();
self::assertEquals($expected, $in->getExpressionData());
}
public function testGetExpressionDataWithSubselect()
{
$select = new Select();
$in = new In('foo', $select);
$expected = [
[
'%s IN %s',
['foo', $select],
[$in::TYPE_IDENTIFIER, $in::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
}
public function testGetExpressionDataWithEmptyValues()
{
$select = new Select();
$in = new In('foo', []);
$expected = [
[
'%s IN (NULL)',
['foo'],
[$in::TYPE_IDENTIFIER],
],
];
$this->assertEquals($expected, $in->getExpressionData());
}
public function testGetExpressionDataWithSubselectAndIdentifier()
{
$select = new Select();
$in = new In('foo', $select);
$expected = [
[
'%s IN %s',
['foo', $select],
[$in::TYPE_IDENTIFIER, $in::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
}
public function testGetExpressionDataWithSubselectAndArrayIdentifier()
{
$select = new Select();
$in = new In(['foo', 'bar'], $select);
$expected = [
[
'(%s, %s) IN %s',
['foo', 'bar', $select],
[$in::TYPE_IDENTIFIER, $in::TYPE_IDENTIFIER, $in::TYPE_VALUE],
],
];
self::assertEquals($expected, $in->getExpressionData());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/PredicateTest.php | test/unit/Sql/Predicate/PredicateTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Adapter\Platform\Sql92;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\Predicate\Predicate;
use Laminas\Db\Sql\Select;
use Laminas\Stdlib\ErrorHandler;
use PHPUnit\Framework\TestCase;
use const E_USER_NOTICE;
class PredicateTest extends TestCase
{
public function testEqualToCreatesOperatorPredicate()
{
$predicate = new Predicate();
$predicate->equalTo('foo.bar', 'bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s = %s', $parts[0]);
self::assertContains(['foo.bar', 'bar'], $parts[0]);
}
public function testNotEqualToCreatesOperatorPredicate()
{
$predicate = new Predicate();
$predicate->notEqualTo('foo.bar', 'bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s != %s', $parts[0]);
self::assertContains(['foo.bar', 'bar'], $parts[0]);
}
public function testLessThanCreatesOperatorPredicate()
{
$predicate = new Predicate();
$predicate->lessThan('foo.bar', 'bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s < %s', $parts[0]);
self::assertContains(['foo.bar', 'bar'], $parts[0]);
}
public function testGreaterThanCreatesOperatorPredicate()
{
$predicate = new Predicate();
$predicate->greaterThan('foo.bar', 'bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s > %s', $parts[0]);
self::assertContains(['foo.bar', 'bar'], $parts[0]);
}
public function testLessThanOrEqualToCreatesOperatorPredicate()
{
$predicate = new Predicate();
$predicate->lessThanOrEqualTo('foo.bar', 'bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s <= %s', $parts[0]);
self::assertContains(['foo.bar', 'bar'], $parts[0]);
}
public function testGreaterThanOrEqualToCreatesOperatorPredicate()
{
$predicate = new Predicate();
$predicate->greaterThanOrEqualTo('foo.bar', 'bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s >= %s', $parts[0]);
self::assertContains(['foo.bar', 'bar'], $parts[0]);
}
public function testLikeCreatesLikePredicate()
{
$predicate = new Predicate();
$predicate->like('foo.bar', 'bar%');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%1$s LIKE %2$s', $parts[0]);
self::assertContains(['foo.bar', 'bar%'], $parts[0]);
}
public function testNotLikeCreatesLikePredicate()
{
$predicate = new Predicate();
$predicate->notLike('foo.bar', 'bar%');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%1$s NOT LIKE %2$s', $parts[0]);
self::assertContains(['foo.bar', 'bar%'], $parts[0]);
}
public function testLiteralCreatesLiteralPredicate()
{
$predicate = new Predicate();
$predicate->literal('foo.bar = ?', 'bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('foo.bar = %s', $parts[0]);
self::assertContains(['bar'], $parts[0]);
}
public function testIsNullCreatesIsNullPredicate()
{
$predicate = new Predicate();
$predicate->isNull('foo.bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%1$s IS NULL', $parts[0]);
self::assertContains(['foo.bar'], $parts[0]);
}
public function testIsNotNullCreatesIsNotNullPredicate()
{
$predicate = new Predicate();
$predicate->isNotNull('foo.bar');
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%1$s IS NOT NULL', $parts[0]);
self::assertContains(['foo.bar'], $parts[0]);
}
public function testInCreatesInPredicate()
{
$predicate = new Predicate();
$predicate->in('foo.bar', ['foo', 'bar']);
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s IN (%s, %s)', $parts[0]);
self::assertContains(['foo.bar', 'foo', 'bar'], $parts[0]);
}
public function testNotInCreatesNotInPredicate()
{
$predicate = new Predicate();
$predicate->notIn('foo.bar', ['foo', 'bar']);
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%s NOT IN (%s, %s)', $parts[0]);
self::assertContains(['foo.bar', 'foo', 'bar'], $parts[0]);
}
public function testBetweenCreatesBetweenPredicate()
{
$predicate = new Predicate();
$predicate->between('foo.bar', 1, 10);
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%1$s BETWEEN %2$s AND %3$s', $parts[0]);
self::assertContains(['foo.bar', 1, 10], $parts[0]);
}
public function testBetweenCreatesNotBetweenPredicate()
{
$predicate = new Predicate();
$predicate->notBetween('foo.bar', 1, 10);
$parts = $predicate->getExpressionData();
self::assertCount(1, $parts);
self::assertContains('%1$s NOT BETWEEN %2$s AND %3$s', $parts[0]);
self::assertContains(['foo.bar', 1, 10], $parts[0]);
}
public function testCanChainPredicateFactoriesBetweenOperators()
{
$predicate = new Predicate();
$predicate->isNull('foo.bar')
->or
->isNotNull('bar.baz')
->and
->equalTo('baz.bat', 'foo');
$parts = $predicate->getExpressionData();
self::assertCount(5, $parts);
self::assertContains('%1$s IS NULL', $parts[0]);
self::assertContains(['foo.bar'], $parts[0]);
self::assertEquals(' OR ', $parts[1]);
self::assertContains('%1$s IS NOT NULL', $parts[2]);
self::assertContains(['bar.baz'], $parts[2]);
self::assertEquals(' AND ', $parts[3]);
self::assertContains('%s = %s', $parts[4]);
self::assertContains(['baz.bat', 'foo'], $parts[4]);
}
public function testCanNestPredicates()
{
$predicate = new Predicate();
$predicate->isNull('foo.bar')
->nest()
->isNotNull('bar.baz')
->and
->equalTo('baz.bat', 'foo')
->unnest();
$parts = $predicate->getExpressionData();
self::assertCount(7, $parts);
self::assertContains('%1$s IS NULL', $parts[0]);
self::assertContains(['foo.bar'], $parts[0]);
self::assertEquals(' AND ', $parts[1]);
self::assertEquals('(', $parts[2]);
self::assertContains('%1$s IS NOT NULL', $parts[3]);
self::assertContains(['bar.baz'], $parts[3]);
self::assertEquals(' AND ', $parts[4]);
self::assertContains('%s = %s', $parts[5]);
self::assertContains(['baz.bat', 'foo'], $parts[5]);
self::assertEquals(')', $parts[6]);
}
/**
* @testdox Unit test: Test expression() is chainable and returns proper values
*/
public function testExpression()
{
$predicate = new Predicate();
// is chainable
self::assertSame($predicate, $predicate->expression('foo = ?', 0));
// with parameter
self::assertEquals(
[['foo = %s', [0], [Expression::TYPE_VALUE]]],
$predicate->getExpressionData()
);
}
/**
* @testdox Unit test: Test expression() allows null $parameters
*/
public function testExpressionNullParameters()
{
$predicate = new Predicate();
$predicate->expression('foo = bar');
$predicates = $predicate->getPredicates();
$expression = $predicates[0][1];
self::assertEquals([], $expression->getParameters());
}
/**
* @testdox Unit test: Test literal() is chainable, returns proper values, and is backwards compatible with 2.0.*
*/
public function testLiteral()
{
$predicate = new Predicate();
// is chainable
self::assertSame($predicate, $predicate->literal('foo = bar'));
// with parameter
self::assertEquals(
[['foo = bar', [], []]],
$predicate->getExpressionData()
);
// test literal() is backwards-compatible, and works with with parameters
$predicate = new Predicate();
$predicate->expression('foo = ?', 'bar');
// with parameter
self::assertEquals(
[['foo = %s', ['bar'], [Expression::TYPE_VALUE]]],
$predicate->getExpressionData()
);
// test literal() is backwards-compatible, and works with with parameters, even 0 which tests as false
$predicate = new Predicate();
$predicate->expression('foo = ?', 0);
// with parameter
self::assertEquals(
[['foo = %s', [0], [Expression::TYPE_VALUE]]],
$predicate->getExpressionData()
);
}
public function testCanCreateExpressionsWithoutAnyBoundSqlParameters(): void
{
$where1 = new Predicate();
$where1->expression('some_expression()');
self::assertSame(
'SELECT "a_table".* FROM "a_table" WHERE (some_expression())',
$this->makeSqlString($where1)
);
}
public function testWillBindSqlParametersToExpressionsWithGivenParameter(): void
{
$where = new Predicate();
$where->expression('some_expression(?)', null);
self::assertSame(
'SELECT "a_table".* FROM "a_table" WHERE (some_expression(\'\'))',
$this->makeSqlString($where)
);
}
public function testWillBindSqlParametersToExpressionsWithGivenStringParameter(): void
{
$where = new Predicate();
$where->expression('some_expression(?)', 'a string');
self::assertSame(
'SELECT "a_table".* FROM "a_table" WHERE (some_expression(\'a string\'))',
$this->makeSqlString($where)
);
}
private function makeSqlString(Predicate $where): string
{
$select = new Select('a_table');
$select->where($where);
// this is still faster than connecting to a real DB for this kind of test.
// we are using unsafe SQL quoting on purpose here: this raises warnings in production.
ErrorHandler::start(E_USER_NOTICE);
try {
$string = $select->getSqlString(new Sql92());
} finally {
ErrorHandler::stop();
}
return $string;
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/BetweenTest.php | test/unit/Sql/Predicate/BetweenTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\Between;
use PHPUnit\Framework\TestCase;
class BetweenTest extends TestCase
{
/** @var Between */
protected $between;
protected function setUp(): void
{
$this->between = new Between();
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::__construct
* @covers \Laminas\Db\Sql\Predicate\Between::getIdentifier
* @covers \Laminas\Db\Sql\Predicate\Between::getMinValue
* @covers \Laminas\Db\Sql\Predicate\Between::getMaxValue
*/
public function testConstructorYieldsNullIdentifierMinimumAndMaximumValues()
{
self::assertNull($this->between->getIdentifier());
self::assertNull($this->between->getMinValue());
self::assertNull($this->between->getMaxValue());
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::__construct
* @covers \Laminas\Db\Sql\Predicate\Between::getIdentifier
* @covers \Laminas\Db\Sql\Predicate\Between::getMinValue
* @covers \Laminas\Db\Sql\Predicate\Between::getMaxValue
*/
public function testConstructorCanPassIdentifierMinimumAndMaximumValues()
{
$between = new Between('foo.bar', 1, 300);
self::assertEquals('foo.bar', $between->getIdentifier());
self::assertSame(1, $between->getMinValue());
self::assertSame(300, $between->getMaxValue());
$between = new Between('foo.bar', 0, 1);
self::assertEquals('foo.bar', $between->getIdentifier());
self::assertSame(0, $between->getMinValue());
self::assertSame(1, $between->getMaxValue());
$between = new Between('foo.bar', -1, 0);
self::assertEquals('foo.bar', $between->getIdentifier());
self::assertSame(-1, $between->getMinValue());
self::assertSame(0, $between->getMaxValue());
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::getSpecification
*/
public function testSpecificationHasSaneDefaultValue()
{
self::assertEquals('%1$s BETWEEN %2$s AND %3$s', $this->between->getSpecification());
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::setIdentifier
* @covers \Laminas\Db\Sql\Predicate\Between::getIdentifier
*/
public function testIdentifierIsMutable()
{
$this->between->setIdentifier('foo.bar');
self::assertEquals('foo.bar', $this->between->getIdentifier());
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::setMinValue
* @covers \Laminas\Db\Sql\Predicate\Between::getMinValue
*/
public function testMinValueIsMutable()
{
$this->between->setMinValue(10);
self::assertEquals(10, $this->between->getMinValue());
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::setMaxValue
* @covers \Laminas\Db\Sql\Predicate\Between::getMaxValue
*/
public function testMaxValueIsMutable()
{
$this->between->setMaxValue(10);
self::assertEquals(10, $this->between->getMaxValue());
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::setSpecification
* @covers \Laminas\Db\Sql\Predicate\Between::getSpecification
*/
public function testSpecificationIsMutable()
{
$this->between->setSpecification('%1$s IS INBETWEEN %2$s AND %3$s');
self::assertEquals('%1$s IS INBETWEEN %2$s AND %3$s', $this->between->getSpecification());
}
/**
* @covers \Laminas\Db\Sql\Predicate\Between::getExpressionData
*/
public function testRetrievingWherePartsReturnsSpecificationArrayOfIdentifierAndValuesAndArrayOfTypes()
{
$this->between->setIdentifier('foo.bar')
->setMinValue(10)
->setMaxValue(19);
$expected = [
[
$this->between->getSpecification(),
['foo.bar', 10, 19],
[Between::TYPE_IDENTIFIER, Between::TYPE_VALUE, Between::TYPE_VALUE],
],
];
self::assertEquals($expected, $this->between->getExpressionData());
$this->between->setIdentifier([10 => Between::TYPE_VALUE])
->setMinValue(['foo.bar' => Between::TYPE_IDENTIFIER])
->setMaxValue(['foo.baz' => Between::TYPE_IDENTIFIER]);
$expected = [
[
$this->between->getSpecification(),
[10, 'foo.bar', 'foo.baz'],
[Between::TYPE_VALUE, Between::TYPE_IDENTIFIER, Between::TYPE_IDENTIFIER],
],
];
self::assertEquals($expected, $this->between->getExpressionData());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/LiteralTest.php | test/unit/Sql/Predicate/LiteralTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\Literal;
use PHPUnit\Framework\TestCase;
class LiteralTest extends TestCase
{
public function testSetLiteral()
{
$literal = new Literal('bar');
self::assertSame($literal, $literal->setLiteral('foo'));
}
public function testGetLiteral()
{
$literal = new Literal('bar');
self::assertEquals('bar', $literal->getLiteral());
}
public function testGetExpressionData()
{
$literal = new Literal('bar');
self::assertEquals([['bar', [], []]], $literal->getExpressionData());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/OperatorTest.php | test/unit/Sql/Predicate/OperatorTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\Operator;
use PHPUnit\Framework\TestCase;
use function var_export;
class OperatorTest extends TestCase
{
public function testEmptyConstructorYieldsNullLeftAndRightValues()
{
$operator = new Operator();
self::assertNull($operator->getLeft());
self::assertNull($operator->getRight());
}
public function testEmptyConstructorYieldsDefaultsForOperatorAndLeftAndRightTypes()
{
$operator = new Operator();
self::assertEquals(Operator::OP_EQ, $operator->getOperator());
self::assertEquals(Operator::TYPE_IDENTIFIER, $operator->getLeftType());
self::assertEquals(Operator::TYPE_VALUE, $operator->getRightType());
}
public function testCanPassAllValuesToConstructor()
{
$operator = new Operator('bar', '>=', 'foo.bar', Operator::TYPE_VALUE, Operator::TYPE_IDENTIFIER);
self::assertEquals(Operator::OP_GTE, $operator->getOperator());
self::assertEquals('bar', $operator->getLeft());
self::assertEquals('foo.bar', $operator->getRight());
self::assertEquals(Operator::TYPE_VALUE, $operator->getLeftType());
self::assertEquals(Operator::TYPE_IDENTIFIER, $operator->getRightType());
$operator = new Operator(['bar' => Operator::TYPE_VALUE], '>=', ['foo.bar' => Operator::TYPE_IDENTIFIER]);
self::assertEquals(Operator::OP_GTE, $operator->getOperator());
self::assertEquals(['bar' => Operator::TYPE_VALUE], $operator->getLeft());
self::assertEquals(['foo.bar' => Operator::TYPE_IDENTIFIER], $operator->getRight());
self::assertEquals(Operator::TYPE_VALUE, $operator->getLeftType());
self::assertEquals(Operator::TYPE_IDENTIFIER, $operator->getRightType());
$operator = new Operator('bar', '>=', 0);
self::assertEquals(0, $operator->getRight());
}
public function testLeftIsMutable()
{
$operator = new Operator();
$operator->setLeft('foo.bar');
self::assertEquals('foo.bar', $operator->getLeft());
}
public function testRightIsMutable()
{
$operator = new Operator();
$operator->setRight('bar');
self::assertEquals('bar', $operator->getRight());
}
public function testLeftTypeIsMutable()
{
$operator = new Operator();
$operator->setLeftType(Operator::TYPE_VALUE);
self::assertEquals(Operator::TYPE_VALUE, $operator->getLeftType());
}
public function testRightTypeIsMutable()
{
$operator = new Operator();
$operator->setRightType(Operator::TYPE_IDENTIFIER);
self::assertEquals(Operator::TYPE_IDENTIFIER, $operator->getRightType());
}
public function testOperatorIsMutable()
{
$operator = new Operator();
$operator->setOperator(Operator::OP_LTE);
self::assertEquals(Operator::OP_LTE, $operator->getOperator());
}
public function testRetrievingWherePartsReturnsSpecificationArrayOfLeftAndRightAndArrayOfTypes()
{
$operator = new Operator();
$operator->setLeft('foo')
->setOperator('>=')
->setRight('foo.bar')
->setLeftType(Operator::TYPE_VALUE)
->setRightType(Operator::TYPE_IDENTIFIER);
$expected = [
[
'%s >= %s',
['foo', 'foo.bar'],
[Operator::TYPE_VALUE, Operator::TYPE_IDENTIFIER],
],
];
$test = $operator->getExpressionData();
self::assertEquals($expected, $test, var_export($test, 1));
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/LikeTest.php | test/unit/Sql/Predicate/LikeTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\Like;
use PHPUnit\Framework\TestCase;
class LikeTest extends TestCase
{
public function testConstructEmptyArgs()
{
$like = new Like();
self::assertEquals('', $like->getIdentifier());
self::assertEquals('', $like->getLike());
}
public function testConstructWithArgs()
{
$like = new Like('bar', 'Foo%');
self::assertEquals('bar', $like->getIdentifier());
self::assertEquals('Foo%', $like->getLike());
}
public function testAccessorsMutators()
{
$like = new Like();
$like->setIdentifier('bar');
self::assertEquals('bar', $like->getIdentifier());
$like->setLike('foo%');
self::assertEquals('foo%', $like->getLike());
$like->setSpecification('target = target');
self::assertEquals('target = target', $like->getSpecification());
}
public function testGetExpressionData()
{
$like = new Like('bar', 'Foo%');
self::assertEquals(
[
['%1$s LIKE %2$s', ['bar', 'Foo%'], [$like::TYPE_IDENTIFIER, $like::TYPE_VALUE]],
],
$like->getExpressionData()
);
$like = new Like(['Foo%' => $like::TYPE_VALUE], ['bar' => $like::TYPE_IDENTIFIER]);
self::assertEquals(
[
['%1$s LIKE %2$s', ['Foo%', 'bar'], [$like::TYPE_VALUE, $like::TYPE_IDENTIFIER]],
],
$like->getExpressionData()
);
}
public function testInstanceOfPerSetters()
{
$like = new Like();
self::assertInstanceOf(Like::class, $like->setIdentifier('bar'));
self::assertInstanceOf(Like::class, $like->setSpecification('%1$s LIKE %2$s'));
self::assertInstanceOf(Like::class, $like->setLike('foo%'));
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/PredicateSetTest.php | test/unit/Sql/Predicate/PredicateSetTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Exception\InvalidArgumentException;
use Laminas\Db\Sql\Predicate\Expression;
use Laminas\Db\Sql\Predicate\In;
use Laminas\Db\Sql\Predicate\IsNotNull;
use Laminas\Db\Sql\Predicate\IsNull;
use Laminas\Db\Sql\Predicate\Literal;
use Laminas\Db\Sql\Predicate\Operator;
use Laminas\Db\Sql\Predicate\PredicateSet;
use LaminasTest\Db\DeprecatedAssertionsTrait;
use PHPUnit\Framework\TestCase;
use function var_export;
class PredicateSetTest extends TestCase
{
use DeprecatedAssertionsTrait;
public function testEmptyConstructorYieldsCountOfZero()
{
$predicateSet = new PredicateSet();
self::assertCount(0, $predicateSet);
}
public function testCombinationIsAndByDefault()
{
$predicateSet = new PredicateSet();
$predicateSet->addPredicate(new IsNull('foo'))
->addPredicate(new IsNull('bar'));
$parts = $predicateSet->getExpressionData();
self::assertCount(3, $parts);
self::assertStringContainsString('AND', $parts[1]);
self::assertStringNotContainsString('OR', $parts[1]);
}
public function testCanPassPredicatesAndDefaultCombinationViaConstructor()
{
$predicateSet = new PredicateSet();
$set = new PredicateSet([
new IsNull('foo'),
new IsNull('bar'),
], 'OR');
$parts = $set->getExpressionData();
self::assertCount(3, $parts);
self::assertStringContainsString('OR', $parts[1]);
self::assertStringNotContainsString('AND', $parts[1]);
}
public function testCanPassBothPredicateAndCombinationToAddPredicate()
{
$predicateSet = new PredicateSet();
$predicateSet->addPredicate(new IsNull('foo'), 'OR')
->addPredicate(new IsNull('bar'), 'AND')
->addPredicate(new IsNull('baz'), 'OR')
->addPredicate(new IsNull('bat'), 'AND');
$parts = $predicateSet->getExpressionData();
self::assertCount(7, $parts);
self::assertStringNotContainsString('OR', $parts[1], var_export($parts, 1));
self::assertStringContainsString('AND', $parts[1]);
self::assertStringContainsString('OR', $parts[3]);
self::assertStringNotContainsString('AND', $parts[3]);
self::assertStringNotContainsString('OR', $parts[5]);
self::assertStringContainsString('AND', $parts[5]);
}
public function testCanUseOrPredicateAndAndPredicateMethods()
{
$predicateSet = new PredicateSet();
$predicateSet->orPredicate(new IsNull('foo'))
->andPredicate(new IsNull('bar'))
->orPredicate(new IsNull('baz'))
->andPredicate(new IsNull('bat'));
$parts = $predicateSet->getExpressionData();
self::assertCount(7, $parts);
self::assertStringNotContainsString('OR', $parts[1], var_export($parts, 1));
self::assertStringContainsString('AND', $parts[1]);
self::assertStringContainsString('OR', $parts[3]);
self::assertStringNotContainsString('AND', $parts[3]);
self::assertStringNotContainsString('OR', $parts[5]);
self::assertStringContainsString('AND', $parts[5]);
}
/**
* @covers \Laminas\Db\Sql\Predicate\PredicateSet::addPredicates
*/
public function testAddPredicates()
{
$predicateSet = new PredicateSet();
$predicateSet->addPredicates('x = y');
$predicateSet->addPredicates(['foo > ?' => 5]);
$predicateSet->addPredicates(['id' => 2]);
$predicateSet->addPredicates(['a = b'], PredicateSet::OP_OR);
$predicateSet->addPredicates(['c1' => null]);
$predicateSet->addPredicates(['c2' => [1, 2, 3]]);
$predicateSet->addPredicates([new IsNotNull('c3')]);
$predicates = $this->readAttribute($predicateSet, 'predicates');
self::assertEquals('AND', $predicates[0][0]);
self::assertInstanceOf(Literal::class, $predicates[0][1]);
self::assertEquals('AND', $predicates[1][0]);
self::assertInstanceOf(Expression::class, $predicates[1][1]);
self::assertEquals('AND', $predicates[2][0]);
self::assertInstanceOf(Operator::class, $predicates[2][1]);
self::assertEquals('OR', $predicates[3][0]);
self::assertInstanceOf(Literal::class, $predicates[3][1]);
self::assertEquals('AND', $predicates[4][0]);
self::assertInstanceOf(IsNull::class, $predicates[4][1]);
self::assertEquals('AND', $predicates[5][0]);
self::assertInstanceOf(In::class, $predicates[5][1]);
self::assertEquals('AND', $predicates[6][0]);
self::assertInstanceOf(IsNotNull::class, $predicates[6][1]);
$predicateSet->addPredicates(function ($what) use ($predicateSet) {
self::assertSame($predicateSet, $what);
});
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('Predicate cannot be null');
$predicateSet->addPredicates(null);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/ExpressionTest.php | test/unit/Sql/Predicate/ExpressionTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\Expression;
use Laminas\Db\Sql\Predicate\IsNull;
use PHPUnit\Framework\TestCase;
use function var_export;
class ExpressionTest extends TestCase
{
public function testEmptyConstructorYieldsEmptyLiteralAndParameter()
{
$expression = new Expression();
self::assertEquals('', $expression->getExpression());
self::assertEmpty($expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassLiteralAndSingleScalarParameterToConstructor()
{
$expression = new Expression('foo.bar = ?', 'bar');
self::assertEquals('foo.bar = ?', $expression->getExpression());
self::assertEquals(['bar'], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassNoParameterToConstructor()
{
$expression = new Expression('foo.bar');
self::assertEquals([], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassSingleNullParameterToConstructor()
{
$expression = new Expression('?', null);
self::assertEquals([null], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassSingleZeroParameterValueToConstructor()
{
$predicate = new Expression('?', 0);
self::assertEquals([0], $predicate->getParameters());
}
/**
* @group 6849
*/
public function testCanPassSinglePredicateParameterToConstructor()
{
$predicate = new IsNull('foo.baz');
$expression = new Expression('?', $predicate);
self::assertEquals([$predicate], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassMultiScalarParametersToConstructor()
{
$expression = new Expression('? OR ?', 'foo', 'bar');
self::assertEquals(['foo', 'bar'], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassMultiNullParametersToConstructor()
{
$expression = new Expression('? OR ?', null, null);
self::assertEquals([null, null], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassMultiPredicateParametersToConstructor()
{
$predicate = new IsNull('foo.baz');
$expression = new Expression('? OR ?', $predicate, $predicate);
self::assertEquals([$predicate, $predicate], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassArrayOfOneScalarParameterToConstructor()
{
$expression = new Expression('?', ['foo']);
self::assertEquals(['foo'], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassArrayOfMultiScalarsParameterToConstructor()
{
$expression = new Expression('? OR ?', ['foo', 'bar']);
self::assertEquals(['foo', 'bar'], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassArrayOfOneNullParameterToConstructor()
{
$expression = new Expression('?', [null]);
self::assertEquals([null], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassArrayOfMultiNullsParameterToConstructor()
{
$expression = new Expression('? OR ?', [null, null]);
self::assertEquals([null, null], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassArrayOfOnePredicateParameterToConstructor()
{
$predicate = new IsNull('foo.baz');
$expression = new Expression('?', [$predicate]);
self::assertEquals([$predicate], $expression->getParameters());
}
/**
* @group 6849
*/
public function testCanPassArrayOfMultiPredicatesParameterToConstructor()
{
$predicate = new IsNull('foo.baz');
$expression = new Expression('? OR ?', [$predicate, $predicate]);
self::assertEquals([$predicate, $predicate], $expression->getParameters());
}
public function testLiteralIsMutable()
{
$expression = new Expression();
$expression->setExpression('foo.bar = ?');
self::assertEquals('foo.bar = ?', $expression->getExpression());
}
public function testParameterIsMutable()
{
$expression = new Expression();
$expression->setParameters(['foo', 'bar']);
self::assertEquals(['foo', 'bar'], $expression->getParameters());
}
public function testRetrievingWherePartsReturnsSpecificationArrayOfLiteralAndParametersAndArrayOfTypes()
{
$expression = new Expression();
$expression->setExpression('foo.bar = ? AND id != ?')
->setParameters(['foo', 'bar']);
$expected = [
[
'foo.bar = %s AND id != %s',
['foo', 'bar'],
[Expression::TYPE_VALUE, Expression::TYPE_VALUE],
],
];
$test = $expression->getExpressionData();
self::assertEquals($expected, $test, var_export($test, 1));
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Predicate/NotBetweenTest.php | test/unit/Sql/Predicate/NotBetweenTest.php | <?php
namespace LaminasTest\Db\Sql\Predicate;
use Laminas\Db\Sql\Predicate\NotBetween;
use PHPUnit\Framework\TestCase;
class NotBetweenTest extends TestCase
{
/** @var NotBetween */
protected $notBetween;
protected function setUp(): void
{
$this->notBetween = new NotBetween();
}
/**
* @covers \Laminas\Db\Sql\Predicate\NotBetween::getSpecification
*/
public function testSpecificationHasSameDefaultValue()
{
self::assertEquals('%1$s NOT BETWEEN %2$s AND %3$s', $this->notBetween->getSpecification());
}
/**
* @covers \Laminas\Db\Sql\Predicate\NotBetween::getExpressionData
*/
public function testRetrievingWherePartsReturnsSpecificationArrayOfIdentifierAndValuesAndArrayOfTypes()
{
$this->notBetween->setIdentifier('foo.bar')
->setMinValue(10)
->setMaxValue(19);
$expected = [
[
$this->notBetween->getSpecification(),
['foo.bar', 10, 19],
[NotBetween::TYPE_IDENTIFIER, NotBetween::TYPE_VALUE, NotBetween::TYPE_VALUE],
],
];
self::assertEquals($expected, $this->notBetween->getExpressionData());
$this->notBetween->setIdentifier([10 => NotBetween::TYPE_VALUE])
->setMinValue(['foo.bar' => NotBetween::TYPE_IDENTIFIER])
->setMaxValue(['foo.baz' => NotBetween::TYPE_IDENTIFIER]);
$expected = [
[
$this->notBetween->getSpecification(),
[10, 'foo.bar', 'foo.baz'],
[NotBetween::TYPE_VALUE, NotBetween::TYPE_IDENTIFIER, NotBetween::TYPE_IDENTIFIER],
],
];
self::assertEquals($expected, $this->notBetween->getExpressionData());
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/PlatformTest.php | test/unit/Sql/Platform/PlatformTest.php | <?php
namespace LaminasTest\Db\Sql\Platform;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\StatementContainer;
use Laminas\Db\Sql\Exception\RuntimeException;
use Laminas\Db\Sql\Platform\Platform;
use LaminasTest\Db\TestAsset;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use ReflectionMethod;
use ReflectionProperty;
class PlatformTest extends TestCase
{
public function testResolveDefaultPlatform()
{
$adapter = $this->resolveAdapter('sql92');
$platform = new Platform($adapter);
$reflectionMethod = new ReflectionMethod($platform, 'resolvePlatform');
$reflectionMethod->setAccessible(true);
self::assertEquals($adapter->getPlatform(), $reflectionMethod->invoke($platform, null));
}
public function testResolvePlatformName()
{
$platform = new Platform($this->resolveAdapter('sql92'));
$reflectionMethod = new ReflectionMethod($platform, 'resolvePlatformName');
$reflectionMethod->setAccessible(true);
self::assertEquals('mysql', $reflectionMethod->invoke($platform, new TestAsset\TrustingMysqlPlatform()));
self::assertEquals('sqlserver', $reflectionMethod->invoke(
$platform,
new TestAsset\TrustingSqlServerPlatform()
));
self::assertEquals('oracle', $reflectionMethod->invoke($platform, new TestAsset\TrustingOraclePlatform()));
self::assertEquals('sql92', $reflectionMethod->invoke($platform, new TestAsset\TrustingSql92Platform()));
}
/**
* @group 6890
*/
public function testAbstractPlatformCrashesGracefullyOnMissingDefaultPlatform()
{
$adapter = $this->resolveAdapter('sql92');
$reflectionProperty = new ReflectionProperty($adapter, 'platform');
$reflectionProperty->setAccessible(true);
$reflectionProperty->setValue($adapter, null);
$platform = new Platform($adapter);
$reflectionMethod = new ReflectionMethod($platform, 'resolvePlatform');
$reflectionMethod->setAccessible(true);
$this->expectException(RuntimeException::class);
$this->expectExceptionMessage('$this->defaultPlatform was not set');
$reflectionMethod->invoke($platform, null);
}
/**
* @group 6890
*/
public function testAbstractPlatformCrashesGracefullyOnMissingDefaultPlatformWithGetDecorators()
{
$adapter = $this->resolveAdapter('sql92');
$reflectionProperty = new ReflectionProperty($adapter, 'platform');
$reflectionProperty->setAccessible(true);
$reflectionProperty->setValue($adapter, null);
$platform = new Platform($adapter);
$reflectionMethod = new ReflectionMethod($platform, 'resolvePlatform');
$reflectionMethod->setAccessible(true);
$this->expectException(RuntimeException::class);
$this->expectExceptionMessage('$this->defaultPlatform was not set');
$platform->getDecorators();
}
/**
* @param string $platformName
* @return Adapter
*/
protected function resolveAdapter($platformName)
{
$platform = null;
switch ($platformName) {
case 'sql92':
$platform = new TestAsset\TrustingSql92Platform();
break;
case 'MySql':
$platform = new TestAsset\TrustingMysqlPlatform();
break;
case 'Oracle':
$platform = new TestAsset\TrustingOraclePlatform();
break;
case 'SqlServer':
$platform = new TestAsset\TrustingSqlServerPlatform();
break;
}
/** @var DriverInterface|MockObject $mockDriver */
$mockDriver = $this->getMockBuilder(DriverInterface::class)->getMock();
$mockDriver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
$mockDriver->expects($this->any())->method('createStatement')->will($this->returnCallback(function () {
return new StatementContainer();
}));
return new Adapter($mockDriver, $platform);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Mysql/MysqlTest.php | test/unit/Sql/Platform/Mysql/MysqlTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Mysql;
use Laminas\Db\Sql\Platform\Mysql\Mysql;
use Laminas\Db\Sql\Platform\Mysql\SelectDecorator;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
use function current;
use function key;
class MysqlTest extends TestCase
{
/**
* @testdox unit test / object test: Test Mysql object has Select proxy
* @covers \Laminas\Db\Sql\Platform\Mysql\Mysql::__construct
*/
public function testConstruct()
{
$mysql = new Mysql();
$decorators = $mysql->getDecorators();
$type = key($decorators);
$decorator = current($decorators);
self::assertEquals(Select::class, $type);
self::assertInstanceOf(SelectDecorator::class, $decorator);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Mysql/SelectDecoratorTest.php | test/unit/Sql/Platform/Mysql/SelectDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Mysql;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\Mysqli\Statement;
use Laminas\Db\Adapter\Driver\Pdo\Connection;
use Laminas\Db\Adapter\Driver\Pdo\Pdo;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\Platform\Mysql as MysqlPlatform;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\Platform\Mysql\SelectDecorator;
use Laminas\Db\Sql\Select;
use Laminas\Db\Sql\Sql;
use LaminasTest\Db\TestAsset\TrustingMysqlPlatform;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
class SelectDecoratorTest extends TestCase
{
/** @var Adapter&MockObject */
protected $mockAdapter;
/** @var Sql */
protected $sql;
/**
* @testdox integration test: Testing SelectDecorator will use Select an internal state to prepare
* a proper limit/offset sql statement
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::prepareStatement
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::processLimit
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::processOffset
* @dataProvider dataProvider
*/
public function testPrepareStatement(Select $select, string $expectedSql, array $expectedParams)
{
$driver = $this->getMockBuilder(DriverInterface::class)->getMock();
$driver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
// test
$adapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([
$driver,
new MysqlPlatform(),
])
->getMock();
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$statement->expects($this->once())->method('setSql')->with($expectedSql);
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
$selectDecorator->prepareStatement($adapter, $statement);
self::assertEquals($expectedParams, $parameterContainer->getNamedArray());
}
/**
* @testdox integration test: Testing SelectDecorator will use Select an internal state to prepare
* a proper limit/offset sql statement
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::prepareStatement
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::processLimit
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::processOffset
* @dataProvider dataProvider
* @param mixed $ignore
* @param array<string, mixed> $params
* @param mixed $alsoIgnore
*/
public function testPrepareStatementForSqlObject(
Select $select,
$ignore,
array $expectedParams,
$alsoIgnore,
string $expectedPdoSql
) {
// mock the adapter, driver, and parts
$newStatement = new Statement();
$driver = new Pdo(new Connection());
$mockAdapter = $this->getMockBuilder(Adapter::class)
->setConstructorArgs([$driver, new TrustingMysqlPlatform()])
->getMock();
$trustingPlatform = new TrustingMysqlPlatform();
$mockAdapter->expects($this->any())->method('getPlatform')->will($this->returnValue($trustingPlatform));
$mockAdapter->expects($this->any())->method('getDriver')->will($this->returnValue($driver));
// setup mock adapter
$this->mockAdapter = $mockAdapter;
$this->sql = new Sql($this->mockAdapter, 'foo');
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
$statement = $this->sql->prepareStatementForSqlObject($select, $newStatement);
self::assertEquals($expectedPdoSql, $statement->getSql());
}
/**
* @testdox integration test: Testing SelectDecorator will use Select an internal state to prepare
* a proper limit/offset sql statement
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::getSqlString
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::processLimit
* @covers \Laminas\Db\Sql\Platform\Mysql\SelectDecorator::processOffset
* @dataProvider dataProvider
* @param mixed $ignore
* @param mixed $alsoIgnore
*/
public function testGetSqlString(Select $select, $ignore, $alsoIgnore, string $expectedSql)
{
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
self::assertEquals($expectedSql, $selectDecorator->getSqlString(new TrustingMysqlPlatform()));
}
/**
* @psalm-return array<array-key, array{
* 0: Select,
* 1: string,
* 2: array<string, mixed>
* 3: string,
* 4: string
* }>
*/
public function dataProvider(): array
{
// phpcs:disable Generic.Files.LineLength.TooLong
$select0 = new Select();
$select0->from('foo')->limit(5)->offset(10);
$expectedPrepareSql0 = 'SELECT `foo`.* FROM `foo` LIMIT ? OFFSET ?';
$expectedPrepareObjectSql0 = 'SELECT `foo`.* FROM `foo` LIMIT :limit OFFSET :offset';
$expectedParams0 = ['offset' => 10, 'limit' => 5];
$expectedSql0 = 'SELECT `foo`.* FROM `foo` LIMIT 5 OFFSET 10';
// offset without limit
$select1 = new Select();
$select1->from('foo')->offset(10);
$expectedPrepareSql1 = 'SELECT `foo`.* FROM `foo` LIMIT 18446744073709551615 OFFSET ?';
$expectedPrepareObjectSql1 = 'SELECT `foo`.* FROM `foo` LIMIT 18446744073709551615 OFFSET :offset';
$expectedParams1 = ['offset' => 10];
$expectedSql1 = 'SELECT `foo`.* FROM `foo` LIMIT 18446744073709551615 OFFSET 10';
// offset and limit are not type casted when injected into parameter container
$select2 = new Select();
$select2->from('foo')->limit('5')->offset('10000000000000000000');
$expectedPrepareSql2 = 'SELECT `foo`.* FROM `foo` LIMIT ? OFFSET ?';
$expectedPrepareObjectSql2 = 'SELECT `foo`.* FROM `foo` LIMIT :limit OFFSET :offset';
$expectedParams2 = ['offset' => '10000000000000000000', 'limit' => '5'];
$expectedSql2 = 'SELECT `foo`.* FROM `foo` LIMIT 5 OFFSET 10000000000000000000';
// nested single limit & offset in field param
$nestedSelect0 = new Select();
$nestedSelect0->from('foo1')
->columns([
'cnt' => new Expression('count(foo1.id)'),
])->limit(100)->offset(500);
$select3 = new Select();
$select3->from('foo')
->columns([
'res' => $nestedSelect0,
])
->limit(10)->offset(50);
$expectedPrepareSql3 =
"SELECT (SELECT count(foo1.id) AS `cnt` FROM `foo1` LIMIT ? OFFSET ?) AS `res`"
. " FROM `foo` LIMIT ? OFFSET ?";
$expectedPrepareObjectSql3 =
"SELECT (SELECT count(foo1.id) AS `cnt` FROM `foo1` LIMIT :subselect1limit OFFSET :subselect1offset) AS `res`"
. " FROM `foo` LIMIT :limit OFFSET :offset";
$expectedParams3 = [
'subselect1limit' => 100,
'subselect1offset' => 500,
'limit' => 10,
'offset' => 50,
];
$expectedSql3 = "SELECT (SELECT count(foo1.id) AS `cnt`"
. " FROM `foo1` LIMIT 100 OFFSET 500) AS `res`"
. " FROM `foo` LIMIT 10 OFFSET 50";
// nested multiple limit & offset in field param
$nestedSelect0 = new Select();
$nestedSelect0->from('foo1')
->columns([
'cnt' => new Expression('count(foo1.id)'),
])->limit(100)->offset(500);
$nestedSelect1 = new Select();
$nestedSelect1->from('foo2')
->columns([
'cnt' => new Expression('count(foo2.id)'),
])->limit(50)->offset(101);
$select4 = new Select();
$select4->from('foo')
->columns([
'res' => $nestedSelect0,
'res0' => $nestedSelect1,
])
->limit(10)->offset(5);
$expectedPrepareSql4 =
"SELECT (SELECT count(foo1.id) AS `cnt` FROM `foo1` LIMIT ? OFFSET ?) AS `res`,"
. " (SELECT count(foo2.id) AS `cnt` FROM `foo2` LIMIT ? OFFSET ?) AS `res0`"
. " FROM `foo` LIMIT ? OFFSET ?";
$expectedPrepareObjectSql4 =
"SELECT (SELECT count(foo1.id) AS `cnt` FROM `foo1` LIMIT :subselect1limit OFFSET :subselect1offset)"
. " AS `res`, (SELECT count(foo2.id) AS `cnt` FROM `foo2` LIMIT :subselect2limit OFFSET :subselect2offset)"
. " AS `res0` FROM `foo` LIMIT :limit OFFSET :offset";
$expectedParams4 = [
'subselect1limit' => 100,
'subselect1offset' => 500,
'subselect2limit' => 50,
'subselect2offset' => 101,
'limit' => 10,
'offset' => 5,
];
$expectedSql4 = "SELECT (SELECT count(foo1.id) AS `cnt` FROM `foo1` LIMIT 100 OFFSET 500) AS `res`,"
. " (SELECT count(foo2.id) AS `cnt` FROM `foo2` LIMIT 50 OFFSET 101) AS `res0`"
. " FROM `foo` LIMIT 10 OFFSET 5";
// nested limit in field param, no limit in containing select
$nestedSelect0 = new Select();
$nestedSelect0->from('foo1')
->columns([
'cnt' => new Expression('count(foo1.id)'),
]);
$nestedSelect0->where->equalTo('foo2', 'ab');
$nestedSelect0->limit(1);
$select5 = new Select();
$select5->from('foo')
->columns([
'res' => $nestedSelect0,
]);
$expectedPrepareSql5 =
"SELECT (SELECT count(foo1.id) AS `cnt` FROM `foo1` WHERE `foo2` = ? LIMIT ?) AS `res`"
. " FROM `foo`";
$expectedPrepareObjectSql5 =
"SELECT (SELECT count(foo1.id) AS `cnt` FROM `foo1` WHERE `foo2` = :subselect1where1 LIMIT"
. " :subselect1limit) AS `res` FROM `foo`";
$expectedParams5 = [
'subselect1limit' => 1,
'subselect1where1' => 'ab',
];
$expectedSql5 = "SELECT (SELECT count(foo1.id) AS `cnt`"
. " FROM `foo1` WHERE `foo2` = 'ab' LIMIT 1) AS `res`"
. " FROM `foo`";
return [
[$select0, $expectedPrepareSql0, $expectedParams0, $expectedSql0, $expectedPrepareObjectSql0],
[$select1, $expectedPrepareSql1, $expectedParams1, $expectedSql1, $expectedPrepareObjectSql1],
[$select2, $expectedPrepareSql2, $expectedParams2, $expectedSql2, $expectedPrepareObjectSql2],
[$select3, $expectedPrepareSql3, $expectedParams3, $expectedSql3, $expectedPrepareObjectSql3],
[$select4, $expectedPrepareSql4, $expectedParams4, $expectedSql4, $expectedPrepareObjectSql4],
[$select5, $expectedPrepareSql5, $expectedParams5, $expectedSql5, $expectedPrepareObjectSql5],
];
// phpcs:enable Generic.Files.LineLength.TooLong
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Mysql/Ddl/AlterTableDecoratorTest.php | test/unit/Sql/Platform/Mysql/Ddl/AlterTableDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Mysql\Ddl;
use Laminas\Db\Adapter\Platform\Mysql;
use Laminas\Db\Sql\Ddl\AlterTable;
use Laminas\Db\Sql\Ddl\Column\Column;
use Laminas\Db\Sql\Ddl\Constraint\PrimaryKey;
use Laminas\Db\Sql\Platform\Mysql\Ddl\AlterTableDecorator;
use PHPUnit\Framework\TestCase;
class AlterTableDecoratorTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Platform\Mysql\Ddl\AlterTableDecorator::setSubject
*/
public function testSetSubject()
{
$ctd = new AlterTableDecorator();
$ct = new AlterTable();
self::assertSame($ctd, $ctd->setSubject($ct));
}
/**
* @covers \Laminas\Db\Sql\Platform\Mysql\Ddl\AlterTableDecorator::getSqlString
*/
public function testGetSqlString()
{
$ctd = new AlterTableDecorator();
$ct = new AlterTable('foo');
$ctd->setSubject($ct);
$col = new Column('bar');
$col->setOption('zerofill', true);
$col->setOption('unsigned', true);
$col->setOption('identity', true);
$col->setOption('comment', 'baz');
$col->setOption('after', 'bar');
$col->addConstraint(new PrimaryKey());
$ct->addColumn($col);
self::assertEquals(
"ALTER TABLE `foo`\n ADD COLUMN `bar` INTEGER UNSIGNED ZEROFILL "
. "NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT 'baz' AFTER `bar`",
@$ctd->getSqlString(new Mysql())
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Mysql/Ddl/CreateTableDecoratorTest.php | test/unit/Sql/Platform/Mysql/Ddl/CreateTableDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Mysql\Ddl;
use Laminas\Db\Adapter\Platform\Mysql;
use Laminas\Db\Sql\Ddl\Column\Column;
use Laminas\Db\Sql\Ddl\Constraint\PrimaryKey;
use Laminas\Db\Sql\Ddl\CreateTable;
use Laminas\Db\Sql\Platform\Mysql\Ddl\CreateTableDecorator;
use PHPUnit\Framework\TestCase;
class CreateTableDecoratorTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Platform\Mysql\Ddl\CreateTableDecorator::setSubject
*/
public function testSetSubject()
{
$ctd = new CreateTableDecorator();
$ct = new CreateTable();
self::assertSame($ctd, $ctd->setSubject($ct));
}
/**
* @covers \Laminas\Db\Sql\Platform\Mysql\Ddl\CreateTableDecorator::getSqlString
*/
public function testGetSqlString()
{
$ctd = new CreateTableDecorator();
$ct = new CreateTable('foo');
$ctd->setSubject($ct);
$col = new Column('bar');
$col->setOption('zerofill', true);
$col->setOption('unsigned', true);
$col->setOption('identity', true);
$col->setOption('column-format', 'FIXED');
$col->setOption('storage', 'memory');
$col->setOption('comment', 'baz');
$col->addConstraint(new PrimaryKey());
$ct->addColumn($col);
self::assertEquals(
// @codingStandardsIgnoreStart
"CREATE TABLE `foo` ( \n `bar` INTEGER UNSIGNED ZEROFILL NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT 'baz' COLUMN_FORMAT FIXED STORAGE MEMORY \n)",
// @codingStandardsIgnoreEnd
@$ctd->getSqlString(new Mysql())
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/IbmDb2/SelectDecoratorTest.php | test/unit/Sql/Platform/IbmDb2/SelectDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\IbmDb2;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\Platform\IbmDb2 as IbmDb2Platform;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\Platform\IbmDb2\SelectDecorator;
use Laminas\Db\Sql\Select;
use Laminas\Db\Sql\Where;
use PHPUnit\Framework\TestCase;
class SelectDecoratorTest extends TestCase
{
/**
* @testdox integration test: Testing SelectDecorator will use Select to produce properly IBM Db2
* dialect prepared sql
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::prepareStatement
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::processLimitOffset
* @dataProvider dataProvider
* @param mixed $notUsed
*/
public function testPrepareStatement(
Select $select,
string $expectedPrepareSql,
array $expectedParams,
$notUsed,
bool $supportsLimitOffset
) {
$driver = $this->getMockBuilder(DriverInterface::class)->getMock();
$driver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
// test
$adapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([
$driver,
new IbmDb2Platform(),
])
->getMock();
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement
->expects($this->any())
->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$statement
->expects($this->once())
->method('setSql')
->with($expectedPrepareSql);
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
$selectDecorator->setSupportsLimitOffset($supportsLimitOffset);
$selectDecorator->prepareStatement($adapter, $statement);
self::assertEquals($expectedParams, $parameterContainer->getNamedArray());
}
/**
* @testdox integration test: Testing SelectDecorator will use Select to produce properly Ibm DB2
* dialect sql statements
* @covers \Laminas\Db\Sql\Platform\IbmDb2\SelectDecorator::getSqlString
* @dataProvider dataProvider
* @param mixed $ignored0
* @param mixed $ignored1
*/
public function testGetSqlString(
Select $select,
$ignored0,
$ignored1,
string $expectedSql,
bool $supportsLimitOffset
) {
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement
->expects($this->any())
->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
$selectDecorator->setSupportsLimitOffset($supportsLimitOffset);
self::assertEquals($expectedSql, @$selectDecorator->getSqlString(new IbmDb2Platform()));
}
/**
* Data provider for testGetSqlString
*
* @return array
*/
public function dataProvider()
{
// phpcs:disable Generic.Files.LineLength.TooLong
$select0 = new Select();
$select0->from(['x' => 'foo'])->limit(5);
$expectedParams0 = ['limit' => 5, 'offset' => 0];
$expectedPrepareSql0 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN ? AND ?';
$expectedSql0 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN 0 AND 5';
$select1 = new Select();
$select1->from(['x' => 'foo'])->limit(5)->offset(10);
$expectedParams1 = ['limit' => 15, 'offset' => 11];
$expectedPrepareSql1 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN ? AND ?';
$expectedSql1 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN 11 AND 15';
$select2 = new Select();
$select2->columns([new Expression('DISTINCT(id) as id')])->from(['x' => 'foo'])->limit(5)->offset(10);
$expectedParams2 = ['limit' => 15, 'offset' => 11];
$expectedPrepareSql2 = 'SELECT DISTINCT(id) as id FROM ( SELECT DISTINCT(id) as id, DENSE_RANK() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN ? AND ?';
$expectedSql2 = 'SELECT DISTINCT(id) as id FROM ( SELECT DISTINCT(id) as id, DENSE_RANK() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN 11 AND 15';
$select3 = new Select();
$where3 = new Where();
$where3->greaterThan('x.id', '10')->AND->lessThan('x.id', '31');
$select3->from(['x' => 'foo'])->where($where3)->limit(5)->offset(10);
$expectedParams3 = ['limit' => 15, 'offset' => 11, 'where1' => '10', 'where2' => '31'];
$expectedPrepareSql3 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" WHERE "x"."id" > ? AND "x"."id" < ? ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN ? AND ?';
$expectedSql3 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" WHERE "x"."id" > \'10\' AND "x"."id" < \'31\' ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN 11 AND 15';
$select4 = new Select();
$where4 = $where3;
$select4->from(['x' => 'foo'])->where($where4)->limit(5);
$expectedParams4 = ['limit' => 5, 'offset' => 0, 'where1' => 10, 'where2' => 31];
$expectedPrepareSql4 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" WHERE "x"."id" > ? AND "x"."id" < ? ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN ? AND ?';
$expectedSql4 = 'SELECT * FROM ( SELECT "x".*, ROW_NUMBER() OVER () AS LAMINAS_DB_ROWNUM FROM "foo" "x" WHERE "x"."id" > \'10\' AND "x"."id" < \'31\' ) AS LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION WHERE LAMINAS_IBMDB2_SERVER_LIMIT_OFFSET_EMULATION.LAMINAS_DB_ROWNUM BETWEEN 0 AND 5';
$select5 = new Select();
$select5->from(['x' => 'foo'])->limit(5);
$expectedParams5 = [];
$expectedPrepareSql5 = 'SELECT "x".* FROM "foo" "x" LIMIT 5';
$expectedSql5 = 'SELECT "x".* FROM "foo" "x" LIMIT 5';
$select6 = new Select();
$select6->columns([new Expression('DISTINCT(id) as id')])->from(['x' => 'foo'])->limit(5)->offset(10);
$expectedParams6 = [];
$expectedPrepareSql6 = 'SELECT DISTINCT(id) as id FROM "foo" "x" LIMIT 5 OFFSET 10';
$expectedSql6 = 'SELECT DISTINCT(id) as id FROM "foo" "x" LIMIT 5 OFFSET 10';
return [
[$select0, $expectedPrepareSql0, $expectedParams0, $expectedSql0, false],
[$select1, $expectedPrepareSql1, $expectedParams1, $expectedSql1, false],
[$select2, $expectedPrepareSql2, $expectedParams2, $expectedSql2, false],
[$select3, $expectedPrepareSql3, $expectedParams3, $expectedSql3, false],
[$select4, $expectedPrepareSql4, $expectedParams4, $expectedSql4, false],
[$select5, $expectedPrepareSql5, $expectedParams5, $expectedSql5, true],
[$select6, $expectedPrepareSql6, $expectedParams6, $expectedSql6, true],
];
// phpcs:enable Generic.Files.LineLength.TooLong
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Sqlite/SqliteTest.php | test/unit/Sql/Platform/Sqlite/SqliteTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Sqlite;
use Laminas\Db\Sql\Platform\Sqlite\SelectDecorator;
use Laminas\Db\Sql\Platform\Sqlite\Sqlite;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
use function current;
use function key;
class SqliteTest extends TestCase
{
/**
* @testdox unit test / object test: Test Sqlite constructor will register the decorator
* @covers \Laminas\Db\Sql\Platform\Sqlite\Sqlite::__construct
*/
public function testConstructorRegistersSqliteDecorator()
{
$mysql = new Sqlite();
$decorators = $mysql->getDecorators();
$type = key($decorators);
$decorator = current($decorators);
self::assertEquals(Select::class, $type);
self::assertInstanceOf(SelectDecorator::class, $decorator);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Sqlite/SelectDecoratorTest.php | test/unit/Sql/Platform/Sqlite/SelectDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Sqlite;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\Platform\Sqlite as SqlitePlatform;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\Platform\Sqlite\SelectDecorator;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
class SelectDecoratorTest extends TestCase
{
/**
* @testdox integration test: Testing SelectDecorator will use Select an internal state to prepare a proper combine
* statement
* @covers \Laminas\Db\Sql\Platform\Sqlite\SelectDecorator::prepareStatement
* @covers \Laminas\Db\Sql\Platform\Sqlite\SelectDecorator::processCombine
* @dataProvider dataProviderUnionSyntaxFromCombine
*/
public function testPrepareStatementPreparesUnionSyntaxFromCombine(
Select $select,
string $expectedSql,
array $expectedParams
) {
$driver = $this->getMockBuilder(DriverInterface::class)->getMock();
$driver->expects($this->any())->method('formatParameterName')->will($this->returnValue('?'));
// test
$adapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([
$driver,
new SqlitePlatform(),
])
->getMock();
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$statement->expects($this->once())->method('setSql')->with($expectedSql);
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
$selectDecorator->prepareStatement($adapter, $statement);
self::assertEquals($expectedParams, $parameterContainer->getNamedArray());
}
/**
* @testdox integration test: Testing SelectDecorator will use Select an internal state to prepare a proper combine
* statement
* @covers \Laminas\Db\Sql\Platform\Sqlite\SelectDecorator::getSqlString
* @covers \Laminas\Db\Sql\Platform\Sqlite\SelectDecorator::processCombine
* @dataProvider dataProviderUnionSyntaxFromCombine
* @param mixed $ignore
* @param mixed $alsoIgnore
*/
public function testGetSqlStringPreparesUnionSyntaxFromCombine(
Select $select,
$ignore,
$alsoIgnore,
string $expectedSql
) {
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
self::assertEquals($expectedSql, $selectDecorator->getSqlString(new SqlitePlatform()));
}
/**
* Create a data provider for union syntax that would come from combine
*
* @psalm-return array<array-key, array{
* 0: Select,
* 1: string,
* 2: array<string, mixed>,
* 3: string
* }>
*/
public function dataProviderUnionSyntaxFromCombine(): array
{
$select0 = new Select();
$select0->from('foo');
$select1 = clone $select0;
$select0->combine($select1);
$expectedPrepareSql0 = ' SELECT "foo".* FROM "foo" UNION SELECT "foo".* FROM "foo"';
$expectedParams0 = [];
$expectedSql0 = ' SELECT "foo".* FROM "foo" UNION SELECT "foo".* FROM "foo"';
// nested single limit & offset in field param
$nestedSelect0 = new Select();
$nestedSelect0->from('foo1')
->columns([
'cnt' => new Expression('count(foo1.id)'),
])->limit(100)->offset(500);
$select3 = new Select();
$select3->from('foo')
->columns([
'res' => $nestedSelect0,
])
->limit(10)->offset(50);
$expectedPrepareSql3 =
' SELECT ( SELECT count(foo1.id) AS "cnt" FROM "foo1" LIMIT ? OFFSET ?) AS "res"'
. ' FROM "foo" LIMIT ? OFFSET ?';
$expectedParams3 = [
'subselect1limit' => 100,
'subselect1offset' => 500,
'limit' => 10,
'offset' => 50,
];
$expectedSql3 = ' SELECT ( SELECT count(foo1.id) AS "cnt"'
. ' FROM "foo1" LIMIT 100 OFFSET 500) AS "res"'
. ' FROM "foo" LIMIT 10 OFFSET 50';
// multiple nested query
$nestedSelect0 = new Select();
$nestedSelect0->from('foo1')
->columns([
'cnt' => new Expression('count(foo1.id)'),
])->limit(100)->offset(500);
$nestedSelect1 = new Select();
$nestedSelect1->from('foo2')
->columns([
'cnt' => new Expression('count(foo2.id)'),
])->limit(50)->offset(101);
$select4 = new Select();
$select4->from('foo')
->columns([
'res' => $nestedSelect0,
'res0' => $nestedSelect1,
])
->limit(10)->offset(5);
$expectedPrepareSql4 =
' SELECT ( SELECT count(foo1.id) AS "cnt" FROM "foo1" LIMIT ? OFFSET ?) AS "res",'
. ' ( SELECT count(foo2.id) AS "cnt" FROM "foo2" LIMIT ? OFFSET ?) AS "res0"'
. ' FROM "foo" LIMIT ? OFFSET ?';
$expectedParams4 = [
'subselect1limit' => 100,
'subselect1offset' => 500,
'subselect2limit' => 50,
'subselect2offset' => 101,
'limit' => 10,
'offset' => 5,
];
$expectedSql4 = ' SELECT ( SELECT count(foo1.id) AS "cnt" FROM "foo1" LIMIT 100 OFFSET 500) AS "res",'
. ' ( SELECT count(foo2.id) AS "cnt" FROM "foo2" LIMIT 50 OFFSET 101) AS "res0"'
. ' FROM "foo" LIMIT 10 OFFSET 5';
return [
[$select0, $expectedPrepareSql0, $expectedParams0, $expectedSql0],
[$select3, $expectedPrepareSql3, $expectedParams3, $expectedSql3],
[$select4, $expectedPrepareSql4, $expectedParams4, $expectedSql4],
];
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/SqlServer/SelectDecoratorTest.php | test/unit/Sql/Platform/SqlServer/SelectDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\SqlServer;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\Platform\SqlServer as SqlServerPlatform;
use Laminas\Db\Sql\Expression;
use Laminas\Db\Sql\Platform\SqlServer\SelectDecorator;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
class SelectDecoratorTest extends TestCase
{
/**
* @testdox integration test: Testing SelectDecorator will use Select an internal state to prepare
* a proper limit/offset sql statement
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::prepareStatement
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::processLimitOffset
* @dataProvider dataProvider
* @param array<string, mixed> $expectedParams
* @param mixed $notUsed
*/
public function testPrepareStatement(
Select $select,
string $expectedSql,
array $expectedParams,
$notUsed,
int $expectedFormatParamCount
) {
$driver = $this->getMockBuilder(DriverInterface::class)->getMock();
$driver->expects($this->exactly($expectedFormatParamCount))->method('formatParameterName')
->will($this->returnValue('?'));
// test
$adapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([
$driver,
new SqlServerPlatform(),
])
->getMock();
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$statement->expects($this->once())->method('setSql')->with($expectedSql);
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
$selectDecorator->prepareStatement($adapter, $statement);
self::assertEquals($expectedParams, $parameterContainer->getNamedArray());
}
/**
* @testdox integration test: Testing SelectDecorator will use Select an internal state to prepare
* a proper limit/offset sql statement
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::getSqlString
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::processLimitOffset
* @dataProvider dataProvider
* @param mixed $ignored
* @param mixed $alsoIgnored
*/
public function testGetSqlString(Select $select, $ignored, $alsoIgnored, string $expectedSql)
{
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
self::assertEquals($expectedSql, $selectDecorator->getSqlString(new SqlServerPlatform()));
}
/** @psalm-return array<array-key, array{0: Select, 1: string, 2: array<string, mixed>, 3: string, 4: int}> */
public function dataProvider(): array
{
// phpcs:disable Generic.Files.LineLength.TooLong
$select0 = new Select();
$select0->from('foo')->columns(['bar', 'baz'])->order('bar')->limit(5)->offset(10);
$expectedPrepareSql0 = 'SELECT [bar], [baz] FROM ( SELECT [foo].[bar] AS [bar], [foo].[baz] AS [baz], ROW_NUMBER() OVER (ORDER BY [bar] ASC) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN ?+1 AND ?+?';
$expectedParams0 = ['offset' => 10, 'limit' => 5, 'offsetForSum' => 10];
$expectedSql0 = 'SELECT [bar], [baz] FROM ( SELECT [foo].[bar] AS [bar], [foo].[baz] AS [baz], ROW_NUMBER() OVER (ORDER BY [bar] ASC) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN 10+1 AND 5+10';
$expectedFormatParamCount0 = 3;
$select1 = new Select();
$select1->from('foo')->columns(['bar', 'bam' => 'baz'])->limit(5)->offset(10);
$expectedPrepareSql1 = 'SELECT [bar], [bam] FROM ( SELECT [foo].[bar] AS [bar], [foo].[baz] AS [bam], ROW_NUMBER() OVER (ORDER BY (SELECT 1)) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN ?+1 AND ?+?';
$expectedParams1 = ['offset' => 10, 'limit' => 5, 'offsetForSum' => 10];
$expectedSql1 = 'SELECT [bar], [bam] FROM ( SELECT [foo].[bar] AS [bar], [foo].[baz] AS [bam], ROW_NUMBER() OVER (ORDER BY (SELECT 1)) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN 10+1 AND 5+10';
$expectedFormatParamCount1 = 3;
$select2 = new Select();
$select2->from('foo')->order('bar')->limit(5)->offset(10);
$expectedPrepareSql2 = 'SELECT * FROM ( SELECT [foo].*, ROW_NUMBER() OVER (ORDER BY [bar] ASC) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN ?+1 AND ?+?';
$expectedParams2 = ['offset' => 10, 'limit' => 5, 'offsetForSum' => 10];
$expectedSql2 = 'SELECT * FROM ( SELECT [foo].*, ROW_NUMBER() OVER (ORDER BY [bar] ASC) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN 10+1 AND 5+10';
$expectedFormatParamCount2 = 3;
$select3 = new Select();
$select3->from('foo');
$expectedPrepareSql3 = 'SELECT [foo].* FROM [foo]';
$expectedParams3 = [];
$expectedSql3 = 'SELECT [foo].* FROM [foo]';
$expectedFormatParamCount3 = 0;
$select4 = new Select();
$select4->from('foo')->columns([new Expression('DISTINCT(bar) as bar')])->limit(5)->offset(10);
$expectedPrepareSql4 = 'SELECT DISTINCT(bar) as bar FROM ( SELECT DISTINCT(bar) as bar, ROW_NUMBER() OVER (ORDER BY (SELECT 1)) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN ?+1 AND ?+?';
$expectedParams4 = ['offset' => 10, 'limit' => 5, 'offsetForSum' => 10];
$expectedSql4 = 'SELECT DISTINCT(bar) as bar FROM ( SELECT DISTINCT(bar) as bar, ROW_NUMBER() OVER (ORDER BY (SELECT 1)) AS [__LAMINAS_ROW_NUMBER] FROM [foo] ) AS [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION] WHERE [LAMINAS_SQL_SERVER_LIMIT_OFFSET_EMULATION].[__LAMINAS_ROW_NUMBER] BETWEEN 10+1 AND 5+10';
$expectedFormatParamCount4 = 3;
return [
[$select0, $expectedPrepareSql0, $expectedParams0, $expectedSql0, $expectedFormatParamCount0],
[$select1, $expectedPrepareSql1, $expectedParams1, $expectedSql1, $expectedFormatParamCount1],
[$select2, $expectedPrepareSql2, $expectedParams2, $expectedSql2, $expectedFormatParamCount2],
[$select3, $expectedPrepareSql3, $expectedParams3, $expectedSql3, $expectedFormatParamCount3],
[$select4, $expectedPrepareSql4, $expectedParams4, $expectedSql4, $expectedFormatParamCount4],
];
// phpcs:enable Generic.Files.LineLength.TooLong
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/SqlServer/SqlServerTest.php | test/unit/Sql/Platform/SqlServer/SqlServerTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\SqlServer;
use Laminas\Db\Sql\Platform\SqlServer\SelectDecorator;
use Laminas\Db\Sql\Platform\SqlServer\SqlServer;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
use function current;
use function key;
class SqlServerTest extends TestCase
{
/**
* @testdox unit test / object test: Test SqlServer object has Select proxy
* @covers \Laminas\Db\Sql\Platform\SqlServer\SqlServer::__construct
*/
public function testConstruct()
{
$sqlServer = new SqlServer();
$decorators = $sqlServer->getDecorators();
$type = key($decorators);
$decorator = current($decorators);
self::assertEquals(Select::class, $type);
self::assertInstanceOf(SelectDecorator::class, $decorator);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/SqlServer/Ddl/CreateTableDecoratorTest.php | test/unit/Sql/Platform/SqlServer/Ddl/CreateTableDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\SqlServer\Ddl;
use Laminas\Db\Sql\Ddl\Column\Column;
use Laminas\Db\Sql\Ddl\CreateTable;
use Laminas\Db\Sql\Platform\SqlServer\Ddl\CreateTableDecorator;
use PHPUnit\Framework\TestCase;
class CreateTableDecoratorTest extends TestCase
{
/**
* @covers \Laminas\Db\Sql\Platform\SqlServer\Ddl\CreateTableDecorator::getSqlString
*/
public function testGetSqlString()
{
$ctd = new CreateTableDecorator();
$ct = new CreateTable('foo');
self::assertEquals("CREATE TABLE \"foo\" ( \n)", $ctd->setSubject($ct)->getSqlString());
$ct = new CreateTable('foo', true);
self::assertEquals("CREATE TABLE \"#foo\" ( \n)", $ctd->setSubject($ct)->getSqlString());
$ct = new CreateTable('foo');
$ct->addColumn(new Column('bar'));
self::assertEquals(
"CREATE TABLE \"foo\" ( \n \"bar\" INTEGER NOT NULL \n)",
$ctd->setSubject($ct)->getSqlString()
);
$ct = new CreateTable('foo', true);
$ct->addColumn(new Column('bar'));
self::assertEquals(
"CREATE TABLE \"#foo\" ( \n \"bar\" INTEGER NOT NULL \n)",
$ctd->setSubject($ct)->getSqlString()
);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Oracle/SelectDecoratorTest.php | test/unit/Sql/Platform/Oracle/SelectDecoratorTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Oracle;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Adapter\Driver\DriverInterface;
use Laminas\Db\Adapter\Driver\StatementInterface;
use Laminas\Db\Adapter\ParameterContainer;
use Laminas\Db\Adapter\Platform\Oracle as OraclePlatform;
use Laminas\Db\Sql\Platform\Oracle\SelectDecorator;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
class SelectDecoratorTest extends TestCase
{
/**
* @testdox integration test: Testing SelectDecorator will use Select to produce properly Oracle
* dialect prepared sql
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::prepareStatement
* @covers \Laminas\Db\Sql\Platform\SqlServer\SelectDecorator::processLimitOffset
* @dataProvider dataProvider
* @param mixed $notUsed
*/
public function testPrepareStatement(
Select $select,
string $expectedSql,
array $expectedParams,
$notUsed,
int $expectedFormatParamCount
) {
$driver = $this->getMockBuilder(DriverInterface::class)->getMock();
$driver->expects($this->exactly($expectedFormatParamCount))
->method('formatParameterName')
->will($this->returnValue('?'));
// test
$adapter = $this->getMockBuilder(Adapter::class)
->setMethods()
->setConstructorArgs([
$driver,
new OraclePlatform(),
])
->getMock();
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())
->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$statement->expects($this->once())->method('setSql')->with($expectedSql);
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
$selectDecorator->prepareStatement($adapter, $statement);
self::assertEquals($expectedParams, $parameterContainer->getNamedArray());
}
/**
* @testdox integration test: Testing SelectDecorator will use Select to produce properly Oracle
* dialect sql statements
* @covers \Laminas\Db\Sql\Platform\Oracle\SelectDecorator::getSqlString
* @dataProvider dataProvider
* @param mixed $ignored
* @param mixed $alsoIgnored
*/
public function testGetSqlString(Select $select, $ignored, $alsoIgnored, string $expectedSql)
{
$parameterContainer = new ParameterContainer();
$statement = $this->getMockBuilder(StatementInterface::class)->getMock();
$statement->expects($this->any())
->method('getParameterContainer')
->will($this->returnValue($parameterContainer));
$selectDecorator = new SelectDecorator();
$selectDecorator->setSubject($select);
self::assertEquals($expectedSql, $selectDecorator->getSqlString(new OraclePlatform()));
}
/**
* Data provider for testGetSqlString
*
* @psalm-return array<array-key, array{
* 0: Select,
* 1: string,
* 2: array<string, mixed>
* 3: string,
* 4: int
* }>
*/
public function dataProvider(): array
{
// phpcs:disable Generic.Files.LineLength.TooLong,WebimpressCodingStandard.NamingConventions.ValidVariableName.NotCamelCaps
$select0 = new Select();
$select0->from(['x' => 'foo']);
$expectedSql0 = 'SELECT "x".* FROM "foo" "x"';
$expectedFormatParamCount0 = 0;
$select1a = new Select('test');
$select1b = new Select(['a' => $select1a]);
$select1 = new Select(['b' => $select1b]);
$expectedSql1 = 'SELECT "b".* FROM (SELECT "a".* FROM (SELECT "test".* FROM "test") "a") "b"';
$expectedFormatParamCount1 = 0;
$select2a = new Select('test');
$select2a->limit(2);
$select2b = new Select(['a' => $select2a]);
$select2 = new Select(['b' => $select2b]);
$expectedSql2_1 = 'SELECT "b".* FROM (SELECT "a".* FROM (SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "test".* FROM "test" ) b WHERE rownum <= (:offset2+:limit2)) WHERE b_rownum >= (:offset2 + 1)) "a") "b"';
$expectedSql2_2 = 'SELECT "b".* FROM (SELECT "a".* FROM (SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "test".* FROM "test" ) b WHERE rownum <= (0+2)) WHERE b_rownum >= (0 + 1)) "a") "b"';
$expectedFormatParamCount2 = 0;
$expectedParams2 = ['offset2' => 0, 'limit2' => 2];
$select3a = new Select('test');
$select3a->offset(2);
$select3b = new Select(['a' => $select3a]);
$select3 = new Select(['b' => $select3b]);
$expectedSql3_1 = 'SELECT "b".* FROM (SELECT "a".* FROM (SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "test".* FROM "test" ) b ) WHERE b_rownum > (:offset2)) "a") "b"';
$expectedSql3_2 = 'SELECT "b".* FROM (SELECT "a".* FROM (SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "test".* FROM "test" ) b ) WHERE b_rownum > (2)) "a") "b"';
$expectedFormatParamCount3 = 0;
$expectedParams3 = ['offset2' => 2];
$select4a = new Select('test');
$select4a->limit(2);
$select4a->offset(2);
$select4b = new Select(['a' => $select4a]);
$select4 = new Select(['b' => $select4b]);
$expectedSql4_1 = 'SELECT "b".* FROM (SELECT "a".* FROM (SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "test".* FROM "test" ) b WHERE rownum <= (:offset2+:limit2)) WHERE b_rownum >= (:offset2 + 1)) "a") "b"';
$expectedSql4_2 = 'SELECT "b".* FROM (SELECT "a".* FROM (SELECT * FROM (SELECT b.*, rownum b_rownum FROM ( SELECT "test".* FROM "test" ) b WHERE rownum <= (2+2)) WHERE b_rownum >= (2 + 1)) "a") "b"';
$expectedFormatParamCount4 = 0;
$expectedParams4 = ['offset2' => 2, 'limit2' => 2];
return [
[$select0, $expectedSql0, [], $expectedSql0, $expectedFormatParamCount0],
[$select1, $expectedSql1, [], $expectedSql1, $expectedFormatParamCount1],
[$select2, $expectedSql2_1, $expectedParams2, $expectedSql2_2, $expectedFormatParamCount2],
[$select3, $expectedSql3_1, $expectedParams3, $expectedSql3_2, $expectedFormatParamCount3],
[$select4, $expectedSql4_1, $expectedParams4, $expectedSql4_2, $expectedFormatParamCount4],
];
// phpcs:enable Generic.Files.LineLength.TooLong,WebimpressCodingStandard.NamingConventions.ValidVariableName.NotCamelCaps
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
laminas/laminas-db | https://github.com/laminas/laminas-db/blob/1395efe76f7a20c322e78d1885efe103e5e291ff/test/unit/Sql/Platform/Oracle/OracleTest.php | test/unit/Sql/Platform/Oracle/OracleTest.php | <?php
namespace LaminasTest\Db\Sql\Platform\Oracle;
use Laminas\Db\Sql\Platform\Oracle\Oracle;
use Laminas\Db\Sql\Platform\Oracle\SelectDecorator;
use Laminas\Db\Sql\Select;
use PHPUnit\Framework\TestCase;
use function current;
use function key;
class OracleTest extends TestCase
{
/**
* @testdox unit test / object test: Test Mysql object has Select proxy
* @covers \Laminas\Db\Sql\Platform\Oracle\Oracle::__construct
*/
public function testConstruct()
{
$oracle = new Oracle();
$decorators = $oracle->getDecorators();
$type = key($decorators);
$decorator = current($decorators);
self::assertEquals(Select::class, $type);
self::assertInstanceOf(SelectDecorator::class, $decorator);
}
}
| php | BSD-3-Clause | 1395efe76f7a20c322e78d1885efe103e5e291ff | 2026-01-05T05:03:07.882669Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/rector.php | rector.php | <?php
declare(strict_types=1);
use Rector\Config\RectorConfig;
return RectorConfig::configure()
->withPaths([
__DIR__.'/src',
__DIR__.'/tests',
])
->withPreparedSets(
deadCode: true,
codeQuality: true,
codingStyle: true,
typeDeclarations: true,
privatization: true,
earlyReturn: true,
)
->withPhpSets();
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/workbench/app/Models/User.php | workbench/app/Models/User.php | <?php
namespace App\Models;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Mirror\Concerns\Impersonatable;
class User extends Authenticatable
{
use HasFactory, Impersonatable, Notifiable;
/**
* The attributes that are mass assignable.
*
* @var array<int, string>
*/
protected $fillable = [
'name',
'email',
'password',
];
/**
* The attributes that should be hidden for serialization.
*
* @var array<int, string>
*/
protected $hidden = [
'password',
'remember_token',
];
/**
* Get the attributes that should be cast.
*
* @return array<string, string>
*/
protected function casts(): array
{
return [
'email_verified_at' => 'datetime',
'password' => 'hashed',
];
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/workbench/database/factories/UserFactory.php | workbench/database/factories/UserFactory.php | <?php
namespace Database\Factories;
use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
/**
* @template TModel of User
*
* @extends Factory<TModel>
*/
class UserFactory extends \Orchestra\Testbench\Factories\UserFactory
{
/**
* The name of the factory's corresponding model.
*
* @var class-string<TModel>
*/
protected $model = User::class;
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/ImpersonationSession.php | src/ImpersonationSession.php | <?php
namespace Mirror;
use Illuminate\Contracts\Session\Session;
use Illuminate\Support\Carbon;
use Mirror\Exceptions\TamperedSessionException;
readonly class ImpersonationSession
{
/**
* The session key prefix for impersonation data.
*/
private const PREFIX = 'mirror.';
/**
* Session key for storing the impersonator's ID.
*/
private const IMPERSONATED_BY_KEY = self::PREFIX.'impersonated_by';
/**
* Session key for the impersonation flag.
*/
private const IMPERSONATING_KEY = self::PREFIX.'impersonating';
/**
* Session key for storing the guard name being used.
*/
private const GUARD_NAME_KEY = self::PREFIX.'guard_name';
/**
* Session key for storing the integrity hash.
*/
private const INTEGRITY_KEY = self::PREFIX.'integrity';
/**
* Session key for storing the start timestamp.
*/
private const STARTED_AT_KEY = self::PREFIX.'started_at';
/**
* Session key for storing the URL to redirect to when leaving impersonation.
*/
private const LEAVE_REDIRECT_URL_KEY = self::PREFIX.'leave_redirect_url';
public function __construct(
private Session $session,
private string $appKey
) {}
/**
* Store the impersonator's identifier in the session.
*/
public function setImpersonator(int|string $impersonatorId): self
{
$this->session->put(self::IMPERSONATED_BY_KEY, $impersonatorId);
return $this;
}
/**
* Get the impersonator's identifier from the session.
*/
public function getImpersonator(): int|string|null
{
return $this->session->get(self::IMPERSONATED_BY_KEY);
}
/**
* Mark the session as currently impersonating.
*/
public function markAsImpersonating(): self
{
$this->session->put(self::IMPERSONATING_KEY, true);
return $this;
}
/**
* Check if currently impersonating.
*/
public function isImpersonating(): bool
{
return $this->session->get(self::IMPERSONATING_KEY, false) === true;
}
/**
* Clear the impersonation flag from the session.
*/
public function clearImpersonatingFlag(): void
{
$this->session->forget(self::IMPERSONATING_KEY);
}
/**
* Clear the impersonator identifier from the session.
*/
public function clearImpersonator(): void
{
$this->session->forget(self::IMPERSONATED_BY_KEY);
}
/**
* Store the guard name being used for impersonation.
*/
public function setGuardName(string $guardName): self
{
$this->session->put(self::GUARD_NAME_KEY, $guardName);
return $this;
}
/**
* Get the guard name used for impersonation.
*/
public function getGuardName(): ?string
{
return $this->session->get(self::GUARD_NAME_KEY);
}
/**
* Clear the guard name from the session.
*/
public function clearGuardName(): void
{
$this->session->forget(self::GUARD_NAME_KEY);
}
/**
* Clear all impersonation data from the session.
*/
public function clear(): void
{
$this->clearImpersonatingFlag();
$this->clearImpersonator();
$this->clearGuardName();
$this->clearIntegrityHash();
$this->clearStartedAt();
$this->clearLeaveRedirectUrl();
}
/**
* Generate and store the integrity hash for the current session data.
*/
public function generateIntegrityHash(): self
{
$payload = $this->buildIntegrityPayload();
$hash = hash_hmac('sha256', $payload, $this->appKey);
$this->session->put(self::INTEGRITY_KEY, $hash);
return $this;
}
/**
* Verify the integrity of the session data.
*
* @throws TamperedSessionException
*/
public function verifyIntegrity(): void
{
if (! $this->isImpersonating()) {
return;
}
$storedHash = $this->session->get(self::INTEGRITY_KEY);
if (! $storedHash) {
$this->clear();
throw TamperedSessionException::detected();
}
$expectedHash = hash_hmac('sha256', $this->buildIntegrityPayload(), $this->appKey);
if (! hash_equals($storedHash, $expectedHash)) {
$this->clear();
throw TamperedSessionException::detected();
}
}
/**
* Build the payload for integrity hash verification.
*/
protected function buildIntegrityPayload(): string
{
return json_encode([
'impersonator' => $this->getImpersonator(),
'guard_name' => $this->getGuardName(),
'started_at' => $this->getStartedAt(),
'leave_redirect_url' => $this->getLeaveRedirectUrl(),
], JSON_THROW_ON_ERROR);
}
/**
* Clear the integrity hash from the session.
*/
protected function clearIntegrityHash(): void
{
$this->session->forget(self::INTEGRITY_KEY);
}
/**
* Set the impersonation start timestamp.
*/
public function setStartedAt(int $timestamp): self
{
$this->session->put(self::STARTED_AT_KEY, $timestamp);
return $this;
}
/**
* Get the impersonation start timestamp.
*/
public function getStartedAt(): ?int
{
/** @var ?int $value */
$value = $this->session->get(self::STARTED_AT_KEY);
return $value;
}
/**
* Clear the start timestamp from the session.
*/
protected function clearStartedAt(): void
{
$this->session->forget(self::STARTED_AT_KEY);
}
/**
* Check if the impersonation has expired based on TTL.
*/
public function isExpired(?int $ttl): bool
{
if ($ttl === null || ! $this->isImpersonating()) {
return false;
}
$startedAt = $this->getStartedAt();
if ($startedAt === null) {
return true;
}
/** @var int $timestamp */
$timestamp = Carbon::now()->timestamp;
return ($timestamp - $startedAt) > $ttl;
}
/**
* Set the URL to redirect to when leaving impersonation.
*/
public function setLeaveRedirectUrl(?string $url): self
{
if ($url !== null) {
$this->session->put(self::LEAVE_REDIRECT_URL_KEY, $url);
}
return $this;
}
/**
* Get the URL to redirect to when leaving impersonation.
*/
public function getLeaveRedirectUrl(): ?string
{
return $this->session->get(self::LEAVE_REDIRECT_URL_KEY);
}
/**
* Clear the leave redirect URL from the session.
*/
protected function clearLeaveRedirectUrl(): void
{
$this->session->forget(self::LEAVE_REDIRECT_URL_KEY);
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/MirrorServiceProvider.php | src/MirrorServiceProvider.php | <?php
namespace Mirror;
use Illuminate\Config\Repository;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Foundation\Application;
use Illuminate\Session\Store;
use Illuminate\Support\Facades\Blade;
use Illuminate\Support\Facades\Route;
use Illuminate\Support\ServiceProvider;
use Mirror\Facades\Mirror;
use Mirror\Http\Middleware\CheckImpersonationTtl;
use Mirror\Http\Middleware\PreventImpersonation;
use Mirror\Http\Middleware\RequireImpersonation;
class MirrorServiceProvider extends ServiceProvider
{
/**
* Register any application services.
*/
public function register(): void
{
$this->mergeConfigFrom(
__DIR__.'/../config/mirror.php', 'mirror'
);
$this->app->singleton(ImpersonationSession::class, fn (Application $app): ImpersonationSession => new ImpersonationSession(
$app->make(Store::class),
$app->make(Repository::class)->get('app.key'),
));
$this->app->singleton(Impersonator::class);
$this->app->alias(Impersonator::class, 'mirror');
}
/**
* Bootstrap any application services.
*/
public function boot(): void
{
$this->registerMiddlewares();
$this->registerBladeDirectives();
if ($this->app->runningInConsole()) {
$this->publishes([
__DIR__.'/../config/mirror.php' => config_path('mirror.php'),
], 'mirror');
}
}
/**
* Register the Mirror middlewares.
*/
protected function registerMiddlewares(): void
{
Route::aliasMiddleware('mirror.prevent', PreventImpersonation::class)
->aliasMiddleware('mirror.require', RequireImpersonation::class)
->aliasMiddleware('mirror.ttl', CheckImpersonationTtl::class);
}
/**
* Register the Mirror Blade directives.
*/
protected function registerBladeDirectives(): void
{
Blade::if('impersonating', fn (?string $guard = null): bool => $this->checkImpersonating($guard));
Blade::if('canImpersonate', fn (?string $guard = null): bool => $this->checkCanImpersonate($guard));
Blade::if('canBeImpersonated', fn (?Authenticatable $user = null, ?string $guard = null): bool => $this->checkCanBeImpersonated($user, $guard));
}
/**
* Check if the authenticated model is impersonating.
*/
protected function checkImpersonating(?string $guard): bool
{
if ($guard !== null) {
return session()->has('mirror.impersonating') && session('mirror.guard_name') === $guard;
}
return Mirror::isImpersonating();
}
/**
* Check if the authenticated model can impersonate.
*/
protected function checkCanImpersonate(?string $guard): bool
{
$user = auth($guard)->user();
if (! $user) {
return false;
}
// @phpstan-ignore-next-line function.alreadyNarrowedType
return method_exists($user, 'canImpersonate')
? $user->canImpersonate()
: true;
}
/**
* Check if the authenticated model can be impersonated.
*/
protected function checkCanBeImpersonated(?Authenticatable $user, ?string $guard): bool
{
if (! $user instanceof Authenticatable) {
$user = auth($guard)->user();
}
if (! $user) {
return false;
}
// @phpstan-ignore-next-line function.alreadyNarrowedType
return method_exists($user, 'canBeImpersonated')
? $user->canBeImpersonated()
: true;
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Impersonator.php | src/Impersonator.php | <?php
namespace Mirror;
use Illuminate\Auth\AuthManager;
use Illuminate\Auth\Recaller;
use Illuminate\Config\Repository;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Auth\Guard;
use Illuminate\Contracts\Auth\StatefulGuard;
use Illuminate\Http\Request;
use Illuminate\Support\Carbon;
use InvalidArgumentException;
use Mirror\Events\ImpersonationStarted;
use Mirror\Events\ImpersonationStopped;
use Mirror\Exceptions\ImpersonationException;
use Mirror\Exceptions\TamperedSessionException;
class Impersonator
{
/**
* Request-scoped cache for impersonator model
*/
private ?Authenticatable $impersonatorCache = null;
/**
* Cached configuration values
*/
private readonly bool $enabled;
/**
* Cached TTL value
*/
private readonly ?int $ttl;
/**
* Cached default redirect URL
*/
private readonly string $defaultRedirectUrl;
public function __construct(
private readonly AuthManager $auth,
private readonly ImpersonationSession $impersonationSession,
private readonly Repository $config,
private readonly Request $request,
) {
$this->enabled = $this->config->get('mirror.enabled', true);
$this->ttl = $this->config->get('mirror.ttl');
$this->defaultRedirectUrl = $this->config->get('mirror.default_redirect_url', '/');
}
/**
* Get the name of the guard currently being used.
*/
protected function getCurrentGuardName(): string
{
$defaultGuard = $this->auth->getDefaultDriver();
if ($this->auth->guard($defaultGuard)->check()) {
return $defaultGuard;
}
/** @var array<string> $guards */
$guards = $this->config->get('auth.guards', []);
foreach (array_keys($guards) as $guardName) {
if ($guardName === $defaultGuard) {
continue;
}
if ($this->auth->guard($guardName)->check()) {
return $guardName;
}
}
return $defaultGuard;
}
/**
* Get the authenticatable class name.
*/
protected function getAuthenticatableClass(): string
{
$defaultGuard = $this->config->get('auth.defaults.guard');
$guardProvider = $this->config->get(sprintf('auth.guards.%s.provider', $defaultGuard));
return $this->config->get(sprintf('auth.providers.%s.model', $guardProvider));
}
/**
* Start impersonating another user.
*
* @throws ImpersonationException
*/
public function start(Authenticatable $user, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null): ?string
{
$this->ensureImpersonationIsEnabled();
$this->ensureNotAlreadyImpersonating();
$guardName = $this->getCurrentGuardName();
$guard = $this->auth->guard($guardName);
/** @var Authenticatable $impersonator */
$impersonator = $guard->user();
$this->ensureCanImpersonate($impersonator);
$this->ensureCanBeImpersonated($user);
$this->impersonationSession
->setGuardName($guardName)
->setImpersonator($impersonator->getAuthIdentifier())
->setStartedAt((int) Carbon::now()->timestamp)
->setLeaveRedirectUrl($leaveRedirectUrl ?? $this->request->fullUrl())
->markAsImpersonating()
->generateIntegrityHash();
$guard->login($user);
$this->dispatchEventAfterResponse(
new ImpersonationStarted($impersonator, $user, $guardName)
);
return $startRedirectUrl;
}
/**
* Stop impersonating and restore the original user.
*
* @throws ImpersonationException
* @throws TamperedSessionException
*/
public function stop(): void
{
$this->ensureIsImpersonating();
$this->impersonationSession->verifyIntegrity();
$this->ensureNotExpired();
$this->performStop();
}
/**
* Force stop impersonation without checking TTL.
*
* @throws ImpersonationException
* @throws TamperedSessionException
*/
public function forceStop(): void
{
$this->ensureIsImpersonating();
$this->impersonationSession->verifyIntegrity();
$this->performStop();
}
/**
* Perform the actual stop operation - restore the original user.
*/
protected function performStop(): void
{
$session = $this->impersonationSession;
$impersonatorId = $session->getImpersonator();
/** @var string $guardName */
$guardName = $session->getGuardName();
$guard = $this->auth->guard($guardName);
$recaller = $this->recaller($guard);
/** @var Authenticatable $impersonatedUser */
$impersonatedUser = $guard->user();
$session->clear();
$guard->logout();
$remember = false;
if ($recaller instanceof Recaller && $recaller->valid()) {
$remember = $impersonatorId == $recaller->id();
}
$guard->loginUsingId($impersonatorId, $remember);
/** @var Authenticatable $impersonatorUser */
$impersonatorUser = $guard->user();
$this->dispatchEventAfterResponse(
new ImpersonationStopped($impersonatorUser, $impersonatedUser, $guardName)
);
$this->impersonatorCache = null;
}
/**
* Check if currently impersonating another user.
*/
public function isImpersonating(): bool
{
return $this->impersonationSession->isImpersonating();
}
/**
* Get the original user who initiated the impersonation.
*/
public function getImpersonator(): ?Authenticatable
{
if ($this->impersonatorCache instanceof Authenticatable) {
return $this->impersonatorCache;
}
$impersonatorId = $this->impersonationSession->getImpersonator();
if (! $impersonatorId) {
return null;
}
$class = $this->getAuthenticatableClass();
$this->impersonatorCache = $class::find($impersonatorId);
return $this->impersonatorCache;
}
/**
* Start impersonating a user by their primary key.
*
* @throws ImpersonationException
* @throws \InvalidArgumentException
*/
public function startByKey(int|string $key, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null): ?string
{
$class = $this->getAuthenticatableClass();
$user = $class::find($key);
if (! $user) {
throw new \InvalidArgumentException(sprintf('User with key [%s] not found.', $key));
}
return $this->start($user, $leaveRedirectUrl, $startRedirectUrl);
}
/**
* Start impersonating a user by their email address.
*
* @throws ImpersonationException
* @throws \InvalidArgumentException
*/
public function startByEmail(string $email, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null): ?string
{
$class = $this->getAuthenticatableClass();
$user = $class::query()->where('email', $email)->first();
if (! $user) {
throw new \InvalidArgumentException(sprintf('User with email [%s] not found.', $email));
}
return $this->start($user, $leaveRedirectUrl, $startRedirectUrl);
}
/**
* Get the impersonator's ID.
*/
public function impersonatorId(): int|string|null
{
return $this->impersonationSession->getImpersonator();
}
/**
* Alias for start().
*
* @throws ImpersonationException
*/
public function as(Authenticatable $user, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null): ?string
{
return $this->start($user, $leaveRedirectUrl, $startRedirectUrl);
}
/**
* Alias for stop().
*
* @throws ImpersonationException
* @throws TamperedSessionException
*/
public function leave(): void
{
$this->stop();
}
/**
* Alias for isImpersonating().
*/
public function impersonating(): bool
{
return $this->isImpersonating();
}
/**
* Alias for getImpersonator().
*/
public function impersonator(): ?Authenticatable
{
return $this->getImpersonator();
}
/**
* Get the URL to redirect to when leaving impersonation.
*/
public function getLeaveRedirectUrl(): ?string
{
return $this->impersonationSession->getLeaveRedirectUrl();
}
/**
* Check if the impersonation session has expired
*/
public function isExpired(): bool
{
return $this->impersonationSession->isExpired($this->ttl);
}
/**
* Get the TTL configuration value
*/
public function getTtl(): ?int
{
return $this->ttl;
}
/**
* Get the default redirect URL
*/
public function getDefaultRedirectUrl(): string
{
return $this->defaultRedirectUrl;
}
/**
* Ensure impersonation is enabled in config.
*
* @throws ImpersonationException
*/
protected function ensureImpersonationIsEnabled(): void
{
if (! $this->enabled) {
throw ImpersonationException::notEnabled();
}
}
/**
* Ensure the user is not already impersonating.
*
* @throws ImpersonationException
*/
protected function ensureNotAlreadyImpersonating(): void
{
if ($this->isImpersonating()) {
throw ImpersonationException::alreadyImpersonating();
}
}
/**
* Ensure the user is currently impersonating.
*
* @throws ImpersonationException
*/
protected function ensureIsImpersonating(): void
{
if (! $this->isImpersonating()) {
throw ImpersonationException::notImpersonating();
}
}
/**
* Ensure the impersonation has not expired.
*
* @throws ImpersonationException
*/
protected function ensureNotExpired(): void
{
if ($this->impersonationSession->isExpired($this->ttl)) {
$this->impersonationSession->clear();
throw ImpersonationException::expired();
}
}
/**
* Ensure the impersonator can impersonate other users.
*
* @throws ImpersonationException
*/
protected function ensureCanImpersonate(?Authenticatable $impersonator): void
{
if (! $impersonator instanceof Authenticatable) {
throw ImpersonationException::cannotImpersonate();
}
// @phpstan-ignore-next-line function.alreadyNarrowedType
if (method_exists($impersonator, 'canImpersonate') && ! $impersonator->canImpersonate()) {
throw ImpersonationException::cannotImpersonate();
}
}
/**
* Ensure the target user can be impersonated.
*
* @throws ImpersonationException
*/
protected function ensureCanBeImpersonated(Authenticatable $user): void
{
// @phpstan-ignore-next-line function.alreadyNarrowedType
if (method_exists($user, 'canBeImpersonated') && ! $user->canBeImpersonated()) {
throw ImpersonationException::cannotBeImpersonated();
}
}
/**
* Dispatch an event after the response is sent
*
* @param ImpersonationStarted|ImpersonationStopped $event
*
* @throws InvalidArgumentException
*/
protected function dispatchEventAfterResponse(object $event): void
{
$result = match ($event::class) {
ImpersonationStarted::class => ImpersonationStarted::dispatch(
$event->impersonator,
$event->impersonated,
$event->guardName
),
ImpersonationStopped::class => ImpersonationStopped::dispatch(
$event->impersonator,
$event->impersonated,
$event->guardName
),
default => throw new InvalidArgumentException(sprintf('Unknown event class: %s', $event::class)),
};
if (is_object($result) && method_exists($result, 'afterResponse')) {
$result->afterResponse();
}
}
/**
* Get the decrypted recaller cookie for the request.
*/
protected function recaller(Guard|StatefulGuard $guard): ?Recaller
{
if (
// @phpstan-ignore-next-line function.alreadyNarrowedType
! is_callable([$guard, 'getRequest'])
// @phpstan-ignore-next-line function.alreadyNarrowedType
|| ! is_callable([$guard, 'getRecallerName'])
// @phpstan-ignore-next-line function.impossibleType
|| is_null($guard->getRequest())
) {
return null;
}
if ($recaller = $guard->getRequest()->cookies->get($guard->getRecallerName())) {
return new Recaller($recaller);
}
return null;
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Exceptions/ImpersonationException.php | src/Exceptions/ImpersonationException.php | <?php
namespace Mirror\Exceptions;
use Exception;
class ImpersonationException extends Exception
{
public static function notEnabled(): self
{
return new self('Impersonation is not enabled.');
}
public static function alreadyImpersonating(): self
{
return new self('You are already impersonating a user. Please stop the current impersonation before starting a new one.');
}
public static function notImpersonating(): self
{
return new self('You are not impersonating any user.');
}
public static function cannotImpersonate(): self
{
return new self('You do not have permission to impersonate users.');
}
public static function cannotBeImpersonated(): self
{
return new self('This user cannot be impersonated.');
}
public static function expired(): self
{
return new self('The impersonation session has expired.');
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Exceptions/TamperedSessionException.php | src/Exceptions/TamperedSessionException.php | <?php
namespace Mirror\Exceptions;
class TamperedSessionException extends ImpersonationException
{
public static function detected(): self
{
return new self('Impersonation session data has been tampered with. For security reasons, the session has been cleared.');
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Http/Middleware/RequireImpersonation.php | src/Http/Middleware/RequireImpersonation.php | <?php
namespace Mirror\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Mirror\Facades\Mirror;
use Symfony\Component\HttpFoundation\Response;
class RequireImpersonation
{
/**
* Handle an incoming request.
*
* @param Closure(Request): (Response) $next
*/
public function handle(Request $request, Closure $next): Response
{
if (! Mirror::isImpersonating()) {
abort(403, 'This action requires active impersonation.');
}
return $next($request);
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Http/Middleware/CheckImpersonationTtl.php | src/Http/Middleware/CheckImpersonationTtl.php | <?php
namespace Mirror\Http\Middleware;
use Closure;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Mirror\Exceptions\ImpersonationException;
use Mirror\Impersonator;
use Symfony\Component\HttpFoundation\Response;
readonly class CheckImpersonationTtl
{
public function __construct(
private Impersonator $impersonator
) {}
/**
* Handle an incoming request.
*
* @param Closure(Request): (Response) $next
*
* @throws ImpersonationException
*/
public function handle(Request $request, Closure $next): Response
{
if (! $this->impersonator->isImpersonating()) {
return $next($request);
}
if ($this->impersonator->isExpired()) {
$redirectUrl = $this->impersonator->getLeaveRedirectUrl()
?? $this->impersonator->getDefaultRedirectUrl();
$this->impersonator->forceStop();
/** @var RedirectResponse $response */
$response = redirect($redirectUrl);
return $response->with('warning', 'Your impersonation session has expired and you have been returned to your original account.');
}
return $next($request);
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Http/Middleware/PreventImpersonation.php | src/Http/Middleware/PreventImpersonation.php | <?php
namespace Mirror\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Mirror\Facades\Mirror;
use Symfony\Component\HttpFoundation\Response;
class PreventImpersonation
{
/**
* Handle an incoming request.
*
* @param Closure(Request): (Response) $next
*/
public function handle(Request $request, Closure $next): Response
{
if (Mirror::isImpersonating()) {
abort(403, 'This action is not allowed while impersonating another user.');
}
return $next($request);
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Facades/Mirror.php | src/Facades/Mirror.php | <?php
namespace Mirror\Facades;
use Illuminate\Support\Facades\Facade;
/**
* @method static ?string start(\Illuminate\Contracts\Auth\Authenticatable $user, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null)
* @method static ?string startByKey(int|string $key, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null)
* @method static ?string startByEmail(string $email, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null)
* @method static void stop()
* @method static void forceStop()
* @method static bool isImpersonating()
* @method static \Illuminate\Contracts\Auth\Authenticatable|null getImpersonator()
* @method static ?string getLeaveRedirectUrl()
* @method static int|string|null impersonatorId()
* @method static ?string as(\Illuminate\Contracts\Auth\Authenticatable $user, ?string $leaveRedirectUrl = null, ?string $startRedirectUrl = null)
* @method static void leave()
* @method static bool impersonating()
* @method static \Illuminate\Contracts\Auth\Authenticatable|null impersonator()
*
* @throws \Mirror\Exceptions\ImpersonationException
*
* @see \Mirror\Impersonator
*/
class Mirror extends Facade
{
/**
* Get the registered name of the component.
*/
protected static function getFacadeAccessor(): string
{
return 'mirror';
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Concerns/Impersonatable.php | src/Concerns/Impersonatable.php | <?php
namespace Mirror\Concerns;
/**
* @phpstan-ignore trait.unused
*/
trait Impersonatable
{
/**
* Determine if the user can impersonate other users.
*/
public function canImpersonate(): bool
{
return true;
}
/**
* Determine if the user can be impersonated by other users.
*/
public function canBeImpersonated(): bool
{
return true;
}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Events/ImpersonationStarted.php | src/Events/ImpersonationStarted.php | <?php
namespace Mirror\Events;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
class ImpersonationStarted
{
use Dispatchable;
use InteractsWithSockets;
use SerializesModels;
/**
* Create a new event instance.
*/
public function __construct(
public Authenticatable $impersonator,
public Authenticatable $impersonated,
public string $guardName,
) {}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/src/Events/ImpersonationStopped.php | src/Events/ImpersonationStopped.php | <?php
namespace Mirror\Events;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
class ImpersonationStopped
{
use Dispatchable;
use InteractsWithSockets;
use SerializesModels;
/**
* Create a new event instance.
*/
public function __construct(
public Authenticatable $impersonator,
public Authenticatable $impersonated,
public string $guardName,
) {}
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Pest.php | tests/Pest.php | <?php
use Mirror\Tests\TestCase;
/*
|--------------------------------------------------------------------------
| Test Case
|--------------------------------------------------------------------------
|
| The closure you provide to your test functions is always bound to a specific PHPUnit test
| case class. By default, that class is "PHPUnit\Framework\TestCase". Of course, you may
| need to change it using the "pest()" function to bind a different classes or traits.
|
*/
pest()->extend(TestCase::class)
->use(Illuminate\Foundation\Testing\RefreshDatabase::class)
->in('Feature');
pest()->extend(TestCase::class)
->in('Unit');
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/TestCase.php | tests/TestCase.php | <?php
namespace Mirror\Tests;
use Orchestra\Testbench\Attributes\WithMigration;
use Orchestra\Testbench\Concerns\WithWorkbench;
use Orchestra\Testbench\TestCase as BaseTestCase;
#[WithMigration]
abstract class TestCase extends BaseTestCase
{
use WithWorkbench;
}
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Feature/ImpersonatorTest.php | tests/Feature/ImpersonatorTest.php | <?php
use App\Models\User;
use Carbon\Carbon;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Auth\StatefulGuard;
use Illuminate\Events\Dispatcher as EventsDispatcher;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Route;
use Illuminate\Support\Facades\Session;
use Mirror\Events\ImpersonationStarted;
use Mirror\Events\ImpersonationStopped;
use Mirror\Exceptions\ImpersonationException;
use Mirror\Exceptions\TamperedSessionException;
use Mirror\Facades\Mirror;
use Mirror\Impersonator;
use Mockery\MockInterface;
use function Pest\Laravel\actingAs;
it('start successfully impersonates user and dispatches event', function (): void {
Event::fake();
$admin = User::factory()->create(['email' => 'admin@test.com']);
$targetUser = User::factory()->create(['email' => 'user@test.com']);
actingAs($admin);
expect(Auth::id())->toBe($admin->id)
->and(Mirror::isImpersonating())->toBeFalse();
$redirectUrl = Mirror::start($targetUser);
expect($redirectUrl)->toBeNull()
->and(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue()
->and(Mirror::impersonatorId())->toBe($admin->id);
Event::assertDispatched(ImpersonationStarted::class, fn ($event): bool => $event->impersonator->id === $admin->id
&& $event->impersonated->id === $targetUser->id
&& $event->guardName === 'web');
});
it('start accepts custom leave and enter redirect URLs', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
$redirectUrl = Mirror::start($targetUser, '/admin/users', '/dashboard');
expect($redirectUrl)->toBe('/dashboard')
->and(Mirror::getLeaveRedirectUrl())->toBe('/admin/users')
->and(Auth::id())->toBe($targetUser->id);
});
it('start throws exception when impersonation is disabled in config', function (): void {
Config::set('mirror.enabled', false);
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
})->throws(ImpersonationException::class, 'Impersonation is not enabled');
it('start throws exception when already impersonating another user', function (): void {
$admin = User::factory()->create();
$user1 = User::factory()->create();
$user2 = User::factory()->create();
actingAs($admin);
Mirror::start($user1);
Mirror::start($user2);
})->throws(ImpersonationException::class, 'already impersonating');
it('start throws exception when impersonator lacks canImpersonate permission', function (): void {
$targetUser = User::factory()->create();
$adminWithRestriction = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canImpersonate')
->andReturn(false);
});
actingAs($adminWithRestriction);
Mirror::start($targetUser);
})->throws(ImpersonationException::class, 'do not have permission to impersonate');
it('start throws exception when target user has canBeImpersonated set to false', function (): void {
$admin = User::factory()->create();
actingAs($admin);
$restrictedUser = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canBeImpersonated')
->andReturn(false);
});
Mirror::start($restrictedUser);
})->throws(ImpersonationException::class, 'cannot be impersonated');
it('start stores all impersonation data in session with integrity hash', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
expect(Session::has('mirror.impersonating'))->toBeTrue()
->and(Session::get('mirror.impersonated_by'))->toBe($admin->id)
->and(Session::get('mirror.guard_name'))->toBe('web')
->and(Session::has('mirror.started_at'))->toBeTrue()
->and(Session::has('mirror.integrity'))->toBeTrue();
});
it('stop ends impersonation and restores original user', function (): void {
Event::fake();
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
expect(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue();
Mirror::stop();
expect(Auth::id())->toBe($admin->id)
->and(Mirror::isImpersonating())->toBeFalse()
->and(Mirror::impersonatorId())->toBeNull();
Event::assertDispatched(ImpersonationStopped::class, fn ($event): bool => $event->impersonator->id === $admin->id
&& $event->impersonated->id === $targetUser->id
&& $event->guardName === 'web');
});
it('stop throws exception when not currently impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
Mirror::stop();
})->throws(ImpersonationException::class, 'not impersonating any user');
it('stop throws exception when impersonation session TTL has expired', function (): void {
Config::set('mirror.ttl', 3600);
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
// Travel forward in time past the TTL
Carbon::setTestNow(Carbon::now()->addSeconds(3601));
Mirror::stop();
})->throws(ImpersonationException::class, 'session has expired');
it('stop clears all impersonation data from session', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
Mirror::stop();
expect(Session::has('mirror.impersonating'))->toBeFalse()
->and(Session::has('mirror.impersonated_by'))->toBeFalse()
->and(Session::has('mirror.guard_name'))->toBeFalse()
->and(Session::has('mirror.started_at'))->toBeFalse()
->and(Session::has('mirror.integrity'))->toBeFalse()
->and(Session::has('mirror.leave_redirect_url'))->toBeFalse();
});
it('stop throws exception when session integrity hash is tampered with', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
Session::put('mirror.impersonated_by', 999);
Mirror::stop();
})->throws(TamperedSessionException::class, 'tampered');
it('forceStop ends impersonation without validating TTL expiration', function (): void {
Config::set('mirror.ttl', 3600);
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
// Travel forward in time past the TTL
Carbon::setTestNow(Carbon::now()->addSeconds(3601));
Mirror::forceStop();
expect(Auth::id())->toBe($admin->id)
->and(Mirror::isImpersonating())->toBeFalse();
});
it('forceStop throws exception when not currently impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
Mirror::forceStop();
})->throws(ImpersonationException::class, 'not impersonating any user');
it('isImpersonating returns true when actively impersonating a user', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
expect(Mirror::isImpersonating())->toBeTrue()
->and(Mirror::impersonating())->toBeTrue();
});
it('isImpersonating returns false when not impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
expect(Mirror::isImpersonating())->toBeFalse()
->and(Mirror::impersonating())->toBeFalse();
});
it('getImpersonator returns original user model when impersonating', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
$impersonator = Mirror::getImpersonator();
expect($impersonator)->not->toBeNull()
->and($impersonator->id)->toBe($admin->id)
->and($impersonator->email)->toBe($admin->email);
$impersonatorAlias = Mirror::impersonator();
expect($impersonatorAlias->id)->toBe($admin->id);
});
it('getImpersonator returns null when not impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
expect(Mirror::getImpersonator())->toBeNull()
->and(Mirror::impersonator())->toBeNull();
});
it('startByKey finds and impersonates user by their primary key', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
$redirectUrl = Mirror::startByKey($targetUser->id);
expect($redirectUrl)->toBeNull()
->and(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue();
});
it('startByKey throws exception when user with given key does not exist', function (): void {
$admin = User::factory()->create();
actingAs($admin);
Mirror::startByKey(99999);
})->throws(InvalidArgumentException::class, 'User with key [99999] not found');
it('startByEmail finds and impersonates user by their email address', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create(['email' => 'target@example.com']);
actingAs($admin);
$redirectUrl = Mirror::startByEmail('target@example.com');
expect($redirectUrl)->toBeNull()
->and(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue();
});
it('startByEmail throws exception when user with given email does not exist', function (): void {
$admin = User::factory()->create();
actingAs($admin);
Mirror::startByEmail('notfound@example.com');
})->throws(InvalidArgumentException::class, 'User with email [notfound@example.com] not found');
it('impersonatorId returns original user ID when impersonating', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
expect(Mirror::impersonatorId())->toBe($admin->id);
});
it('impersonatorId returns null when not impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
expect(Mirror::impersonatorId())->toBeNull();
});
it('as() method is an alias for start() with same behavior', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
$result = Mirror::as($targetUser, '/admin', '/dashboard');
expect($result)->toBe('/dashboard')
->and(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue();
});
it('leave() method is an alias for stop() with same behavior', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
Mirror::leave();
expect(Auth::id())->toBe($admin->id)
->and(Mirror::isImpersonating())->toBeFalse();
});
it('getLeaveRedirectUrl returns URL where user will return after stopping impersonation', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser, '/admin/users');
expect(Mirror::getLeaveRedirectUrl())->toBe('/admin/users');
});
it('getLeaveRedirectUrl captures current URL when no explicit leave URL is provided', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
$leaveUrl = Mirror::getLeaveRedirectUrl();
expect($leaveUrl)->not->toBeNull()
->and($leaveUrl)->toBeString();
});
it('getLeaveRedirectUrl returns null when not impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
expect(Mirror::getLeaveRedirectUrl())->toBeNull();
});
it('allows impersonating multiple users sequentially after stopping each session', function (): void {
$admin = User::factory()->create();
$user1 = User::factory()->create();
$user2 = User::factory()->create();
actingAs($admin);
Mirror::start($user1);
expect(Auth::id())->toBe($user1->id);
Mirror::stop();
expect(Auth::id())->toBe($admin->id);
Mirror::start($user2);
expect(Auth::id())->toBe($user2->id);
Mirror::stop();
expect(Auth::id())->toBe($admin->id);
});
it('start generates 64-character integrity hash to prevent session tampering', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
$hash = Session::get('mirror.integrity');
expect($hash)->not->toBeNull()
->and($hash)->toBeString()
->and(strlen((string) $hash))->toBe(64);
});
it('stop verifies session integrity hash has not been tampered with', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
Mirror::stop();
expect(Auth::id())->toBe($admin->id);
});
it('start throws exception when impersonator is not authenticated', function (): void {
$targetUser = User::factory()->create();
expect(auth()->check())->toBeFalse();
Mirror::start($targetUser);
})->throws(ImpersonationException::class, 'do not have permission to impersonate');
it('start uses default guard when starting impersonation', function (): void {
Config::set('auth.defaults.guard', 'web');
Config::set('auth.guards', [
'web' => ['driver' => 'session', 'provider' => 'users'],
'api' => ['driver' => 'token', 'provider' => 'users'],
]);
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin, 'web');
Mirror::start($targetUser);
expect(Mirror::isImpersonating())->toBeTrue()
->and(auth()->id())->toBe($targetUser->id);
});
it('start finds authenticated user in default guard when starting impersonation', function (): void {
Config::set('auth.defaults.guard', 'web');
Config::set('auth.guards', [
'web' => ['driver' => 'session', 'provider' => 'users'],
'api' => ['driver' => 'token', 'provider' => 'users'],
'admin' => ['driver' => 'session', 'provider' => 'users'],
]);
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin, 'web');
$redirectUrl = Mirror::start($targetUser);
expect($redirectUrl)->toBeNull()
->and(Mirror::isImpersonating())->toBeTrue()
->and(auth('web')->id())->toBe($targetUser->id);
});
it('start searches through all configured guards to find authenticated user', function (): void {
Config::set('auth.defaults.guard', 'web');
Config::set('auth.guards', [
'web' => ['driver' => 'session', 'provider' => 'users'],
'api' => ['driver' => 'session', 'provider' => 'users'],
'admin' => ['driver' => 'session', 'provider' => 'users'],
]);
$admin = User::factory()->create();
$user = User::factory()->create();
auth('admin')->login($admin);
auth('web')->logout();
expect(auth('web')->check())->toBeFalse()
->and(auth('admin')->check())->toBeTrue();
$redirectUrl = Mirror::start($user);
expect($redirectUrl)->toBeNull()
->and(Mirror::isImpersonating())->toBeTrue()
->and(auth('admin')->id())->toBe($user->id);
});
it('start dispatches events with afterResponse hook for queued listeners', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
Mirror::stop();
expect(Mirror::isImpersonating())->toBeFalse();
});
it('invokes dispatcher afterResponse hook when available', function (): void {
$dispatcher = new class(app()) extends EventsDispatcher
{
public bool $afterResponseCalled = false;
public function dispatch($event, $payload = [], $halt = false): mixed
{
return new class($this)
{
public function __construct(private readonly EventsDispatcher $tracker) {}
public function afterResponse(): void
{
$this->tracker->afterResponseCalled = true;
}
};
}
};
$originalDispatcher = Event::getFacadeRoot();
Event::swap($dispatcher);
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
expect($dispatcher->afterResponseCalled)->toBeTrue();
Event::swap($originalDispatcher);
});
it('dispatchEventAfterResponse throws exception for unknown event class', function (): void {
$admin = User::factory()->create();
actingAs($admin);
$impersonator = app(Impersonator::class);
$unknownEvent = new class
{
public string $impersonator = 'admin';
public string $impersonated = 'user';
public string $guardName = 'web';
};
$reflection = new ReflectionClass($impersonator);
$method = $reflection->getMethod('dispatchEventAfterResponse');
$method->invoke($impersonator, $unknownEvent);
})->throws(InvalidArgumentException::class, 'Unknown event class');
it('start dispatches ImpersonationStarted event', function (): void {
Event::fake();
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
Event::assertDispatched(ImpersonationStarted::class);
});
it('stop dispatches ImpersonationStopped event', function (): void {
Event::fake();
$admin = User::factory()->create();
$targetUser = User::factory()->create();
actingAs($admin);
Mirror::start($targetUser);
Mirror::stop();
Event::assertDispatched(ImpersonationStopped::class);
});
it('getImpersonator caches model in memory to avoid repeated database queries', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
DB::enableQueryLog();
DB::flushQueryLog();
// should query database
$impersonator1 = Mirror::getImpersonator();
$firstCallQueries = count(DB::getQueryLog());
expect($firstCallQueries)->toBeGreaterThan(0)
->and($impersonator1)->not->toBeNull()
->and($impersonator1->id)->toBe($admin->id);
// should now use the cached value
$impersonator2 = Mirror::getImpersonator();
$impersonator3 = Mirror::getImpersonator();
$totalQueries = count(DB::getQueryLog());
expect($impersonator2)->toBe($impersonator1)
->and($impersonator3)->toBe($impersonator1)
->and($totalQueries)->toBe($firstCallQueries);
});
it('getImpersonator returns identical instance across multiple calls within request', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$call1 = Mirror::getImpersonator();
$call2 = Mirror::getImpersonator();
$call3 = Mirror::getImpersonator();
expect($call1)->toBe($call2)
->and($call2)->toBe($call3);
});
it('getImpersonator cache is cleared when impersonation stops to allow new sessions', function (): void {
$admin = User::factory()->create();
$user1 = User::factory()->create();
$user2 = User::factory()->create();
actingAs($admin);
Mirror::start($user1);
$firstImpersonator = Mirror::getImpersonator();
Mirror::stop();
Mirror::start($user2);
$secondImpersonator = Mirror::getImpersonator();
expect($firstImpersonator->id)->toBe($admin->id)
->and($secondImpersonator->id)->toBe($admin->id)
->and($firstImpersonator)->not->toBe($secondImpersonator);
});
it('impersonatorId retrieves ID from session without database query', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
DB::enableQueryLog();
DB::flushQueryLog();
$id = Mirror::impersonatorId();
expect(DB::getQueryLog())->toHaveCount(0)
->and($id)->toBe($admin->id);
});
it('impersonatorId is more efficient than getImpersonator()->id for ID-only needs', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$impersonator = app(Impersonator::class);
DB::enableQueryLog();
DB::flushQueryLog();
$idDirect = Mirror::impersonatorId();
$directQueries = count(DB::getQueryLog());
expect($directQueries)->toBe(0);
DB::flushQueryLog();
$idViaModel = Mirror::getImpersonator()->id;
$modelQueries = count(DB::getQueryLog());
expect($modelQueries)->toBeGreaterThan(0)
->and($idDirect)->toBe($idViaModel);
});
it('Impersonator caches TTL config value at instantiation time', function (): void {
Config::set('mirror.ttl', 3600);
$impersonator = app(Impersonator::class);
Config::set('mirror.ttl', 7200);
expect($impersonator->getTtl())->toBe(3600);
});
it('Impersonator caches default redirect URL config value at instantiation time', function (): void {
Config::set('mirror.default_redirect_url', '/admin');
$impersonator = app(Impersonator::class);
Config::set('mirror.default_redirect_url', '/dashboard');
expect($impersonator->getDefaultRedirectUrl())->toBe('/admin');
});
it('Impersonator returns same cached config values across multiple getter calls', function (): void {
Config::set('mirror.ttl', 1800);
Config::set('mirror.default_redirect_url', '/home');
$impersonator = app(Impersonator::class);
$ttl1 = $impersonator->getTtl();
$ttl2 = $impersonator->getTtl();
$url1 = $impersonator->getDefaultRedirectUrl();
$url2 = $impersonator->getDefaultRedirectUrl();
expect($ttl1)->toBe($ttl2)
->and($ttl1)->toBe(1800)
->and($url1)->toBe($url2)
->and($url1)->toBe('/home');
});
it('isExpired uses cached TTL value for consistent results within request', function (): void {
Config::set('mirror.ttl', 3600);
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$expired1 = Mirror::isExpired();
$expired2 = Mirror::isExpired();
$expired3 = Mirror::isExpired();
expect($expired1)->toBe($expired2)
->and($expired2)->toBe($expired3)
->and($expired1)->toBeFalse();
});
it('isExpired can detect expired sessions without throwing exceptions', function (): void {
Config::set('mirror.ttl', 1);
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
sleep(2);
$expired = Mirror::isExpired();
expect($expired)->toBeTrue();
});
it('Mirror facade reuses single Impersonator instance for multiple method calls', function (): void {
Config::set('mirror.ttl', 3600);
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$isImpersonating = Mirror::isImpersonating();
$isExpired = Mirror::isExpired();
$leaveUrl = Mirror::getLeaveRedirectUrl();
$defaultUrl = Mirror::getDefaultRedirectUrl();
expect($isImpersonating)->toBeTrue()
->and($isExpired)->toBeFalse()
->and($leaveUrl)->toBeString()
->and($defaultUrl)->toBeString();
});
it('isImpersonating returns quickly without database queries when not impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
DB::enableQueryLog();
DB::flushQueryLog();
$isImpersonating = Mirror::isImpersonating();
expect($isImpersonating)->toBeFalse()
->and(DB::getQueryLog())->toHaveCount(0);
});
it('start checks default guard first before iterating other guards', function (): void {
Config::set('auth.defaults.guard', 'web');
$admin = User::factory()->create();
actingAs($admin, 'web');
expect(auth('web')->check())->toBeTrue();
});
it('start only iterates other guards when default guard has no authenticated user', function (): void {
Config::set('auth.defaults.guard', 'web');
Config::set('auth.guards', [
'web' => ['driver' => 'session', 'provider' => 'users'],
'api' => ['driver' => 'token', 'provider' => 'users'],
'admin' => ['driver' => 'session', 'provider' => 'users'],
]);
$admin = User::factory()->create();
actingAs($admin, 'web');
// should use web without checking api or admin
expect(auth()->getDefaultDriver())->toBe('web')
->and(auth('web')->check())->toBeTrue();
});
it('multiple impersonation checks do not multiply database queries due to caching', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
DB::enableQueryLog();
DB::flushQueryLog();
$check1 = Mirror::isImpersonating();
$id1 = Mirror::impersonatorId();
$imp1 = Mirror::getImpersonator();
$check2 = Mirror::isImpersonating();
$id2 = Mirror::impersonatorId();
$imp2 = Mirror::getImpersonator();
$queries = DB::getQueryLog();
// should only query once
expect($check1)->toBeTrue()
->and($check2)->toBeTrue()
->and($id1)->toBe($admin->id)
->and($id2)->toBe($admin->id)
->and($imp1)->toBe($imp2)
->and(count($queries))->toBeLessThanOrEqual(1);
});
it('isImpersonating can be called many times with minimal session reads', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$checks = [];
for ($i = 0; $i < 10; $i++) {
$checks[] = Mirror::isImpersonating();
}
expect(array_unique($checks))->toHaveCount(1)
->and($checks[0])->toBeTrue();
});
it('remembers the "remember" cookie of the impersonator\'s original session', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
// Create route so we can check the cookies
Route::post('/stop', function (): Response {
Mirror::stop();
$guard = Auth::guard('web');
expect($guard->getCookieJar()->hasQueued($guard->getRecallerName()))
->toBeTrue();
return response('ok');
});
$guard = Auth::guard('web');
$remember = true;
$guard->login($admin, $remember);
Mirror::start($targetUser);
expect(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue()
->and(Mirror::impersonatorId())->toBe($admin->id);
$cookies = [
$guard->getRecallerName() => $admin->getAuthIdentifier().'|'.$admin->getRememberToken().'|'.$admin->getAuthPassword(),
];
$this->actingAs($targetUser, 'web')->call('POST', '/stop', [], $cookies);
expect(Auth::id())->toBe($admin->id)
->and(Mirror::isImpersonating())->toBeFalse();
});
it('doesnt set the "remember" cookie if the impersonator\'s original session didnt have it', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
// Create route so we can check the cookies
Route::post('/stop', function (): Response {
Mirror::stop();
$guard = Auth::guard('web');
expect($guard->getCookieJar()->hasQueued($guard->getRecallerName()))
->toBeFalse();
return response('ok');
});
$guard = Auth::guard('web');
$guard->login($admin);
Mirror::start($targetUser);
expect(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue()
->and(Mirror::impersonatorId())->toBe($admin->id);
$this->actingAs($targetUser, 'web')->post('/stop');
expect(Auth::id())->toBe($admin->id)
->and(Mirror::isImpersonating())->toBeFalse();
});
it('recaller returns null if the guard doesnt have getRequest or getRecallerName method', function (): void {
$admin = User::factory()->create();
$targetUser = User::factory()->create();
$fakeGuard = new class($admin, $targetUser) implements StatefulGuard
{
private ?Authenticatable $currentUser;
public bool $loginUsingIdRememberFlag = true;
public function __construct(
private readonly Authenticatable $impersonator,
private readonly Authenticatable $impersonated,
) {
$this->currentUser = $this->impersonated;
}
public function check(): bool
{
return $this->currentUser instanceof \Illuminate\Contracts\Auth\Authenticatable;
}
public function guest(): bool
{
return ! $this->check();
}
public function user(): ?Authenticatable
{
return $this->currentUser;
}
public function id(): int|string|null
{
return $this->currentUser?->getAuthIdentifier();
}
public function validate(array $credentials = []): bool
{
return false;
}
public function setUser(Authenticatable $user): static
{
$this->currentUser = $user;
return $this;
}
public function hasUser(): bool
{
return $this->currentUser instanceof \Illuminate\Contracts\Auth\Authenticatable;
}
public function attempt(array $credentials = [], $remember = false): bool
{
return false;
}
public function once(array $credentials = []): bool
{
return false;
}
public function login(Authenticatable $user, $remember = false): void
{
$this->currentUser = $user;
}
public function loginUsingId($id, $remember = false): Authenticatable|false
{
$this->loginUsingIdRememberFlag = (bool) $remember;
if ((string) $id === (string) $this->impersonator->getAuthIdentifier()) {
$this->currentUser = $this->impersonator;
return $this->impersonator;
}
return false;
}
public function onceUsingId($id): Authenticatable|false
{
return false;
}
public function viaRemember(): bool
{
return false;
}
public function logout(): void
{
$this->currentUser = null;
}
};
Auth::extend('fake-stateful', fn (): object => $fakeGuard);
Config::set('auth.guards.custom', [
'driver' => 'fake-stateful',
'provider' => 'users',
]);
Auth::guard('custom')->login($admin);
Auth::shouldUse('custom');
Mirror::start($targetUser);
expect(Auth::id())->toBe($targetUser->id)
->and(Mirror::isImpersonating())->toBeTrue()
->and(Session::get('mirror.guard_name'))->toBe('custom');
Mirror::stop();
expect($fakeGuard->loginUsingIdRememberFlag)->toBeFalse()
->and(Auth::id())->toBe($admin->id)
->and(Mirror::isImpersonating())->toBeFalse();
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Feature/PreventImpersonationTest.php | tests/Feature/PreventImpersonationTest.php | <?php
use App\Models\User;
use Illuminate\Support\Facades\Route;
use Mirror\Facades\Mirror;
use function Pest\Laravel\actingAs;
use function Pest\Laravel\delete;
use function Pest\Laravel\get;
use function Pest\Laravel\post;
it('allows request when not impersonating', function (): void {
Route::middleware('mirror.prevent')->get('/sensitive-action', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
actingAs($admin);
get('/sensitive-action')
->assertOk();
});
it('blocks request with 403 when impersonating', function (): void {
Route::middleware('mirror.prevent')->get('/sensitive-action', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
get('/sensitive-action')
->assertForbidden();
});
it('returns correct error message', function (): void {
Route::middleware('mirror.prevent')->get('/sensitive-action', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$response = get('/sensitive-action');
$response->assertForbidden();
expect($response->exception->getMessage())->toContain('This action is not allowed while impersonating another user');
});
it('works with route groups', function (): void {
Route::middleware('mirror.prevent')->group(function (): void {
Route::get('/billing', fn () => response()->json(['page' => 'billing']));
Route::post('/billing/update', fn () => response()->json(['updated' => true]));
Route::delete('/billing/cancel', fn () => response()->json(['cancelled' => true]));
});
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
get('/billing')
->assertOk();
post('/billing/update')
->assertOk();
delete('/billing/cancel')
->assertOk();
Mirror::start($user);
get('/billing')
->assertForbidden();
post('/billing/update')
->assertForbidden();
delete('/billing/cancel')
->assertForbidden();
});
it('can be used with other middlewares', function (): void {
Route::middleware(['auth', 'mirror.prevent'])->post('/critical-action', fn () => response()->json(['success' => true]));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
post('/critical-action')
->assertForbidden();
});
it('allows access after stopping impersonation', function (): void {
Route::middleware('mirror.prevent')->get('/protected', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
get('/protected')
->assertForbidden();
Mirror::stop();
get('/protected')
->assertOk();
});
it('works with multiple middleware layers', function (): void {
Route::middleware(['auth', 'verified', 'mirror.prevent'])->post('/secure', fn () => response()->json(['data' => 'sensitive']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
post('/secure')
->assertForbidden();
});
it('handles unauthenticated requests', function (): void {
Route::middleware('mirror.prevent')->get('/protected', fn () => response()->json(['status' => 'ok']));
get('/protected')
->assertOk();
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Feature/RequireImpersonationTest.php | tests/Feature/RequireImpersonationTest.php | <?php
use App\Models\User;
use Illuminate\Support\Facades\Route;
use Mirror\Facades\Mirror;
use function Pest\Laravel\actingAs;
use function Pest\Laravel\get;
use function Pest\Laravel\post;
it('blocks request with 403 when not impersonating', function (): void {
Route::middleware('mirror.require')->get('/impersonation-only', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
actingAs($admin);
get('/impersonation-only')
->assertForbidden();
});
it('allows request when impersonating', function (): void {
Route::middleware('mirror.require')->get('/impersonation-only', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
get('/impersonation-only')
->assertOk();
});
it('returns correct error message', function (): void {
Route::middleware('mirror.require')->get('/impersonation-only', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
actingAs($admin);
$response = get('/impersonation-only');
$response->assertForbidden();
expect($response->exception->getMessage())->toContain('This action requires active impersonation');
});
it('works with route groups', function (): void {
Route::middleware('mirror.require')->group(function (): void {
Route::get('/debug/session', fn () => response()->json(['session' => 'data']));
Route::get('/debug/cache', fn () => response()->json(['cache' => 'data']));
Route::post('/debug/clear', fn () => response()->json(['cleared' => true]));
});
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
get('/debug/session')
->assertForbidden();
get('/debug/cache')
->assertForbidden();
post('/debug/clear')
->assertForbidden();
Mirror::start($user);
get('/debug/session')
->assertOk();
get('/debug/cache')
->assertOk();
post('/debug/clear')
->assertOk();
});
it('can be used with other middlewares', function (): void {
Route::middleware(['auth', 'mirror.require'])->get('/special', fn () => response()->json(['user_id' => auth()->id()]));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
get('/special')
->assertOk()
->assertJson(['user_id' => $user->id]);
});
it('blocks access after stopping impersonation', function (): void {
Route::middleware('mirror.require')->get('/require-impersonation', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
get('/require-impersonation')
->assertOk();
Mirror::stop();
get('/require-impersonation')
->assertForbidden();
});
it('works with multiple middleware layers', function (): void {
Route::middleware(['auth', 'mirror.require'])->get('/restricted', fn () => response()->json(['data' => 'sensitive']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
get('/restricted')
->assertForbidden();
Mirror::start($user);
get('/restricted')
->assertOk();
});
it('handles unauthenticated requests', function (): void {
Route::middleware('mirror.require')->get('/protected', fn () => response()->json(['status' => 'ok']));
get('/protected')
->assertForbidden();
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Feature/CanBeImpersonatedDirectiveTest.php | tests/Feature/CanBeImpersonatedDirectiveTest.php | <?php
use App\Models\User;
use Mockery\MockInterface;
use function Pest\Laravel\actingAs;
it('shows content when user can be impersonated', function (): void {
$user = User::factory()->create();
actingAs($user);
$blade = <<<'BLADE'
@canBeImpersonated
<span>This user can be impersonated</span>
@endcanBeImpersonated
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->toContain('This user can be impersonated');
});
it('hides content when user cannot be impersonated', function (): void {
$user = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canBeImpersonated')
->andReturn(false);
});
actingAs($user);
$blade = <<<'BLADE'
@canBeImpersonated
<span>This user can be impersonated</span>
@endcanBeImpersonated
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('This user can be impersonated');
});
it('works with else clause', function (): void {
$user = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canBeImpersonated')
->andReturn(false);
});
actingAs($user);
$blade = <<<'BLADE'
@canBeImpersonated
<span>Can be impersonated</span>
@else
<span>Protected User</span>
@endcanBeImpersonated
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('Can be impersonated')
->and($rendered)->toContain('Protected User');
});
it('works with specific user parameter', function (): void {
$admin = User::factory()->create();
actingAs($admin);
$user = User::factory()->create(['name' => 'Protected User']);
$blade = <<<'BLADE'
@canBeImpersonated($user)
<div>Protected User Status</div>
@else
<div>Normal User Status</div>
@endcanBeImpersonated
BLADE;
$rendered = Blade::render($blade, ['user' => $user]);
expect($rendered)->not->toContain('Normal User Status')
->and($rendered)->toContain('Protected User Status');
});
it('returns false when no user is authenticated', function (): void {
$blade = <<<'BLADE'
@canBeImpersonated
<span>Can be impersonated</span>
@else
<span>Not authenticated</span>
@endcanBeImpersonated
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('Can be impersonate')
->and($rendered)->toContain('Not authenticated');
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Feature/CanImpersonateDirectiveTest.php | tests/Feature/CanImpersonateDirectiveTest.php | <?php
use App\Models\User;
use Mockery\MockInterface;
use function Pest\Laravel\actingAs;
it('shows content when user can impersonate', function (): void {
$admin = User::factory()->create();
actingAs($admin);
$blade = <<<'BLADE'
@canImpersonate
<button>Impersonate User</button>
@endcanImpersonate
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->toContain('Impersonate User');
});
it('hides content when user cannot impersonate', function (): void {
$user = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canImpersonate')
->andReturn(false);
});
actingAs($user);
$blade = <<<'BLADE'
@canImpersonate
<button>Impersonate User</button>
@endcanImpersonate
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('Impersonate User');
});
it('hides content when not authenticated', function (): void {
$blade = <<<'BLADE'
@canImpersonate
<button>Impersonate User</button>
@endcanImpersonate
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('Impersonate User');
});
it('works with else clause when cannot impersonate', function (): void {
$user = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canImpersonate')
->andReturn(false);
});
actingAs($user);
$blade = <<<'BLADE'
@canImpersonate
<button>Can Impersonate</button>
@else
<span>No permission to impersonate</span>
@endcanImpersonate
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('Can Impersonate')
->and($rendered)->toContain('No permission to impersonate');
});
it('works with guard parameter', function (): void {
$user = User::factory()->create();
actingAs($user, 'web');
$blade = <<<'BLADE'
@canImpersonate('web')
<button>Impersonate on web</button>
@endcanImpersonate
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->toContain('Impersonate on web');
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Feature/ImpersonatingDirectiveTest.php | tests/Feature/ImpersonatingDirectiveTest.php | <?php
use App\Models\User;
use Mirror\Facades\Mirror;
use function Pest\Laravel\actingAs;
it('shows content when impersonating', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$blade = <<<'BLADE'
@impersonating
<div>You are impersonating</div>
@endimpersonating
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->toContain('You are impersonating');
});
it('works with else clause when impersonating', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
$blade = <<<'BLADE'
@impersonating
<div>Impersonating</div>
@else
<div>Not impersonating</div>
@endimpersonating
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->toContain('Impersonating')
->and($rendered)->not->toContain('Not impersonating');
});
it('hides content when not impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
$blade = <<<'BLADE'
@impersonating
<div>You are impersonating</div>
@endimpersonating
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('You are impersonating');
});
it('works with else clause when not impersonating', function (): void {
$admin = User::factory()->create();
actingAs($admin);
$blade = <<<'BLADE'
@impersonating
<div>Impersonating</div>
@else
<div>Not impersonating</div>
@endimpersonating
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->not->toContain('Impersonating')
->and($rendered)->toContain('Not impersonating');
});
it('works with guard parameter', function (): void {
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin, 'web');
Mirror::start($user);
$blade = <<<'BLADE'
@impersonating('web')
<div>Impersonating on web guard</div>
@endimpersonating
BLADE;
$rendered = Blade::render($blade);
expect($rendered)->toContain('Impersonating on web guard');
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Feature/CheckImpersonationTtlTest.php | tests/Feature/CheckImpersonationTtlTest.php | <?php
use App\Models\User;
use Carbon\Carbon;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\Route;
use Mirror\Facades\Mirror;
use Mirror\Impersonator;
use function Pest\Laravel\actingAs;
use function Pest\Laravel\get;
it('allows request to continue when not impersonating', function (): void {
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
actingAs($admin);
get('/test')
->assertOk()
->assertJson(['status' => 'ok']);
});
it('allows request to continue when impersonating and not expired', function (): void {
Config::set('mirror.ttl', 3600);
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
get('/test')
->assertOk()
->assertJson(['status' => 'ok']);
});
it('allows request when TTL is null (no expiration)', function (): void {
Config::set('mirror.ttl');
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
// Travel forward in time to simulate old session
Carbon::setTestNow(Carbon::now()->addSeconds(999999));
get('/test')
->assertOk()
->assertJson(['status' => 'ok']);
});
it('redirects and stops impersonation when session has expired', function (): void {
Config::set('mirror.ttl', 3600);
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user, '/admin/users');
expect(Mirror::isImpersonating())->toBeTrue();
// Travel forward in time past the TTL
Carbon::setTestNow(Carbon::now()->addSeconds(3601));
get('/test')
->assertRedirect('/admin/users')
->assertSessionHas('warning', 'Your impersonation session has expired and you have been returned to your original account.');
expect(Mirror::isImpersonating())->toBeFalse()
->and(auth()->id())->toBe($admin->id);
});
it('redirects to root when no leave redirect URL is set and session expired', function (): void {
Config::set('mirror.ttl', 3600);
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
// Travel forward in time past the TTL
Carbon::setTestNow(Carbon::now()->addSeconds(3601));
get('/test')
->assertRedirect('/')
->assertSessionHas('warning');
});
it('can be used with other middlewares', function (): void {
Config::set('mirror.ttl', 3600);
Route::middleware(['mirror.ttl', 'auth'])->get('/protected', fn () => response()->json(['user_id' => auth()->id()]));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
get('/protected')
->assertOk()
->assertJson(['user_id' => $user->id]);
});
it('reads TTL from config', function (): void {
Config::set('mirror.ttl', 7200);
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
// Travel forward to just under custom TTL
Carbon::setTestNow(Carbon::now()->addSeconds(7199));
get('/test')
->assertOk();
// Travel forward to just over custom TTL
Carbon::setTestNow(Carbon::now()->addSeconds(2));
get('/test')
->assertRedirect();
});
it('respects disabled TTL (null)', function (): void {
Config::set('mirror.ttl');
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
// Travel forward in time by a very long period
Carbon::setTestNow(Carbon::now()->addYears(30));
get('/test')
->assertOk();
});
it('uses default redirect URL when leave redirect URL is null', function (): void {
Config::set('mirror.ttl', 3600);
Config::set('mirror.default_redirect_url', '/dashboard');
Route::middleware('mirror.ttl')->get('/test', fn () => response()->json(['status' => 'ok']));
$admin = User::factory()->create();
$user = User::factory()->create();
actingAs($admin);
Mirror::start($user);
Carbon::setTestNow(Carbon::now()->addSeconds(3601));
$mock = mock(Impersonator::class);
$mock->shouldReceive('isImpersonating')->andReturn(true);
$mock->shouldReceive('isExpired')->andReturn(true);
$mock->shouldReceive('getLeaveRedirectUrl')->andReturn(null);
$mock->shouldReceive('getDefaultRedirectUrl')->andReturn('/dashboard');
$mock->shouldReceive('forceStop')->andReturn(null);
app()->instance(Impersonator::class, $mock);
get('/test')
->assertRedirect('/dashboard')
->assertSessionHas('warning');
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Unit/ImpersonatableTest.php | tests/Unit/ImpersonatableTest.php | <?php
use App\Models\User;
use Mockery\MockInterface;
it('provides canImpersonate method that returns true by default', function (): void {
$user = User::factory()->make();
expect($user->canImpersonate())->toBeTrue();
});
it('provides canBeImpersonated method that returns true by default', function (): void {
$user = User::factory()->make();
expect($user->canBeImpersonated())->toBeTrue();
});
it('can be overridden to restrict impersonation', function (): void {
$user = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canImpersonate')
->andReturn(false);
});
expect($user->canImpersonate())->toBeFalse();
});
it('can be overridden to prevent being impersonated', function (): void {
$user = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canBeImpersonated')
->andReturn(false);
});
expect($user->canBeImpersonated())->toBeFalse();
});
it('both methods can be overridden independently', function (): void {
$user = Mockery::mock(User::class, function (MockInterface $mock): void {
$mock->shouldReceive('canBeImpersonated')
->andReturn(false);
$mock->shouldReceive('canImpersonate')
->andReturn(true);
});
expect($user->canImpersonate())->toBeTrue()
->and($user->canBeImpersonated())->toBeFalse();
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/tests/Unit/ImpersonationSessionTest.php | tests/Unit/ImpersonationSessionTest.php | <?php
use Illuminate\Support\Facades\Session;
use Mirror\Exceptions\TamperedSessionException;
use Mirror\ImpersonationSession;
beforeEach(function (): void {
$this->session = app(ImpersonationSession::class);
});
it('stores impersonator identifier in session', function (): void {
$this->session->setImpersonator(123);
expect(Session::get('mirror.impersonated_by'))->toBe(123)
->and($this->session->getImpersonator())->toBe(123);
});
it('stores string impersonator identifier', function (): void {
$this->session->setImpersonator('uuid-123');
expect($this->session->getImpersonator())->toBe('uuid-123');
});
it('getImpersonator returns null when no impersonator has been set', function (): void {
expect($this->session->getImpersonator())->toBeNull();
});
it('marks session as impersonating', function (): void {
$this->session->markAsImpersonating();
expect(Session::get('mirror.impersonating'))->toBeTrue()
->and($this->session->isImpersonating())->toBeTrue();
});
it('isImpersonating returns false when session is freshly created', function (): void {
expect($this->session->isImpersonating())->toBeFalse();
});
it('clears the impersonating flag', function (): void {
$this->session->markAsImpersonating();
expect($this->session->isImpersonating())->toBeTrue();
$this->session->clearImpersonatingFlag();
expect($this->session->isImpersonating())->toBeFalse()
->and(Session::has('mirror.impersonating'))->toBeFalse();
});
it('clears the impersonator identifier', function (): void {
$this->session->setImpersonator(123);
expect($this->session->getImpersonator())->toBe(123);
$this->session->clearImpersonator();
expect($this->session->getImpersonator())->toBeNull()
->and(Session::has('mirror.impersonated_by'))->toBeFalse();
});
it('stores guard name in session', function (): void {
$this->session->setGuardName('web');
expect(Session::get('mirror.guard_name'))->toBe('web')
->and($this->session->getGuardName())->toBe('web');
});
it('getGuardName returns null when no guard has been set', function (): void {
expect($this->session->getGuardName())->toBeNull();
});
it('clears the guard name', function (): void {
$this->session->setGuardName('web');
expect($this->session->getGuardName())->toBe('web');
$this->session->clearGuardName();
expect($this->session->getGuardName())->toBeNull()
->and(Session::has('mirror.guard_name'))->toBeFalse();
});
it('stores started at timestamp in session', function (): void {
$timestamp = time();
$this->session->setStartedAt($timestamp);
expect(Session::get('mirror.started_at'))->toBe($timestamp)
->and($this->session->getStartedAt())->toBe($timestamp);
});
it('getStartedAt returns null when no timestamp has been set', function (): void {
expect($this->session->getStartedAt())->toBeNull();
});
it('stores leave redirect URL in session', function (): void {
$url = 'https://example.com/admin/users';
$this->session->setLeaveRedirectUrl($url);
expect(Session::get('mirror.leave_redirect_url'))->toBe($url)
->and($this->session->getLeaveRedirectUrl())->toBe($url);
});
it('does not store null leave redirect URL', function (): void {
$this->session->setLeaveRedirectUrl(null);
expect(Session::has('mirror.leave_redirect_url'))->toBeFalse()
->and($this->session->getLeaveRedirectUrl())->toBeNull();
});
it('getLeaveRedirectUrl returns null when no URL has been set', function (): void {
expect($this->session->getLeaveRedirectUrl())->toBeNull();
});
it('clears all impersonation data from session', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->setLeaveRedirectUrl('/admin')
->markAsImpersonating()
->generateIntegrityHash();
expect(Session::has('mirror.impersonating'))->toBeTrue()
->and(Session::has('mirror.impersonated_by'))->toBeTrue()
->and(Session::has('mirror.guard_name'))->toBeTrue()
->and(Session::has('mirror.started_at'))->toBeTrue()
->and(Session::has('mirror.leave_redirect_url'))->toBeTrue()
->and(Session::has('mirror.integrity'))->toBeTrue();
$this->session->clear();
expect(Session::has('mirror.impersonating'))->toBeFalse()
->and(Session::has('mirror.impersonated_by'))->toBeFalse()
->and(Session::has('mirror.guard_name'))->toBeFalse()
->and(Session::has('mirror.started_at'))->toBeFalse()
->and(Session::has('mirror.leave_redirect_url'))->toBeFalse()
->and(Session::has('mirror.integrity'))->toBeFalse();
});
it('generates and stores integrity hash', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->setLeaveRedirectUrl('/admin')
->generateIntegrityHash();
$hash = Session::get('mirror.integrity');
expect($hash)->not->toBeNull()
->and($hash)->toBeString()
->and(strlen((string) $hash))->toBe(64);
});
it('generates different hash for different data', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->generateIntegrityHash();
$hash1 = Session::get('mirror.integrity');
$this->session->clear();
$this->session
->setImpersonator(456)
->setGuardName('web')
->setStartedAt(time())
->generateIntegrityHash();
$hash2 = Session::get('mirror.integrity');
expect($hash1)->not->toBe($hash2);
});
it('generates same hash for same data', function (): void {
$timestamp = time();
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt($timestamp)
->setLeaveRedirectUrl('/admin')
->generateIntegrityHash();
$hash1 = Session::get('mirror.integrity');
$this->session->generateIntegrityHash();
$hash2 = Session::get('mirror.integrity');
expect($hash1)->toBe($hash2);
});
it('passes verification when data is unchanged', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->setLeaveRedirectUrl('/admin')
->markAsImpersonating()
->generateIntegrityHash();
$this->session->verifyIntegrity();
expect(true)->toBeTrue();
});
it('verifyIntegrity returns early when not currently impersonating', function (): void {
$this->session->verifyIntegrity();
expect(true)->toBeTrue();
});
it('throws exception when hash is missing', function (): void {
$this->session
->setImpersonator(123)
->markAsImpersonating();
$this->session->verifyIntegrity();
})->throws(TamperedSessionException::class, 'tampered');
it('clears session when hash is missing', function (): void {
$this->session
->setImpersonator(123)
->markAsImpersonating();
try {
$this->session->verifyIntegrity();
} catch (TamperedSessionException) {
expect(Session::has('mirror.impersonating'))->toBeFalse()
->and(Session::has('mirror.impersonated_by'))->toBeFalse();
}
});
it('throws exception when impersonator identifier is tampered with', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->markAsImpersonating()
->generateIntegrityHash();
Session::put('mirror.impersonated_by', 456);
$this->session->verifyIntegrity();
})->throws(TamperedSessionException::class, 'tampered');
it('throws exception when guard name is tampered with', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->markAsImpersonating()
->generateIntegrityHash();
Session::put('mirror.guard_name', 'api');
$this->session->verifyIntegrity();
})->throws(TamperedSessionException::class, 'tampered');
it('throws exception when started at timestamp is tampered with', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->markAsImpersonating()
->generateIntegrityHash();
Session::put('mirror.started_at', time() - 3600);
$this->session->verifyIntegrity();
})->throws(TamperedSessionException::class, 'tampered');
it('throws exception when leave redirect URL is tampered with', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->setLeaveRedirectUrl('/admin')
->markAsImpersonating()
->generateIntegrityHash();
Session::put('mirror.leave_redirect_url', '/malicious');
$this->session->verifyIntegrity();
})->throws(TamperedSessionException::class, 'tampered');
it('clears session when tampering is detected', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->markAsImpersonating()
->generateIntegrityHash();
// Tamper
Session::put('mirror.impersonated_by', 999);
try {
$this->session->verifyIntegrity();
} catch (TamperedSessionException) {
expect(Session::has('mirror.impersonating'))->toBeFalse()
->and(Session::has('mirror.impersonated_by'))->toBeFalse()
->and(Session::has('mirror.guard_name'))->toBeFalse()
->and(Session::has('mirror.integrity'))->toBeFalse();
}
});
it('isExpired returns false when TTL is disabled (null)', function (): void {
$this->session
->setStartedAt(time() - 10000)
->markAsImpersonating();
expect($this->session->isExpired(null))->toBeFalse();
});
it('isExpired returns false when user is not impersonating', function (): void {
$this->session->setStartedAt(time() - 10000);
expect($this->session->isExpired(3600))->toBeFalse();
});
it('considers impersonation expired when started at is null', function (): void {
$this->session->markAsImpersonating();
expect($this->session->isExpired(3600))->toBeTrue();
});
it('isExpired returns false when within TTL time window', function (): void {
$this->session
->setStartedAt(time() - 1800)
->markAsImpersonating();
expect($this->session->isExpired(3600))->toBeFalse();
});
it('isExpired returns true when TTL time has elapsed', function (): void {
$this->session
->setStartedAt(time() - 3601)
->markAsImpersonating();
expect($this->session->isExpired(3600))->toBeTrue();
});
it('isExpired returns true when exactly at TTL boundary', function (): void {
$this->session
->setStartedAt(time() - 3601)
->markAsImpersonating();
expect($this->session->isExpired(3600))->toBeTrue();
});
it('isExpired returns false immediately after session starts', function (): void {
$this->session
->setStartedAt(time())
->markAsImpersonating();
expect($this->session->isExpired(3600))->toBeFalse();
});
it('isExpired returns false with TTL of one year when session is one day old', function (): void {
$this->session
->setStartedAt(time() - 86400)
->markAsImpersonating();
expect($this->session->isExpired(31536000))->toBeFalse();
});
it('isExpired returns true with TTL of one second when session is two seconds old', function (): void {
$this->session
->setStartedAt(time() - 2)
->markAsImpersonating();
expect($this->session->isExpired(1))->toBeTrue();
});
it('allows full method chaining for session setup', function (): void {
$timestamp = time();
$result = $this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt($timestamp)
->setLeaveRedirectUrl('/admin')
->markAsImpersonating()
->generateIntegrityHash();
expect($result)->toBe($this->session)
->and($this->session->getImpersonator())->toBe(123)
->and($this->session->getGuardName())->toBe('web')
->and($this->session->getStartedAt())->toBe($timestamp)
->and($this->session->getLeaveRedirectUrl())->toBe('/admin')
->and($this->session->isImpersonating())->toBeTrue()
->and(Session::has('mirror.integrity'))->toBeTrue();
});
it('persists data across multiple requests simulation', function (): void {
$this->session
->setImpersonator(123)
->setGuardName('web')
->setStartedAt(time())
->markAsImpersonating()
->generateIntegrityHash();
$sessionData = Session::all();
$newSession = app(ImpersonationSession::class);
foreach ($sessionData as $key => $value) {
Session::put($key, $value);
}
expect($newSession->getImpersonator())->toBe(123)
->and($newSession->getGuardName())->toBe('web')
->and($newSession->isImpersonating())->toBeTrue();
});
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
franbarbalopez/mirror | https://github.com/franbarbalopez/mirror/blob/3809b19a651f6b234d53e9ae09b93a588a3ef817/config/mirror.php | config/mirror.php | <?php
return [
/*
|--------------------------------------------------------------------------
| Impersonation Enabled
|--------------------------------------------------------------------------
|
| This value determines if the impersonation feature is enabled for your
| application. You may disable this in production or specific environments
| for security purposes.
|
*/
'enabled' => env('MIRROR_ENABLED', true),
/*
|--------------------------------------------------------------------------
| Session Guard
|--------------------------------------------------------------------------
|
| The session guard to use for impersonation. If null, it will use
| the default guard from your auth configuration.
|
*/
'guard' => null,
/*
|--------------------------------------------------------------------------
| Impersonation Time To Live (TTL)
|--------------------------------------------------------------------------
|
| The maximum duration (in seconds) that an impersonation session can last.
| After this time, the impersonation will automatically expire and the user
| will be logged out. Set to null for no time limit.
|
*/
'ttl' => null,
/*
|--------------------------------------------------------------------------
| Default Redirect URL
|--------------------------------------------------------------------------
|
| The default URL to redirect to when the TTL middleware expires a session
| and no leave redirect URL was specified. This allows you to customize
| where users are sent after an automatic session expiration.
|
*/
'default_redirect_url' => '/',
];
| php | MIT | 3809b19a651f6b234d53e9ae09b93a588a3ef817 | 2026-01-05T05:03:29.626930Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/server.php | server.php | <?php
/**
* Laravel - A PHP Framework For Web Artisans
*
* @package Laravel
* @author Taylor Otwell <taylor@laravel.com>
*/
$uri = urldecode(
parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH)
);
// This file allows us to emulate Apache's "mod_rewrite" functionality from the
// built-in PHP web server. This provides a convenient way to test a Laravel
// application without having installed a "real" web server software here.
if ($uri !== '/' && file_exists(__DIR__.'/public'.$uri)) {
return false;
}
require_once __DIR__.'/public/index.php';
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/User.php | app/User.php | <?php
namespace App;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;
use Illuminate\Notifications\Notifiable;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Laravel\Passport\HasApiTokens;
class User extends Authenticatable
{
use HasApiTokens, Notifiable;
/**
* The attributes that are mass assignable.
*
* @var array
*/
protected $fillable = [
'name', 'email', 'password'
];
/**
* The attributes that should be hidden for arrays.
*
* @var array
*/
protected $hidden = [
'password', 'remember_token', 'api_token'
];
/**
* Get the searches for the user.
*
* @return \Illuminate\Database\Eloquent\Relations\HasMany
*/
public function searches(): HasMany
{
return $this->hasMany(Search::class);
}
/**
* Get all of the emails for the user.
*
* @return \Illuminate\Database\Eloquent\Relations\HasManyThrough
*/
public function emails(): HasManyThrough
{
return $this->hasManyThrough(Email::class, Search::class);
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Email.php | app/Email.php | <?php
namespace App;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
class Email extends Model
{
/**
* Indicates if the model should be timestamped.
*
* @var bool
*/
public $timestamps = false;
/**
* The attributes that aren't mass assignable.
*
* @var array
*/
protected $guarded = [];
/**
* The attributes that should be cast to native types.
*
* @var array
*/
protected $casts = [
'search_id' => 'integer'
];
/**
* Get the search that owns the email.
*
* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
*/
public function search(): BelongsTo
{
return $this->belongsTo(Search::class);
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/helpers.php | app/helpers.php | <?php
if (! function_exists('routes_to_array')) {
/**
* Generate an array of routes for a given namespace.
*
* @param string $namespace
* @return array
* @throws \Exception
*/
function routes_to_array(string $namespace): array
{
if (! in_array($namespace, ['api', 'admin'])) {
throw new Exception("routes_to_array expect a namespace argument that is either `api` or `admin`. `{$namespace}` provided");
}
$routes = [];
foreach (Route::getRoutes() as $route) {
if (starts_with($route->getName(), $namespace)) {
$routes[$route->getName()] = config('app.url') . '/' . $route->uri();
}
}
return $routes;
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Url.php | app/Url.php | <?php
namespace App;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
class Url extends Model
{
/**
* Indicates if the model should be timestamped.
*
* @var bool
*/
public $timestamps = false;
/**
* The attributes that aren't mass assignable.
*
* @var array
*/
protected $guarded = [];
/**
* The attributes that should be cast to native types.
*
* @var array
*/
protected $casts = [
'search_id' => 'integer',
'is_crawled' => 'boolean'
];
/**
* Get the search that owns the url.
*
* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
*/
public function search(): BelongsTo
{
return $this->belongsTo(Search::class);
}
/**
* Whether the url is not crawled yet.
*
* @return bool
*/
public function getIsNotCrawledAttribute(): bool
{
return ! $this->is_crawled;
}
/**
* Scope a query to only include not crawled urls.
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeNotCrawled(Builder $query): Builder
{
return $query->where('is_crawled', false);
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Search.php | app/Search.php | <?php
namespace App;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
class Search extends Model
{
public const STATUS_CREATED = 'CREATED';
public const STATUS_RUNNING = 'RUNNING';
public const STATUS_FINISHED = 'FINISHED';
public const STATUS_PAUSED = 'PAUSED';
public const STATUS_FAILED = 'FAILED';
/**
* The attributes that aren't mass assignable.
*
* @var array
*/
protected $guarded = [];
/**
* The attributes that should be cast to native types.
*
* @var array
*/
protected $casts = [
'user_id' => 'integer',
'is_limited' => 'boolean'
];
/**
* Get the user that owns the search.
*
* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
*/
public function user(): BelongsTo
{
return $this->belongsTo(User::class);
}
/**
* Get the urls for the search.
*
* @return \Illuminate\Database\Eloquent\Relations\HasMany
*/
public function urls(): HasMany
{
return $this->hasMany(Url::class);
}
/**
* Get the emails for the search.
*
* @return \Illuminate\Database\Eloquent\Relations\HasMany
*/
public function emails(): HasMany
{
return $this->hasMany(Email::class);
}
/**
* Whether the search is in "created" state.
*
* @return bool
*/
public function getIsCreatedAttribute(): bool
{
return $this->status === self::STATUS_CREATED;
}
/**
* Whether the search is in "running" state.
*
* @return bool
*/
public function getIsRunningAttribute(): bool
{
return $this->status === self::STATUS_RUNNING;
}
/**
* Whether the search is in "finished" state.
*
* @return bool
*/
public function getIsFinishedAttribute(): bool
{
return $this->status === self::STATUS_FINISHED;
}
/**
* Whether the search is in "failed" state.
*
* @return bool
*/
public function getIsFailedAttribute(): bool
{
return $this->status === self::STATUS_FAILED;
}
/**
* Get the search's base domain.
*
* @return string
*/
public function getDomainAttribute(): string
{
$parsed = parse_url($this->url);
return "{$parsed['scheme']}://{$parsed['host']}";
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Jobs/CrawlJob.php | app/Jobs/CrawlJob.php | <?php
namespace App\Jobs;
use App\Search;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Support\Facades\App;
use Symfony\Component\Process\PhpExecutableFinder;
use Symfony\Component\Process\Process;
class CrawlJob implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/**
* The search model instance.
*
* @var \App\Search
*/
public $search;
/**
* Create a new job instance.
*
* @param \App\Search $search
*/
public function __construct(Search $search)
{
$this->search = $search;
}
/**
* Execute the job.
*/
public function handle(): void
{
if (! App::environment('testing')) {
$php = (new PhpExecutableFinder())->find();
$process = Process::fromShellCommandline(
"{$php} artisan crawler:crawl {$this->search->id} > /dev/null 2>&1 &",
realpath(base_path())
);
$process->run();
}
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Exceptions/Handler.php | app/Exceptions/Handler.php | <?php
namespace App\Exceptions;
use Exception;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
class Handler extends ExceptionHandler
{
/**
* A list of the exception types that are not reported.
*
* @var array
*/
protected $dontReport = [
//
];
/**
* A list of the inputs that are never flashed for validation exceptions.
*
* @var array
*/
protected $dontFlash = [
'password',
'password_confirmation',
];
/**
* Report or log an exception.
*
* This is a great spot to send exceptions to Sentry, Bugsnag, etc.
*
* @param \Exception $exception
* @return void
*/
public function report(Exception $exception)
{
parent::report($exception);
}
/**
* Render an exception into an HTTP response.
*
* @param \Illuminate\Http\Request $request
* @param \Exception $exception
* @return \Illuminate\Http\Response
*/
public function render($request, Exception $exception)
{
return parent::render($request, $exception);
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Http/Kernel.php | app/Http/Kernel.php | <?php
namespace App\Http;
use Illuminate\Foundation\Http\Kernel as HttpKernel;
class Kernel extends HttpKernel
{
/**
* The application's global HTTP middleware stack.
*
* These middleware are run during every request to your application.
*
* @var array
*/
protected $middleware = [
\Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode::class,
\Illuminate\Foundation\Http\Middleware\ValidatePostSize::class,
\App\Http\Middleware\TrimStrings::class,
\Illuminate\Foundation\Http\Middleware\ConvertEmptyStringsToNull::class,
\App\Http\Middleware\TrustProxies::class,
];
/**
* The application's route middleware groups.
*
* @var array
*/
protected $middlewareGroups = [
'web' => [
\App\Http\Middleware\EncryptCookies::class,
\Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
\Illuminate\Session\Middleware\StartSession::class,
// \Illuminate\Session\Middleware\AuthenticateSession::class,
\Illuminate\View\Middleware\ShareErrorsFromSession::class,
\App\Http\Middleware\VerifyCsrfToken::class,
\Illuminate\Routing\Middleware\SubstituteBindings::class,
\Laravel\Passport\Http\Middleware\CreateFreshApiToken::class,
],
'api' => [
'throttle:60,1',
'bindings',
],
];
/**
* The application's route middleware.
*
* These middleware may be assigned to groups or used individually.
*
* @var array
*/
protected $routeMiddleware = [
'auth' => \Illuminate\Auth\Middleware\Authenticate::class,
'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
'can' => \Illuminate\Auth\Middleware\Authorize::class,
'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
];
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Http/Requests/UserRequest.php | app/Http/Requests/UserRequest.php | <?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Validation\Rule;
class UserRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules(): array
{
return [
'name' => 'required|string|max:255',
'email' => [
'required',
'string',
'email',
'max:255',
Rule::unique('users')->ignore($this->route('user')->id),
],
'password' => 'nullable|string|min:6|confirmed'
];
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Http/Requests/SearchRequest.php | app/Http/Requests/SearchRequest.php | <?php
namespace App\Http\Requests;
use App\Search;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Validation\Rule;
class SearchRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules(): array
{
return [
'is_limited' => 'nullable|boolean',
'status' => ['nullable', Rule::in([
Search::STATUS_FINISHED,
Search::STATUS_PAUSED,
])]
];
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Http/Requests/UserSearchRequest.php | app/Http/Requests/UserSearchRequest.php | <?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class UserSearchRequest extends FormRequest
{
/**
* Determine if the user is authorized to make this request.
*
* @return bool
*/
public function authorize(): bool
{
return true;
}
/**
* Get the validation rules that apply to the request.
*
* @return array
*/
public function rules(): array
{
return [
'url' => 'required|url',
'is_limited' => 'required|boolean'
];
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Http/Controllers/Controller.php | app/Http/Controllers/Controller.php | <?php
namespace App\Http\Controllers;
use Illuminate\Foundation\Bus\DispatchesJobs;
use Illuminate\Routing\Controller as BaseController;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
class Controller extends BaseController
{
use AuthorizesRequests, DispatchesJobs, ValidatesRequests;
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
hedii/php-crawler | https://github.com/hedii/php-crawler/blob/9de07a738468d0821993b098d9917146eb4365fb/app/Http/Controllers/UserEmailController.php | app/Http/Controllers/UserEmailController.php | <?php
namespace App\Http\Controllers;
use App\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
class UserEmailController extends Controller
{
/**
* Send a file with all the users's emails.
*
* @param \Illuminate\Http\Request $request
* @param \App\User $user
* @return \Symfony\Component\HttpFoundation\BinaryFileResponse
*/
public function __invoke(Request $request, User $user): BinaryFileResponse
{
$emails = $user->emails->pluck('name')->unique()->all();
$tempFileName = str_random() . '.txt';
Storage::put($tempFileName, implode("\r\n", $emails));
return response()
->download(storage_path("app/{$tempFileName}"))
->deleteFileAfterSend(true);
}
}
| php | MIT | 9de07a738468d0821993b098d9917146eb4365fb | 2026-01-05T05:03:37.929921Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.