pax_global_header00006660000000000000000000000064126161136550014520gustar00rootroot0000000000000052 comment=390cefcb101e07e1d6400dbdfc3b90ecf2c1279f dbunit-2.0.2/000077500000000000000000000000001261611365500130065ustar00rootroot00000000000000dbunit-2.0.2/.gitattributes000066400000000000000000000000171261611365500156770ustar00rootroot00000000000000*.php diff=php dbunit-2.0.2/.gitignore000066400000000000000000000000701261611365500147730ustar00rootroot00000000000000/.idea /.vagrant /composer.lock /composer.phar /vendor dbunit-2.0.2/.travis.yml000066400000000000000000000004001261611365500151110ustar00rootroot00000000000000language: php before_script: ./build/travis-ci.sh php: - 5.6 - 7.0 - hhvm script: ./vendor/bin/phpunit --configuration ./build/phpunit.xml notifications: email: false irc: channels: - "irc.freenode.org#phpunit" use_notice: true dbunit-2.0.2/ChangeLog.md000066400000000000000000000115551261611365500151660ustar00rootroot00000000000000DbUnit 1.3 ========== This is the list of changes for the DbUnit 1.3 release series. 1.3.1 ----- * [#76](https://github.com/sebastianbergmann/dbunit/issues/76) [#110](https://github.com/sebastianbergmann/dbunit/pull/110) `CompositeDataSet` now behaves in a way consistent with its documentation when handling several data sets with the same table ([jeunito](https://github.com/jeunito)) * [#113](https://github.com/sebastianbergmann/dbunit/pull/113) [phpunit#1182](https://github.com/sebastianbergmann/phpunit/issues/1182) Multiple corrections have been made to the BankAccountDB sample code ([dragonbe](https://github.com/dragonbe), [elazar](https://github.com/elazar)) * [#117](https://github.com/sebastianbergmann/dbunit/pull/117) Firebird support is now included in the PEAR package distribution ([matheusd](https://github.com/matheusd)) * [#118](https://github.com/sebastianbergmann/dbunit/pull/118) Copyright years were bumped to 2014 ([dmelo](https://github.com/dmelo)) * [#125](https://github.com/sebastianbergmann/dbunit/pull/125) Database connections using Dblib are now supported ([exptom](https://github.com/exptom)) * [#122](https://github.com/sebastianbergmann/dbunit/pull/122) `XmlDataSet` now emits an informative error message in the event of table and row column mismatches ([Sicaine](https://github.com/Sicaine])) * [#114](https://github.com/sebastianbergmann/dbunit/pull/114) Changes from 1.3.0 to address type checking of column values in `matches()` from `AbstractTable` and `ReplacementTable` (see [#28](https://github.com/sebastianbergmann/dbunit/issues/28) and [#61](https://github.com/sebastianbergmann/dbunit/issues/61)) were modified to perform loose type checking on numeric values and to typecast `SimpleXMLElement` values to strings before performing comparisons ([paulyg](https://github.com/paulyg])) * [#112](https://github.com/sebastianbergmann/dbunit/pull/112) `TableFilter` now overrides `assertContainsRow()` to invoke `loadData()` before calling the parent implementation ([jodysimpson](https://github.com/jodysimpson)) 1.3.0 ----- * [#82](https://github.com/sebastianbergmann/dbunit/issues/82) Composer now allows for dev packages as the master branch requires PHPUnit >= 3.8.0 ([whatthejeff](https://github.com/whatthejeff)) * [#66](https://github.com/sebastianbergmann/dbunit/pull/66) The dependency on the Symfony YAML library is now properly indicated in `package.xml` ([elazar](https://github.com/elazar)) * [#54](https://github.com/sebastianbergmann/dbunit/pull/54) `Operation_RowBased->execute()` now handles cases where `PDO::ATTR_EMULATE_PREPARES` is set to `false` ([dexen](https://github.com/dexen)) * [#28](https://github.com/sebastianbergmann/dbunit/issues/28) [#61](https://github.com/sebastianbergmann/dbunit/issues/61) `matches()` in `AbstractTable` and `ReplacementTable` now include type checking of column values * [#88](https://github.com/sebastianbergmann/dbunit/pull/88) `getTable()` and `getTableMetaData()` in `DefaultTableIterator` now properly return values ([szicsu](https://github.com/szicsu)) * [#81](https://github.com/sebastianbergmann/dbunit/pull/81)`Operation_RowBased` now performs significantly better for truncate-only tables ([wakeless](https://github.com/wakeless)) * [#78](https://github.com/sebastianbergmann/dbunit/pull/78) `TestCase->assertTableRowCount()` now correctly calls `getConnection()` as an instance method rather than a static method ([josefzamrzla](https://github.com/josefzamrzla)) * [#69](https://github.com/sebastianbergmann/dbunit/pull/69) `QueryTable` now overrides `assertContainsRow()` to invoke `loadData()` before calling the parent implementation ([jeunito](https://github.com/jeunito)) * [#93](https://github.com/sebastianbergmann/dbunit/pull/93) [#95](https://github.com/sebastianbergmann/dbunit/pull/95) `AbstractTable` now supports outputting table diffs ([ptrofimov](https://github.com/ptrofimov)) * [#67](https://github.com/sebastianbergmann/dbunit/pull/67) [#117](https://github.com/sebastianbergmann/dbunit/pull/117) The Firebird database is now supported ([matheusd](https://github.com/matheusd)) * [#101](https://github.com/sebastianbergmann/dbunit/pull/101) PostgreSQL primary keys now load correctly ([danielek](https://github.com/danielek)) * [#103](https://github.com/sebastianbergmann/dbunit/pull/103) `Sqlite->getTableNames()` no longer emits a notice when called on an empty database ([neilime](https://github.com/neilime)) * [#104](https://github.com/sebastianbergmann/dbunit/pull/104) [#105](https://github.com/sebastianbergmann/dbunit/pull/105) [#106](https://github.com/sebastianbergmann/dbunit/pull/106) `YamlDataSet` can now support YAML parsers other than the one from Symfony via the `IYamlParser` interface ([yparghi](https://github.com/yparghi)) * [#100](https://github.com/sebastianbergmann/dbunit/pull/100) `dbunit.php` no longer references the deprecated singleton class `PHP_CodeCoverage_Filter` ([elazar](https://github.com/elazar)) dbunit-2.0.2/LICENSE000066400000000000000000000030051261611365500140110ustar00rootroot00000000000000DbUnit Copyright (c) 2002-2015, Sebastian Bergmann . All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Sebastian Bergmann nor the names of his contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. dbunit-2.0.2/Vagrantfile000066400000000000000000000004021261611365500151670ustar00rootroot00000000000000VAGRANTFILE_API_VERSION = "2" Vagrant.configure(VAGRANTFILE_API_VERSION) do |config| config.vm.box = "hashicorp/precise64" if Vagrant.has_plugin?("vagrant-cachier") end config.vm.provision "shell", inline: "source /vagrant/build/vagrant.sh" end dbunit-2.0.2/build.xml000066400000000000000000000015521261611365500146320ustar00rootroot00000000000000 dbunit-2.0.2/build/000077500000000000000000000000001261611365500141055ustar00rootroot00000000000000dbunit-2.0.2/build/phpunit.xml000066400000000000000000000017721261611365500163250ustar00rootroot00000000000000 ../tests/Constraint ../tests/DataSet ../tests/Operation ../tests/DB ../src dbunit-2.0.2/build/travis-ci.sh000077500000000000000000000011651261611365500163500ustar00rootroot00000000000000#!/bin/bash COMPOSER="/usr/local/bin/composer" COMPOSER_PATH=$(dirname ${COMPOSER}) MYSQL_USER="root" MYSQL_DATABASE="phpunit_tests" if [ ! -x "${COMPOSER}" ]; then echo "Installing Composer" curl -sS https://getcomposer.org/installer | sudo php -d apc.enable_cli=0 -- --install-dir=${COMPOSER_PATH} --filename=$(basename ${COMPOSER}) else echo "Updating Composer" sudo ${COMPOSER} self-update fi ${COMPOSER} install --no-interaction --prefer-source --dev mysql -u ${MYSQL_USER} -e "CREATE DATABASE IF NOT EXISTS $MYSQL_DATABASE;" sed -i 's///g' build/travis-ci.xml dbunit-2.0.2/build/vagrant.sh000077500000000000000000000030701261611365500161060ustar00rootroot00000000000000#!/bin/bash COMPOSER="/usr/local/bin/composer" DEBIAN_FRONTEND="noninteractive" MYSQL_USER="root" MYSQL_PASSWORD="password" MYSQL_DATABASE="phpunit_tests" sed -i "/mirror:\\/\\//d" /etc/apt/sources.list sed -i "1ideb mirror://mirrors.ubuntu.com/mirrors.txt precise main restricted universe multiverse" /etc/apt/sources.list sed -i "1ideb mirror://mirrors.ubuntu.com/mirrors.txt precise-updates main restricted universe multiverse" /etc/apt/sources.list sed -i "1ideb mirror://mirrors.ubuntu.com/mirrors.txt precise-backports main restricted universe multiverse" /etc/apt/sources.list sed -i "1ideb mirror://mirrors.ubuntu.com/mirrors.txt precise-security main restricted universe multiverse" /etc/apt/sources.list apt-get update debconf-set-selections <<< "mysql-server mysql-server/root_password password $MYSQL_PASSWORD" debconf-set-selections <<< "mysql-server mysql-server/root_password_again password $MYSQL_PASSWORD" apt-get install git php5-cli php5-xdebug php5-sqlite php5-mysql mysql-server-5.5 -y --no-install-recommends mysql -u root -p"$MYSQL_PASSWORD" -e "CREATE DATABASE IF NOT EXISTS $MYSQL_DATABASE;" if [ ! -f "$COMPOSER" ]; then php -r "readfile('https://getcomposer.org/installer');" | sudo php -d apc.enable_cli=0 -- --install-dir=$(dirname "$COMPOSER") --filename=$(basename "$COMPOSER") else sudo "$COMPOSER" self-update fi cd /vagrant cp phpunit.xml.dist phpunit.xml sed -i 's///g' phpunit.xml if [ ! -d vendor ] || [ ! -f vendor/autoload.php ]; then ${COMPOSER} install --no-interaction --prefer-source --dev fi dbunit-2.0.2/composer.json000066400000000000000000000017631261611365500155370ustar00rootroot00000000000000{ "name": "phpunit/dbunit", "description": "DbUnit port for PHP/PHPUnit to support database interaction testing.", "type": "library", "keywords": [ "database", "testing", "xunit" ], "homepage": "https://github.com/sebastianbergmann/dbunit/", "license": "BSD-3-Clause", "authors": [ { "name": "Sebastian Bergmann", "email": "sb@sebastian-bergmann.de", "role": "lead" } ], "support": { "issues": "https://github.com/sebastianbergmann/dbunit/issues", "irc": "irc://irc.freenode.net/phpunit" }, "require": { "php": ">=5.4", "phpunit/phpunit": "~4|~5", "symfony/yaml": "~2.1|~3.0", "ext-pdo": "*", "ext-simplexml": "*" }, "bin": [ "dbunit" ], "autoload": { "classmap": [ "src/" ] }, "extra": { "branch-alias": { "dev-master": "2.0.x-dev" } } } dbunit-2.0.2/dbunit000077500000000000000000000020541261611365500142220ustar00rootroot00000000000000#!/usr/bin/env php * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ foreach (array(__DIR__ . '/../../autoload.php', __DIR__ . '/../vendor/autoload.php', __DIR__ . '/vendor/autoload.php') as $file) { if (file_exists($file)) { define('DBUNIT_COMPOSER_INSTALL', $file); break; } } unset($file); if (!defined('DBUNIT_COMPOSER_INSTALL')) { fwrite(STDERR, 'You need to set up the project dependencies using the following commands:' . PHP_EOL . 'wget http://getcomposer.org/composer.phar' . PHP_EOL . 'php composer.phar install' . PHP_EOL ); die(1); } require DBUNIT_COMPOSER_INSTALL; $command = new PHPUnit_Extensions_Database_UI_Command( new PHPUnit_Extensions_Database_UI_ModeFactory ); $command->main( new PHPUnit_Extensions_Database_UI_Mediums_Text($_SERVER['argv']), new PHPUnit_Extensions_Database_UI_Context ); dbunit-2.0.2/samples/000077500000000000000000000000001261611365500144525ustar00rootroot00000000000000dbunit-2.0.2/samples/BankAccountDB/000077500000000000000000000000001261611365500170505ustar00rootroot00000000000000dbunit-2.0.2/samples/BankAccountDB/BankAccount.php000066400000000000000000000074351261611365500217620ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ class BankAccountException extends RuntimeException {} /** * A bank account. * * @since Class available since Release 1.0.0 */ class BankAccount { /** * The bank account's balance. * * @var float */ protected $balance = 0.00; /** * The bank account's number. * * @var string */ protected $accountNumber = ''; /** * The PDO connection used to store and retrieve bank account information. * * @var PDO */ protected $pdo; /** * Initializes the bank account object. * * @param string $accountNumber * @param \PDO $pdo */ public function __construct($accountNumber, PDO $pdo) { $this->accountNumber = $accountNumber; $this->pdo = $pdo; $this->loadAccount(); } /** * Returns the bank account's balance. * * @return float */ public function getBalance() { return $this->balance; } /** * Sets the bank account's balance. * * @param float $balance * @throws BankAccountException */ protected function setBalance($balance) { if ($balance >= 0) { $this->balance = $balance; $this->updateAccount(); } else { throw new BankAccountException; } } /** * Returns the bank account's number. * * @return float */ public function getAccountNumber() { return $this->accountNumber; } /** * Deposits an amount of money to the bank account. * * @param float $balance * @throws BankAccountException */ public function depositMoney($balance) { $this->setBalance($this->getBalance() + $balance); return $this->getBalance(); } /** * Withdraws an amount of money from the bank account. * * @param float $balance * @throws BankAccountException */ public function withdrawMoney($balance) { $this->setBalance($this->getBalance() - $balance); return $this->getBalance(); } /** * Loads account information from the database. */ protected function loadAccount() { $query = 'SELECT * FROM bank_account WHERE account_number = ?'; $statement = $this->pdo->prepare($query); $statement->execute([$this->accountNumber]); if ($bankAccountInfo = $statement->fetch(PDO::FETCH_ASSOC)) { $this->balance = $bankAccountInfo['balance']; } else { $this->balance = 0; $this->addAccount(); } } /** * Saves account information to the database. */ protected function updateAccount() { $query = 'UPDATE bank_account SET balance = ? WHERE account_number = ?'; $statement = $this->pdo->prepare($query); $statement->execute([$this->balance, $this->accountNumber]); } /** * Adds account information to the database. */ protected function addAccount() { $query = 'INSERT INTO bank_account (balance, account_number) VALUES(?, ?)'; $statement = $this->pdo->prepare($query); $statement->execute([$this->balance, $this->accountNumber]); } static public function createTable(PDO $pdo) { $query = ' CREATE TABLE bank_account ( account_number VARCHAR(17) PRIMARY KEY, balance DECIMAL(9,2) NOT NULL DEFAULT 0 ); '; $pdo->query($query); } } dbunit-2.0.2/samples/BankAccountDB/BankAccountCompositeTest.php000066400000000000000000000104361261611365500245000ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ require_once 'BankAccount.php'; /** * Tests for the BankAccount class. * * @since Class available since Release 1.0.0 */ class BankAccountCompositeTest extends PHPUnit_Framework_TestCase { protected $pdo; protected $tester; public function __construct($name = null, array $data = [], $dataName = '') { parent::__construct($name, $data, $dataName); $this->pdo = new PDO('sqlite::memory:'); BankAccount::createTable($this->pdo); $this->tester = $this->getDatabaseTester(); } /** * @return PHPUnit_Extensions_Database_DefaultTester */ protected function getDatabaseTester() { $connection = new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection($this->pdo, 'sqlite'); $tester = new PHPUnit_Extensions_Database_DefaultTester($connection); $tester->setSetUpOperation(PHPUnit_Extensions_Database_Operation_Factory::CLEAN_INSERT()); $tester->setTearDownOperation(PHPUnit_Extensions_Database_Operation_Factory::NONE()); $tester->setDataSet(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/_files/bank-account-seed.xml')); return $tester; } protected function setUp() { parent::setUp(); $this->tester->onSetUp(); } protected function tearDown() { parent::tearDown(); $this->tester->onTearDown(); } public function testNewAccountBalanceIsInitiallyZero() { $bank_account = new BankAccount('12345678912345678', $this->pdo); $this->assertEquals(0, $bank_account->getBalance()); } public function testOldAccountInfoInitiallySet() { $bank_account = new BankAccount('15934903649620486', $this->pdo); $this->assertEquals(100, $bank_account->getBalance()); $this->assertEquals('15934903649620486', $bank_account->getAccountNumber()); $bank_account = new BankAccount('15936487230215067', $this->pdo); $this->assertEquals(1216, $bank_account->getBalance()); $this->assertEquals('15936487230215067', $bank_account->getAccountNumber()); $bank_account = new BankAccount('12348612357236185', $this->pdo); $this->assertEquals(89, $bank_account->getBalance()); $this->assertEquals('12348612357236185', $bank_account->getAccountNumber()); } public function testAccountBalanceDeposits() { $bank_account = new BankAccount('15934903649620486', $this->pdo); $bank_account->depositMoney(100); $bank_account = new BankAccount('15936487230215067', $this->pdo); $bank_account->depositMoney(230); $bank_account = new BankAccount('12348612357236185', $this->pdo); $bank_account->depositMoney(24); $xml_dataset = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/_files/bank-account-after-deposits.xml'); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($xml_dataset, $this->tester->getConnection()->createDataSet()); } public function testAccountBalanceWithdrawals() { $bank_account = new BankAccount('15934903649620486', $this->pdo); $bank_account->withdrawMoney(100); $bank_account = new BankAccount('15936487230215067', $this->pdo); $bank_account->withdrawMoney(230); $bank_account = new BankAccount('12348612357236185', $this->pdo); $bank_account->withdrawMoney(24); $xml_dataset = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/_files/bank-account-after-withdrawals.xml'); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($xml_dataset, $this->tester->getConnection()->createDataSet()); } public function testNewAccountCreation() { $bank_account = new BankAccount('12345678912345678', $this->pdo); $xml_dataset = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/_files/bank-account-after-new-account.xml'); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($xml_dataset, $this->tester->getConnection()->createDataSet()); } } dbunit-2.0.2/samples/BankAccountDB/BankAccountDBTest.php000066400000000000000000000073221261611365500230230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ require_once dirname(__FILE__) . '/BankAccount.php'; /** * Base class for tests for the BankAccount class. * * @since Class available since Release 1.0.0 */ abstract class BankAccountDBTest extends PHPUnit_Extensions_Database_TestCase { protected $pdo; public function __construct($name = null, array $data = [], $dataName = '') { parent::__construct($name, $data, $dataName); $this->pdo = $this->getPdo(); BankAccount::createTable($this->pdo); } /** * Custom method to obtain a configured PDO instance. * * @return \PDO */ abstract protected function getPdo(); /** * Returns the test database connection. * * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection */ protected function getConnection() { return $this->createDefaultDBConnection($this->pdo); } protected function getDataSet() { return $this->createFlatXMLDataSet(dirname(__FILE__) . '/_files/bank-account-seed.xml'); } public function testNewAccountBalanceIsInitiallyZero() { $bank_account = new BankAccount('12345678912345678', $this->pdo); $this->assertEquals(0, $bank_account->getBalance()); } public function testOldAccountInfoInitiallySet() { $bank_account = new BankAccount('15934903649620486', $this->pdo); $this->assertEquals(100, $bank_account->getBalance()); $this->assertEquals('15934903649620486', $bank_account->getAccountNumber()); $bank_account = new BankAccount('15936487230215067', $this->pdo); $this->assertEquals(1216, $bank_account->getBalance()); $this->assertEquals('15936487230215067', $bank_account->getAccountNumber()); $bank_account = new BankAccount('12348612357236185', $this->pdo); $this->assertEquals(89, $bank_account->getBalance()); $this->assertEquals('12348612357236185', $bank_account->getAccountNumber()); } public function testAccountBalanceDeposits() { $bank_account = new BankAccount('15934903649620486', $this->pdo); $bank_account->depositMoney(100); $bank_account = new BankAccount('15936487230215067', $this->pdo); $bank_account->depositMoney(230); $bank_account = new BankAccount('12348612357236185', $this->pdo); $bank_account->depositMoney(24); $xml_dataset = $this->createFlatXMLDataSet(dirname(__FILE__) . '/_files/bank-account-after-deposits.xml'); $this->assertDataSetsEqual($xml_dataset, $this->getConnection()->createDataSet()); } public function testAccountBalanceWithdrawals() { $bank_account = new BankAccount('15934903649620486', $this->pdo); $bank_account->withdrawMoney(100); $bank_account = new BankAccount('15936487230215067', $this->pdo); $bank_account->withdrawMoney(230); $bank_account = new BankAccount('12348612357236185', $this->pdo); $bank_account->withdrawMoney(24); $xml_dataset = $this->createFlatXMLDataSet(dirname(__FILE__) . '/_files/bank-account-after-withdrawals.xml'); $this->assertDataSetsEqual($xml_dataset, $this->getConnection()->createDataSet()); } public function testNewAccountCreation() { $bank_account = new BankAccount('12345678912345678', $this->pdo); $xml_dataset = $this->createFlatXMLDataSet(dirname(__FILE__) . '/_files/bank-account-after-new-account.xml'); $this->assertDataSetsEqual($xml_dataset, $this->getConnection()->createDataSet()); } } dbunit-2.0.2/samples/BankAccountDB/BankAccountDBTestMySQL.php000066400000000000000000000011421261611365500237030ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ require_once dirname(__FILE__) . '/BankAccount.php'; require_once dirname(__FILE__) . '/BankAccountDBTest.php'; /** * Tests for the BankAccount class. * * @since Class available since Release 1.0.0 */ class BankAccountDBTestMySQL extends BankAccountDBTest { protected function getPdo() { return new PDO('mysql:host=localhost;dbname=test', 'root'); } } dbunit-2.0.2/samples/BankAccountDB/BankAccountDBTestSQLite.php000066400000000000000000000011121261611365500240740ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ require_once dirname(__FILE__) . '/BankAccount.php'; require_once dirname(__FILE__) . '/BankAccountDBTest.php'; /** * Tests for the BankAccount class. * * @since Class available since Release 1.0.0 */ class BankAccountDBTestSQLite extends BankAccountDBTest { protected function getPdo() { return new PDO('sqlite::memory:'); } } dbunit-2.0.2/samples/BankAccountDB/_files/000077500000000000000000000000001261611365500203115ustar00rootroot00000000000000dbunit-2.0.2/samples/BankAccountDB/_files/bank-account-after-deposits.xml000066400000000000000000000004301261611365500263240ustar00rootroot00000000000000 dbunit-2.0.2/samples/BankAccountDB/_files/bank-account-after-new-account.xml000066400000000000000000000005361261611365500267240ustar00rootroot00000000000000 dbunit-2.0.2/samples/BankAccountDB/_files/bank-account-after-withdrawals.xml000066400000000000000000000004241261611365500270260ustar00rootroot00000000000000 dbunit-2.0.2/samples/BankAccountDB/_files/bank-account-seed.xml000066400000000000000000000004271261611365500243210ustar00rootroot00000000000000 dbunit-2.0.2/src/000077500000000000000000000000001261611365500135755ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/000077500000000000000000000000001261611365500157345ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/000077500000000000000000000000001261611365500174405ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/AbstractTester.php000066400000000000000000000074351261611365500231140ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Can be used as a foundation for new DatabaseTesters. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_AbstractTester implements PHPUnit_Extensions_Database_ITester { /** * @var PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ protected $setUpOperation; /** * @var PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ protected $tearDownOperation; /** * @var PHPUnit_Extensions_Database_DataSet_IDataSet */ protected $dataSet; /** * @var string */ protected $schema; /** * Creates a new database tester. */ public function __construct() { $this->setUpOperation = PHPUnit_Extensions_Database_Operation_Factory::CLEAN_INSERT(); $this->tearDownOperation = PHPUnit_Extensions_Database_Operation_Factory::NONE(); } /** * Closes the specified connection. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection */ public function closeConnection(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { $connection->close(); } /** * Returns the test dataset. * * @return PHPUnit_Extensions_Database_DataSet_IDataSet */ public function getDataSet() { return $this->dataSet; } /** * TestCases must call this method inside setUp(). */ public function onSetUp() { $this->getSetUpOperation()->execute($this->getConnection(), $this->getDataSet()); } /** * TestCases must call this method inside tearDown(). */ public function onTearDown() { $this->getTearDownOperation()->execute($this->getConnection(), $this->getDataSet()); } /** * Sets the test dataset to use. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet */ public function setDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { $this->dataSet = $dataSet; } /** * Sets the schema value. * * @param string $schema */ public function setSchema($schema) { $this->schema = $schema; } /** * Sets the DatabaseOperation to call when starting the test. * * @param PHPUnit_Extensions_Database_Operation_DatabaseOperation $setUpOperation */ public function setSetUpOperation(PHPUnit_Extensions_Database_Operation_IDatabaseOperation $setUpOperation) { $this->setUpOperation = $setUpOperation; } /** * Sets the DatabaseOperation to call when ending the test. * * @param PHPUnit_Extensions_Database_Operation_DatabaseOperation $tearDownOperation */ public function setTearDownOperation(PHPUnit_Extensions_Database_Operation_IDatabaseOperation $tearDownOperation) { $this->tearDownOperation = $tearDownOperation; } /** * Returns the schema value * * @return string */ protected function getSchema() { return $this->schema; } /** * Returns the database operation that will be called when starting the test. * * @return PHPUnit_Extensions_Database_Operation_DatabaseOperation */ protected function getSetUpOperation() { return $this->setUpOperation; } /** * Returns the database operation that will be called when ending the test. * * @return PHPUnit_Extensions_Database_Operation_DatabaseOperation */ protected function getTearDownOperation() { return $this->tearDownOperation; } } dbunit-2.0.2/src/Extensions/Database/Constraint/000077500000000000000000000000001261611365500215645ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/Constraint/DataSetIsEqual.php000066400000000000000000000042151261611365500251100ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Asserts whether or not two dbunit datasets are equal. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Constraint_DataSetIsEqual extends PHPUnit_Framework_Constraint { /** * @var PHPUnit_Extensions_Database_DataSet_IDataSet */ protected $value; /** * @var string */ protected $failure_reason; /** * Creates a new constraint. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $value */ public function __construct(PHPUnit_Extensions_Database_DataSet_IDataSet $value) { parent::__construct(); $this->value = $value; } /** * Evaluates the constraint for parameter $other. Returns TRUE if the * constraint is met, FALSE otherwise. * * This method can be overridden to implement the evaluation algorithm. * * @param mixed $other Value or object to evaluate. * @return bool */ protected function matches($other) { if (!$other instanceof PHPUnit_Extensions_Database_DataSet_IDataSet) { throw new InvalidArgumentException( 'PHPUnit_Extensions_Database_DataSet_IDataSet expected' ); } return $this->value->matches($other); } /** * Returns the description of the failure * * The beginning of failure messages is "Failed asserting that" in most * cases. This method should return the second part of that sentence. * * @param mixed $other Evaluated value or object. * @return string */ protected function failureDescription($other) { return $other->__toString() . ' ' . $this->toString(); } /** * Returns a string representation of the constraint. * * @return string */ public function toString() { return sprintf( 'is equal to expected %s', $this->value->__toString() ); } } dbunit-2.0.2/src/Extensions/Database/Constraint/TableIsEqual.php000066400000000000000000000041771261611365500246210ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Asserts whether or not two dbunit tables are equal. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Constraint_TableIsEqual extends PHPUnit_Framework_Constraint { /** * @var PHPUnit_Extensions_Database_DataSet_ITable */ protected $value; /** * @var string */ protected $failure_reason; /** * Creates a new constraint. * * @param PHPUnit_Extensions_Database_DataSet_ITable $value */ public function __construct(PHPUnit_Extensions_Database_DataSet_ITable $value) { parent::__construct(); $this->value = $value; } /** * Evaluates the constraint for parameter $other. Returns TRUE if the * constraint is met, FALSE otherwise. * * This method can be overridden to implement the evaluation algorithm. * * @param mixed $other Value or object to evaluate. * @return bool */ protected function matches($other) { if (!$other instanceof PHPUnit_Extensions_Database_DataSet_ITable) { throw new InvalidArgumentException( 'PHPUnit_Extensions_Database_DataSet_ITable expected' ); } return $this->value->matches($other); } /** * Returns the description of the failure * * The beginning of failure messages is "Failed asserting that" in most * cases. This method should return the second part of that sentence. * * @param mixed $other Evaluated value or object. * @return string */ protected function failureDescription($other) { return $other->__toString() . ' ' . $this->toString(); } /** * Returns a string representation of the constraint. * * @return string */ public function toString() { return sprintf( 'is equal to expected %s', $this->value->__toString() ); } } dbunit-2.0.2/src/Extensions/Database/Constraint/TableRowCount.php000066400000000000000000000026231261611365500250300ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Asserts the row count in a table * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Constraint_TableRowCount extends PHPUnit_Framework_Constraint { /** * @var int */ protected $value; /** * @var string */ protected $tableName; /** * Creates a new constraint. * * @param $tableName * @param $value */ public function __construct($tableName, $value) { parent::__construct(); $this->tableName = $tableName; $this->value = $value; } /** * Evaluates the constraint for parameter $other. Returns TRUE if the * constraint is met, FALSE otherwise. * * This method can be overridden to implement the evaluation algorithm. * * @param mixed $other Value or object to evaluate. * @return bool */ protected function matches($other) { return $other == $this->value; } /** * Returns a string representation of the constraint. * * @return string */ public function toString() { return sprintf('is equal to expected row count %d', $this->value); } } dbunit-2.0.2/src/Extensions/Database/DB/000077500000000000000000000000001261611365500177255ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/DB/DataSet.php000066400000000000000000000105031261611365500217620ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides access to a database instance as a data set. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_DataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * An array of ITable objects. * * @var array */ protected $tables = []; /** * The database connection this dataset is using. * * @var PHPUnit_Extensions_Database_DB_IDatabaseConnection */ protected $databaseConnection; /** * Creates a new dataset using the given database connection. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection */ public function __construct(PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection) { $this->databaseConnection = $databaseConnection; } /** * Creates the query necessary to pull all of the data from a table. * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData * @return unknown */ public static function buildTableSelect(PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData, PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection = NULL) { if ($tableMetaData->getTableName() == '') { $e = new Exception('Empty Table Name'); echo $e->getTraceAsString(); throw $e; } $columns = $tableMetaData->getColumns(); if ($databaseConnection) { $columns = array_map([$databaseConnection, 'quoteSchemaObject'], $columns); } $columnList = implode(', ', $columns); if ($databaseConnection) { $tableName = $databaseConnection->quoteSchemaObject($tableMetaData->getTableName()); } else { $tableName = $tableMetaData->getTableName(); } $primaryKeys = $tableMetaData->getPrimaryKeys(); if ($databaseConnection) { $primaryKeys = array_map([$databaseConnection, 'quoteSchemaObject'], $primaryKeys); } if (count($primaryKeys)) { $orderBy = 'ORDER BY ' . implode(' ASC, ', $primaryKeys) . ' ASC'; } else { $orderBy = ''; } return "SELECT {$columnList} FROM {$tableName} {$orderBy}"; } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DB_TableIterator */ protected function createIterator($reverse = FALSE) { return new PHPUnit_Extensions_Database_DB_TableIterator($this->getTableNames(), $this, $reverse); } /** * Returns a table object for the given table. * * @param string $tableName * @return PHPUnit_Extensions_Database_DB_Table */ public function getTable($tableName) { if (!in_array($tableName, $this->getTableNames())) { throw new InvalidArgumentException("$tableName is not a table in the current database."); } if (empty($this->tables[$tableName])) { $this->tables[$tableName] = new PHPUnit_Extensions_Database_DB_Table($this->getTableMetaData($tableName), $this->databaseConnection); } return $this->tables[$tableName]; } /** * Returns a table meta data object for the given table. * * @param string $tableName * @return PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData */ public function getTableMetaData($tableName) { return new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData($tableName, $this->databaseConnection->getMetaData()->getTableColumns($tableName), $this->databaseConnection->getMetaData()->getTablePrimaryKeys($tableName)); } /** * Returns a list of table names for the database * * @return Array */ public function getTableNames() { return $this->databaseConnection->getMetaData()->getTableNames(); } } dbunit-2.0.2/src/Extensions/Database/DB/DefaultDatabaseConnection.php000066400000000000000000000115751261611365500255000ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface for communicating with a database. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection implements PHPUnit_Extensions_Database_DB_IDatabaseConnection { /** * @var PDO */ protected $connection; /** * The metadata object used to retrieve table meta data from the database. * * @var PHPUnit_Extensions_Database_DB_IMetaData */ protected $metaData; /** * Creates a new database connection * * @param PDO $connection * @param string $schema - The name of the database schema you will be testing against. */ public function __construct(PDO $connection, $schema = '') { $this->connection = $connection; $this->metaData = PHPUnit_Extensions_Database_DB_MetaData::createMetaData($connection, $schema); $connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); } /** * Close this connection. */ public function close() { unset($this->connection); } /** * Returns a database metadata object that can be used to retrieve table * meta data from the database. * * @return PHPUnit_Extensions_Database_DB_IMetaData */ public function getMetaData() { return $this->metaData; } /** * Returns the schema for the connection. * * @return string */ public function getSchema() { return $this->getMetaData()->getSchema(); } /** * Creates a dataset containing the specified table names. If no table * names are specified then it will created a dataset over the entire * database. * * @param array $tableNames * @return PHPUnit_Extensions_Database_DataSet_IDataSet * @todo Implement the filtered data set. */ public function createDataSet(array $tableNames = NULL) { if (empty($tableNames)) { return new PHPUnit_Extensions_Database_DB_DataSet($this); } else { return new PHPUnit_Extensions_Database_DB_FilteredDataSet($this, $tableNames); } } /** * Creates a table with the result of the specified SQL statement. * * @param string $resultName * @param string $sql * @return PHPUnit_Extensions_Database_DB_Table */ public function createQueryTable($resultName, $sql) { return new PHPUnit_Extensions_Database_DataSet_QueryTable($resultName, $sql, $this); } /** * Returns this connection database configuration * * @return PHPUnit_Extensions_Database_Database_DatabaseConfig */ public function getConfig() { } /** * Returns a PDO Connection * * @return PDO */ public function getConnection() { return $this->connection; } /** * Returns the number of rows in the given table. You can specify an * optional where clause to return a subset of the table. * * @param string $tableName * @param string $whereClause * @return int */ public function getRowCount($tableName, $whereClause = NULL) { $query = 'SELECT COUNT(*) FROM ' . $this->quoteSchemaObject($tableName); if (isset($whereClause)) { $query .= " WHERE {$whereClause}"; } return (int) $this->connection->query($query)->fetchColumn(); } /** * Returns a quoted schema object. (table name, column name, etc) * * @param string $object * @return string */ public function quoteSchemaObject($object) { return $this->getMetaData()->quoteSchemaObject($object); } /** * Returns the command used to truncate a table. * * @return string */ public function getTruncateCommand() { return $this->getMetaData()->getTruncateCommand(); } /** * Returns true if the connection allows cascading * * @return bool */ public function allowsCascading() { return $this->getMetaData()->allowsCascading(); } /** * Disables primary keys if connection does not allow setting them otherwise * * @param string $tableName */ public function disablePrimaryKeys($tableName) { $this->getMetaData()->disablePrimaryKeys($tableName); } /** * Reenables primary keys after they have been disabled * * @param string $tableName */ public function enablePrimaryKeys($tableName) { $this->getMetaData()->enablePrimaryKeys($tableName); } } dbunit-2.0.2/src/Extensions/Database/DB/FilteredDataSet.php000066400000000000000000000021061261611365500234410ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides access to a database instance as a data set. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_FilteredDataSet extends PHPUnit_Extensions_Database_DB_DataSet { /** * @var Array */ protected $tableNames; /** * Creates a new dataset using the given database connection. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection */ public function __construct(PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection, Array $tableNames) { parent::__construct($databaseConnection); $this->tableNames = $tableNames; } /** * Returns a list of table names for the database * * @return Array */ public function getTableNames() { return $this->tableNames; } } dbunit-2.0.2/src/Extensions/Database/DB/IDatabaseConnection.php000066400000000000000000000054101261611365500242730ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface for communicating with a database. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DB_IDatabaseConnection { /** * Close this connection. */ public function close(); /** * Creates a dataset containing the specified table names. If no table * names are specified then it will created a dataset over the entire * database. * * @param array $tableNames * @return PHPUnit_Extensions_Database_DataSet_IDataSet */ public function createDataSet(Array $tableNames = NULL); /** * Creates a table with the result of the specified SQL statement. * * @param string $resultName * @param string $sql * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function createQueryTable($resultName, $sql); /** * Returns a PDO Connection * * @return PDO */ public function getConnection(); /** * Returns a database metadata object that can be used to retrieve table * meta data from the database. * * @return PHPUnit_Extensions_Database_DB_IMetaData */ public function getMetaData(); /** * Returns the number of rows in the given table. You can specify an * optional where clause to return a subset of the table. * * @param string $tableName * @param string $whereClause * @param int */ public function getRowCount($tableName, $whereClause = NULL); /** * Returns the schema for the connection. * * @return string */ public function getSchema(); /** * Returns a quoted schema object. (table name, column name, etc) * * @param string $object * @return string */ public function quoteSchemaObject($object); /** * Returns the command used to truncate a table. * * @return string */ public function getTruncateCommand(); /** * Returns true if the connection allows cascading * * @return bool */ public function allowsCascading(); /** * Disables primary keys if connection does not allow setting them otherwise * * @param string $tableName */ public function disablePrimaryKeys($tableName); /** * Reenables primary keys after they have been disabled * * @param string $tableName */ public function enablePrimaryKeys($tableName); } dbunit-2.0.2/src/Extensions/Database/DB/IMetaData.php000066400000000000000000000034631261611365500222350ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface for retreiving metadata from a database. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DB_IMetaData { /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames(); /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName); /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName); /** * Returns the name of the default schema. * * @return string */ public function getSchema(); /** * Returns a quoted schema object. (table name, column name, etc) * * @param string $object * @return string */ public function quoteSchemaObject($object); /** * Returns true if the rdbms allows cascading * * @return bool */ public function allowsCascading(); /** * Disables primary keys if rdbms does not allow setting them otherwise * * @param string $tableName */ public function disablePrimaryKeys($tableName); /** * Reenables primary keys after they have been disabled * * @param string $tableName */ public function enablePrimaryKeys($tableName); } dbunit-2.0.2/src/Extensions/Database/DB/MetaData.php000066400000000000000000000142451261611365500221240ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic constructor for all meta data classes and a factory for * generating the appropriate meta data class. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_DB_MetaData implements PHPUnit_Extensions_Database_DB_IMetaData { protected static $metaDataClassMap = [ 'pgsql' => 'PHPUnit_Extensions_Database_DB_MetaData_PgSQL', 'mysql' => 'PHPUnit_Extensions_Database_DB_MetaData_MySQL', 'oci' => 'PHPUnit_Extensions_Database_DB_MetaData_Oci', 'sqlite' => 'PHPUnit_Extensions_Database_DB_MetaData_Sqlite', 'sqlite2' => 'PHPUnit_Extensions_Database_DB_MetaData_Sqlite', 'sqlsrv' => 'PHPUnit_Extensions_Database_DB_MetaData_SqlSrv', 'firebird' => 'PHPUnit_Extensions_Database_DB_MetaData_Firebird', 'dblib' => 'PHPUnit_Extensions_Database_DB_MetaData_Dblib' ]; /** * The PDO connection used to retreive database meta data * * @var PDO */ protected $pdo; /** * The default schema name for the meta data object. * * @var string */ protected $schema; /** * The character used to quote schema objects. */ protected $schemaObjectQuoteChar = '"'; /** * The command used to perform a TRUNCATE operation. */ protected $truncateCommand = 'TRUNCATE'; /** * Creates a new database meta data object using the given pdo connection * and schema name. * * @param PDO $pdo * @param string $schema */ public final function __construct(PDO $pdo, $schema = '') { $this->pdo = $pdo; $this->schema = $schema; } /** * Creates a meta data object based on the driver of given $pdo object and * $schema name. * * @param PDO $pdo * @param string $schema * @return PHPUnit_Extensions_Database_DB_MetaData */ public static function createMetaData(PDO $pdo, $schema = '') { $driverName = $pdo->getAttribute(PDO::ATTR_DRIVER_NAME); if (isset(self::$metaDataClassMap[$driverName])) { $className = self::$metaDataClassMap[$driverName]; if ($className instanceof ReflectionClass) { return $className->newInstance($pdo, $schema); } else { return self::registerClassWithDriver($className, $driverName)->newInstance($pdo, $schema); } } else { throw new PHPUnit_Extensions_Database_Exception("Could not find a meta data driver for {$driverName} pdo driver."); } } /** * Validates and registers the given $className with the given $pdoDriver. * It should be noted that this function will not attempt to include / * require the file. The $pdoDriver can be determined by the value of the * PDO::ATTR_DRIVER_NAME attribute for a pdo object. * * A reflection of the $className is returned. * * @param string $className * @param string $pdoDriver * @return ReflectionClass */ public static function registerClassWithDriver($className, $pdoDriver) { if (!class_exists($className)) { throw new PHPUnit_Extensions_Database_Exception("Specified class for {$pdoDriver} driver ({$className}) does not exist."); } $reflection = new ReflectionClass($className); if ($reflection->isSubclassOf('PHPUnit_Extensions_Database_DB_MetaData')) { return self::$metaDataClassMap[$pdoDriver] = $reflection; } else { throw new PHPUnit_Extensions_Database_Exception("Specified class for {$pdoDriver} driver ({$className}) does not extend PHPUnit_Extensions_Database_DB_MetaData."); } } /** * Returns the schema for the connection. * * @return string */ public function getSchema() { return $this->schema; } /** * Returns a quoted schema object. (table name, column name, etc) * * @param string $object * @return string */ public function quoteSchemaObject($object) { $parts = explode('.', $object); $quotedParts = []; foreach ($parts as $part) { $quotedParts[] = $this->schemaObjectQuoteChar . str_replace($this->schemaObjectQuoteChar, $this->schemaObjectQuoteChar . $this->schemaObjectQuoteChar, $part) . $this->schemaObjectQuoteChar; } return implode('.', $quotedParts); } /** * Seperates the schema and the table from a fully qualified table name. * * Returns an associative array containing the 'schema' and the 'table'. * * @param string $fullTableName * @return array */ public function splitTableName($fullTableName) { if (($dot = strpos($fullTableName, '.')) !== FALSE) { return [ 'schema' => substr($fullTableName, 0, $dot), 'table' => substr($fullTableName, $dot + 1) ]; } else { return [ 'schema' => NULL, 'table' => $fullTableName ]; } } /** * Returns the command for the database to truncate a table. * * @return string */ public function getTruncateCommand() { return $this->truncateCommand; } /** * Returns true if the rdbms allows cascading * * @return bool */ public function allowsCascading() { return FALSE; } /** * Disables primary keys if the rdbms does not allow setting them otherwise * * @param string $tableName */ public function disablePrimaryKeys($tableName) { return; } /** * Reenables primary keys after they have been disabled * * @param string $tableName */ public function enablePrimaryKeys($tableName) { return; } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/000077500000000000000000000000001261611365500214055ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/DB/MetaData/Dblib.php000066400000000000000000000053711261611365500231400ustar00rootroot00000000000000pdo->query($query); while ($tableName = $result->fetchColumn(0)) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName) { if (!isset($this->columns[$tableName])) { $this->loadColumnInfo($tableName); } return $this->columns[$tableName]; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { if (!isset($this->keys[$tableName])) { $this->loadColumnInfo($tableName); } return $this->keys[$tableName]; } /** * Loads column info from a sql server database. * * @param string $tableName */ protected function loadColumnInfo($tableName) { $query = "SELECT name FROM sys.columns WHERE object_id = OBJECT_ID('" . $tableName . "') ORDER BY column_id"; $result = $this->pdo->query($query); while ($columnName = $result->fetchColumn(0)) { $this->columns[$tableName][] = $columnName; } $keyQuery = "SELECT COL_NAME(ic.OBJECT_ID,ic.column_id) AS ColumnName FROM sys.indexes AS i INNER JOIN sys.index_columns AS ic ON i.OBJECT_ID = ic.OBJECT_ID AND i.index_id = ic.index_id WHERE i.is_primary_key = 1 AND OBJECT_NAME(ic.OBJECT_ID) = '" . $tableName . "'"; $result = $this->pdo->query($keyQuery); while ($columnName = $result->fetchColumn(0)) { $this->keys[$tableName][] = $columnName; } } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/Firebird.php000066400000000000000000000127451261611365500236550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides functionality to retrieve meta data from a Firebird database. * * @version Release: 1.1.2 * @since */ class PHPUnit_Extensions_Database_DB_MetaData_Firebird extends PHPUnit_Extensions_Database_DB_MetaData { /** * The command used to perform a TRUNCATE operation. * @var string */ protected $truncateCommand = 'DELETE FROM'; /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames() { $query = " SELECT DISTINCT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE' AND TABLE_SCHEMA = ? ORDER BY TABLE_NAME "; $query = " select RDB$RELATION_NAME as TABLE_NAME from RDB$RELATIONS where ((RDB$RELATION_TYPE = 0) or (RDB$RELATION_TYPE is null)) and (RDB$SYSTEM_FLAG = 0) order by (RDB$RELATION_NAME) "; $statement = $this->pdo->prepare($query); $statement->execute([$this->getSchema()]); $tableNames = []; while ($tableName = $statement->fetchColumn(0)) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName) { if (!isset($this->columns[$tableName])) { $this->loadColumnInfo($tableName); } return $this->columns[$tableName]; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { if (!isset($this->keys[$tableName])) { $this->loadColumnInfo($tableName); } return $this->keys[$tableName]; } /** * Loads column info from a database table. * * @param string $tableName */ protected function loadColumnInfo($tableName) { $this->columns[$tableName] = []; $this->keys[$tableName] = []; $columnQuery = ' SELECT DISTINCT COLUMN_NAME, ORDINAL_POSITION FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ? AND TABLE_SCHEMA = ? ORDER BY ORDINAL_POSITION '; $columnQuery = " select rf.RDB\$FIELD_NAME as COLUMN_NAME, rf.RDB\$FIELD_POSITION as ORDINAL_POSITION from RDB\$RELATION_FIELDS as rf where upper(RDB\$RELATION_NAME) = upper(?) order by ORDINAL_POSITION "; $columnStatement = $this->pdo->prepare($columnQuery); $columnStatement->execute([$tableName]); while ($columName = $columnStatement->fetchColumn(0)) { $this->columns[$tableName][] = $columName; } $keyQuery = " SELECT KCU.COLUMN_NAME, KCU.ORDINAL_POSITION FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE as KCU LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS as TC ON TC.TABLE_NAME = KCU.TABLE_NAME WHERE TC.CONSTRAINT_TYPE = 'PRIMARY KEY' AND TC.TABLE_NAME = ? AND TC.TABLE_SCHEMA = ? ORDER BY KCU.ORDINAL_POSITION ASC "; $keyQuery = " select idseg.rdb\$field_name as COLUMN_NAME, idseg.rdb\$field_position as ORDINAL_POSITION, rc.rdb\$relation_name as tablename, rc.rdb\$constraint_name as pk_name from RDB\$RELATION_CONSTRAINTS AS rc left join rdb\$index_segments as idseg on (rc.rdb\$index_name = idseg.rdb\$index_name) where rc.RDB\$CONSTRAINT_TYPE = 'PRIMARY KEY' and upper(rc.RDB\$RELATION_NAME) = upper(?) order by rc.rdb\$constraint_name, idseg.rdb\$field_position "; $keyStatement = $this->pdo->prepare($keyQuery); $keyStatement->execute([$tableName]); while ($columName = $keyStatement->fetchColumn(0)) { $this->keys[$tableName][] = $columName; } } /** * Returns the schema for the connection. * * @return string */ public function getSchema() { if (empty($this->schema)) { return 'public'; } else { return $this->schema; } } /** * Returns true if the rdbms allows cascading * * @return bool */ public function allowsCascading() { return false; } /** * Returns a quoted schema object. (table name, column name, etc) * * @param string $object * @return string */ public function quoteSchemaObject($object) { return $object; //firebird does not allow object quoting } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/InformationSchema.php000066400000000000000000000071011261611365500255230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides functionality to retrieve meta data from a database with information_schema support. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_MetaData_InformationSchema extends PHPUnit_Extensions_Database_DB_MetaData { protected $columns = []; protected $keys = []; /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames() { $query = " SELECT DISTINCT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE' AND TABLE_SCHEMA = ? ORDER BY TABLE_NAME "; $statement = $this->pdo->prepare($query); $statement->execute([$this->getSchema()]); $tableNames = []; while ($tableName = $statement->fetchColumn(0)) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName) { if (!isset($this->columns[$tableName])) { $this->loadColumnInfo($tableName); } return $this->columns[$tableName]; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { if (!isset($this->keys[$tableName])) { $this->loadColumnInfo($tableName); } return $this->keys[$tableName]; } /** * Loads column info from a sqlite database. * * @param string $tableName */ protected function loadColumnInfo($tableName) { $this->columns[$tableName] = []; $this->keys[$tableName] = []; $columnQuery = ' SELECT DISTINCT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ? AND TABLE_SCHEMA = ? ORDER BY ORDINAL_POSITION '; $columnStatement = $this->pdo->prepare($columnQuery); $columnStatement->execute([$tableName, $this->getSchema()]); while ($columName = $columnStatement->fetchColumn(0)) { $this->columns[$tableName][] = $columName; } $keyQuery = " SELECT KCU.COLUMN_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS as TC, INFORMATION_SCHEMA.KEY_COLUMN_USAGE as KCU WHERE TC.CONSTRAINT_NAME = KCU.CONSTRAINT_NAME AND TC.TABLE_NAME = KCU.TABLE_NAME AND TC.TABLE_SCHEMA = KCU.TABLE_SCHEMA AND TC.CONSTRAINT_TYPE = 'PRIMARY KEY' AND TC.TABLE_NAME = ? AND TC.TABLE_SCHEMA = ? ORDER BY KCU.ORDINAL_POSITION ASC "; $keyStatement = $this->pdo->prepare($keyQuery); $keyStatement->execute([$tableName, $this->getSchema()]); while ($columName = $keyStatement->fetchColumn(0)) { $this->keys[$tableName][] = $columName; } } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/MySQL.php000066400000000000000000000042751261611365500230730ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides functionality to retrieve meta data from a MySQL database. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_MetaData_MySQL extends PHPUnit_Extensions_Database_DB_MetaData { protected $schemaObjectQuoteChar = '`'; /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames() { $query = 'SHOW TABLES'; $statement = $this->pdo->prepare($query); $statement->execute(); $tableNames = []; while (($tableName = $statement->fetchColumn(0))) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName) { $query = 'SHOW COLUMNS FROM ' . $this->quoteSchemaObject($tableName); $statement = $this->pdo->prepare($query); $statement->execute(); $columnNames = []; while (($columnName = $statement->fetchColumn(0))) { $columnNames[] = $columnName; } return $columnNames; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { $query = 'SHOW INDEX FROM ' . $this->quoteSchemaObject($tableName); $statement = $this->pdo->prepare($query); $statement->execute(); $statement->setFetchMode(PDO::FETCH_ASSOC); $columnNames = []; while (($column = $statement->fetch())) { if ($column['Key_name'] == 'PRIMARY') { $columnNames[] = $column['Column_name']; } } return $columnNames; } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/Oci.php000066400000000000000000000071111261611365500226300ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides functionality to retrieve meta data from an Oracle database. * * @since Class available since Release 3.2.3 */ class PHPUnit_Extensions_Database_DB_MetaData_Oci extends PHPUnit_Extensions_Database_DB_MetaData { /** * No character used to quote schema objects. * @var string */ protected $schemaObjectQuoteChar = ''; /** * The command used to perform a TRUNCATE operation. * @var string */ protected $truncateCommand = 'TRUNCATE TABLE'; /** * @var array */ protected $columns = []; /** * @var array */ protected $keys = []; /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames() { $tableNames = []; $query = "SELECT table_name FROM cat WHERE table_type='TABLE' ORDER BY table_name"; $result = $this->pdo->query($query); while ($tableName = $result->fetchColumn(0)) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName) { if (!isset($this->columns[$tableName])) { $this->loadColumnInfo($tableName); } return $this->columns[$tableName]; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { if (!isset($this->keys[$tableName])) { $this->loadColumnInfo($tableName); } return $this->keys[$tableName]; } /** * Loads column info from a oracle database. * * @param string $tableName */ protected function loadColumnInfo($tableName) { $ownerQuery = ''; $conOwnerQuery = ''; $tableParts = $this->splitTableName($tableName); $this->columns[$tableName] = []; $this->keys[$tableName] = []; if (!empty($tableParts['schema'])) { $ownerQuery = " AND OWNER = '{$tableParts['schema']}'"; $conOwnerQuery = " AND a.owner = '{$tableParts['schema']}'"; } $query = "SELECT DISTINCT COLUMN_NAME FROM USER_TAB_COLUMNS WHERE TABLE_NAME='" . $tableParts['table'] . "' $ownerQuery ORDER BY COLUMN_NAME"; $result = $this->pdo->query($query); while ($columnName = $result->fetchColumn(0)) { $this->columns[$tableName][] = $columnName; } $keyQuery = "SELECT b.column_name FROM user_constraints a, user_cons_columns b WHERE a.constraint_type='P' AND a.constraint_name=b.constraint_name $conOwnerQuery AND a.table_name = '" . $tableParts['table'] . "' "; $result = $this->pdo->query($keyQuery); while ($columnName = $result->fetchColumn(0)) { $this->keys[$tableName][] = $columnName; } } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/PgSQL.php000066400000000000000000000076261261611365500230570ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides functionality to retrieve meta data from a PostgreSQL database. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_MetaData_PgSQL extends PHPUnit_Extensions_Database_DB_MetaData { /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames() { $query = " SELECT DISTINCT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE' AND TABLE_SCHEMA = ? ORDER BY TABLE_NAME "; $statement = $this->pdo->prepare($query); $statement->execute([$this->getSchema()]); $tableNames = []; while ($tableName = $statement->fetchColumn(0)) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName) { if (!isset($this->columns[$tableName])) { $this->loadColumnInfo($tableName); } return $this->columns[$tableName]; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { if (!isset($this->keys[$tableName])) { $this->loadColumnInfo($tableName); } return $this->keys[$tableName]; } /** * Loads column info from a database table. * * @param string $tableName */ protected function loadColumnInfo($tableName) { $this->columns[$tableName] = []; $this->keys[$tableName] = []; $columnQuery = ' SELECT DISTINCT COLUMN_NAME, ORDINAL_POSITION FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ? AND TABLE_SCHEMA = ? ORDER BY ORDINAL_POSITION '; $columnStatement = $this->pdo->prepare($columnQuery); $columnStatement->execute([$tableName, $this->getSchema()]); while ($columName = $columnStatement->fetchColumn(0)) { $this->columns[$tableName][] = $columName; } $keyQuery = " SELECT KCU.COLUMN_NAME, KCU.ORDINAL_POSITION FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE as KCU LEFT JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS as TC ON TC.TABLE_NAME = KCU.TABLE_NAME AND TC.CONSTRAINT_NAME = KCU.CONSTRAINT_NAME WHERE TC.CONSTRAINT_TYPE = 'PRIMARY KEY' AND TC.TABLE_NAME = ? AND TC.TABLE_SCHEMA = ? ORDER BY KCU.ORDINAL_POSITION ASC "; $keyStatement = $this->pdo->prepare($keyQuery); $keyStatement->execute([$tableName, $this->getSchema()]); while ($columName = $keyStatement->fetchColumn(0)) { $this->keys[$tableName][] = $columName; } } /** * Returns the schema for the connection. * * @return string */ public function getSchema() { if (empty($this->schema)) { return 'public'; } else { return $this->schema; } } /** * Returns true if the rdbms allows cascading * * @return bool */ public function allowsCascading() { return TRUE; } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/SqlSrv.php000066400000000000000000000066031261611365500233550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides functionality to retrieve meta data from a Microsoft SQL Server database. * * @since Class available since Release 1.1.0 */ class PHPUnit_Extensions_Database_DB_MetaData_SqlSrv extends PHPUnit_Extensions_Database_DB_MetaData { /** * No character used to quote schema objects. * @var string */ protected $schemaObjectQuoteChar = ''; /** * The command used to perform a TRUNCATE operation. * @var string */ protected $truncateCommand = 'TRUNCATE TABLE'; /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames() { $query = "SELECT name FROM sysobjects WHERE type='U'"; $statement = $this->pdo->prepare($query); $statement->execute(); $tableNames = []; while (($tableName = $statement->fetchColumn(0))) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table. * * @param string $tableName * @return array */ public function getTableColumns($tableName) { $query = "SELECT c.name FROM syscolumns c LEFT JOIN sysobjects o ON c.id = o.id WHERE o.name = '$tableName'"; $statement = $this->pdo->prepare($query); $statement->execute(); $columnNames = []; while (($columnName = $statement->fetchColumn(0))) { $columnNames[] = $columnName; } return $columnNames; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { $query = "EXEC sp_statistics '$tableName'"; $statement = $this->pdo->prepare($query); $statement->execute(); $statement->setFetchMode(PDO::FETCH_ASSOC); $columnNames = []; while (($column = $statement->fetch())) { if ($column['TYPE'] == 1) { $columnNames[] = $column['COLUMN_NAME']; } } return $columnNames; } /** * Allow overwriting identities for the given table. * * @param string $tableName */ public function disablePrimaryKeys($tableName) { try { $query = "SET IDENTITY_INSERT $tableName ON"; $this->pdo->exec($query); } catch (PDOException $e) { // ignore the error here - can happen if primary key is not an identity } } /** * Reenable auto creation of identities for the given table. * * @param string $tableName */ public function enablePrimaryKeys($tableName) { try { $query = "SET IDENTITY_INSERT $tableName OFF"; $this->pdo->exec($query); } catch (PDOException $e) { // ignore the error here - can happen if primary key is not an identity } } } dbunit-2.0.2/src/Extensions/Database/DB/MetaData/Sqlite.php000066400000000000000000000050321261611365500233570ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides functionality to retrieve meta data from an Sqlite database. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_MetaData_Sqlite extends PHPUnit_Extensions_Database_DB_MetaData { protected $columns = []; protected $keys = []; protected $truncateCommand = 'DELETE FROM'; /** * Returns an array containing the names of all the tables in the database. * * @return array */ public function getTableNames() { $query = " SELECT name FROM sqlite_master WHERE type='table' AND name <> 'sqlite_sequence' ORDER BY name "; $result = $this->pdo->query($query); $tableNames = []; while ($tableName = $result->fetchColumn(0)) { $tableNames[] = $tableName; } return $tableNames; } /** * Returns an array containing the names of all the columns in the * $tableName table, * * @param string $tableName * @return array */ public function getTableColumns($tableName) { if (!isset($this->columns[$tableName])) { $this->loadColumnInfo($tableName); } return $this->columns[$tableName]; } /** * Returns an array containing the names of all the primary key columns in * the $tableName table. * * @param string $tableName * @return array */ public function getTablePrimaryKeys($tableName) { if (!isset($this->keys[$tableName])) { $this->loadColumnInfo($tableName); } return $this->keys[$tableName]; } /** * Loads column info from a sqlite database. * * @param string $tableName */ protected function loadColumnInfo($tableName) { $query = "PRAGMA table_info('{$tableName}')"; $statement = $this->pdo->query($query); /* @var $statement PDOStatement */ $this->columns[$tableName] = []; $this->keys[$tableName] = []; while ($columnData = $statement->fetch(PDO::FETCH_NUM)) { $this->columns[$tableName][] = $columnData[1]; if ($columnData[5] == 1) { $this->keys[$tableName][] = $columnData[1]; } } } } dbunit-2.0.2/src/Extensions/Database/DB/ResultSetTable.php000066400000000000000000000023431261611365500233420ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides the functionality to represent a database result set as a DBUnit * table. * * @deprecated The PHPUnit_Extension_Database_DataSet_QueryTable should be used instead * @see PHPUnit_Extension_Database_DataSet_QueryTable * @see PHPUnit_Extension_Database_DataSet_QueryDataSet * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_ResultSetTable extends PHPUnit_Extensions_Database_DataSet_AbstractTable { /** * Creates a new result set table. * * @param string $tableName * @param PDOStatement $pdoStatement */ public function __construct($tableName, PDOStatement $pdoStatement) { $this->data = $pdoStatement->fetchAll(PDO::FETCH_ASSOC); if (count($this->data)) { $columns = array_keys($this->data[0]); } else { $columns = []; } $this->setTableMetaData(new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData($tableName, $columns)); } } dbunit-2.0.2/src/Extensions/Database/DB/Table.php000066400000000000000000000022421261611365500214650ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides the functionality to represent a database table. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_Table extends PHPUnit_Extensions_Database_DataSet_AbstractTable { /** * Creates a new database table object. * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection */ public function __construct(PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData, PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection) { $this->setTableMetaData($tableMetaData); $pdoStatement = $databaseConnection->getConnection()->prepare(PHPUnit_Extensions_Database_DB_DataSet::buildTableSelect($tableMetaData, $databaseConnection)); $pdoStatement->execute(); $this->data = $pdoStatement->fetchAll(PDO::FETCH_ASSOC); } } dbunit-2.0.2/src/Extensions/Database/DB/TableIterator.php000066400000000000000000000051751261611365500232070ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides iterative access to tables from a database instance. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_TableIterator implements PHPUnit_Extensions_Database_DataSet_ITableIterator { /** * An array of tablenames. * * @var Array */ protected $tableNames; /** * If this property is true then the tables will be iterated in reverse * order. * * @var bool */ protected $reverse; /** * The database dataset that this iterator iterates over. * * @var PHPUnit_Extensions_Database_DB_DataSet */ protected $dataSet; public function __construct($tableNames, PHPUnit_Extensions_Database_DB_DataSet $dataSet, $reverse = FALSE) { $this->tableNames = $tableNames; $this->dataSet = $dataSet; $this->reverse = $reverse; $this->rewind(); } /** * Returns the current table. * * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function getTable() { return $this->current(); } /** * Returns the current table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData() { return $this->current()->getTableMetaData(); } /** * Returns the current table. * * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function current() { $tableName = current($this->tableNames); return $this->dataSet->getTable($tableName); } /** * Returns the name of the current table. * * @return string */ public function key() { return $this->current()->getTableMetaData()->getTableName(); } /** * advances to the next element. */ public function next() { if ($this->reverse) { prev($this->tableNames); } else { next($this->tableNames); } } /** * Rewinds to the first element */ public function rewind() { if ($this->reverse) { end($this->tableNames); } else { reset($this->tableNames); } } /** * Returns true if the current index is valid * * @return bool */ public function valid() { return (current($this->tableNames) !== FALSE); } } dbunit-2.0.2/src/Extensions/Database/DB/TableMetaData.php000066400000000000000000000014311261611365500230650ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * This class loads a table metadata object with database metadata. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DB_TableMetaData extends PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData { public function __construct($tableName, PHPUnit_Extensions_Database_DB_IMetaData $databaseMetaData) { $this->tableName = $tableName; $this->columns = $databaseMetaData->getTableColumns($tableName); $this->primaryKeys = $databaseMetaData->getTablePrimaryKeys($tableName); } } dbunit-2.0.2/src/Extensions/Database/DataSet/000077500000000000000000000000001261611365500207655ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/DataSet/AbstractDataSet.php000066400000000000000000000070361261611365500245150ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Implements the basic functionality of data sets. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_DataSet_AbstractDataSet implements PHPUnit_Extensions_Database_DataSet_IDataSet { /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected abstract function createIterator($reverse = FALSE); /** * Returns an array of table names contained in the dataset. * * @return array */ public function getTableNames() { $tableNames = []; foreach ($this->getIterator() as $table) { /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ $tableNames[] = $table->getTableMetaData()->getTableName(); } return $tableNames; } /** * Returns a table meta data object for the given table. * * @param string $tableName * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData($tableName) { return $this->getTable($tableName)->getTableMetaData(); } /** * Returns a table object for the given table. * * @param string $tableName * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function getTable($tableName) { foreach ($this->getIterator() as $table) { /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ if ($table->getTableMetaData()->getTableName() == $tableName) { return $table; } } } /** * Returns an iterator for all table objects in the given dataset. * * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ public function getIterator() { return $this->createIterator(); } /** * Returns a reverse iterator for all table objects in the given dataset. * * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ public function getReverseIterator() { return $this->createIterator(TRUE); } /** * Asserts that the given data set matches this data set. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $other */ public function matches(PHPUnit_Extensions_Database_DataSet_IDataSet $other) { $thisTableNames = $this->getTableNames(); $otherTableNames = $other->getTableNames(); sort($thisTableNames); sort($otherTableNames); if ($thisTableNames != $otherTableNames) { return FALSE; } foreach ($thisTableNames as $tableName) { $table = $this->getTable($tableName); if (!$table->matches($other->getTable($tableName))) { return FALSE; } } return TRUE; } public function __toString() { $iterator = $this->getIterator(); $dataSetString = ''; foreach ($iterator as $table) { $dataSetString .= $table->__toString(); } return $dataSetString; } } dbunit-2.0.2/src/Extensions/Database/DataSet/AbstractTable.php000066400000000000000000000145231261611365500242160ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic functionality for dbunit tables * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_AbstractTable implements PHPUnit_Extensions_Database_DataSet_ITable { /** * @var PHPUnit_Extensions_Database_DataSet_ITableMetaData */ protected $tableMetaData; /** * A 2-dimensional array containing the data for this table. * * @var array */ protected $data; /** * @var PHPUnit_Extensions_Database_DataSet_ITable|null */ private $other; /** * Sets the metadata for this table. * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData * @deprecated */ protected function setTableMetaData(PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData) { $this->tableMetaData = $tableMetaData; } /** * Returns the table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData() { return $this->tableMetaData; } /** * Returns the number of rows in this table. * * @return int */ public function getRowCount() { return count($this->data); } /** * Returns the value for the given column on the given row. * * @param int $row * @param int $column * @todo reorganize this function to throw the exception first. */ public function getValue($row, $column) { if (isset($this->data[$row][$column])) { $value = $this->data[$row][$column]; return ($value instanceof SimpleXMLElement) ? (string) $value : $value; } else { if (!in_array($column, $this->getTableMetaData()->getColumns()) || $this->getRowCount() <= $row) { throw new InvalidArgumentException("The given row ({$row}) and column ({$column}) do not exist in table {$this->getTableMetaData()->getTableName()}"); } else { return NULL; } } } /** * Returns the an associative array keyed by columns for the given row. * * @param int $row * @return array */ public function getRow($row) { if (isset($this->data[$row])) { return $this->data[$row]; } else { if ($this->getRowCount() <= $row) { throw new InvalidArgumentException("The given row ({$row}) does not exist in table {$this->getTableMetaData()->getTableName()}"); } else { return NULL; } } } /** * Asserts that the given table matches this table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $other */ public function matches(PHPUnit_Extensions_Database_DataSet_ITable $other) { $thisMetaData = $this->getTableMetaData(); $otherMetaData = $other->getTableMetaData(); if (!$thisMetaData->matches($otherMetaData) || $this->getRowCount() != $other->getRowCount()) { return FALSE; } $columns = $thisMetaData->getColumns(); $rowCount = $this->getRowCount(); for ($i = 0; $i < $rowCount; $i++) { foreach ($columns as $columnName) { $thisValue = $this->getValue($i, $columnName); $otherValue = $other->getValue($i, $columnName); if (is_numeric($thisValue) && is_numeric($otherValue)) { if ($thisValue != $otherValue) { $this->other = $other; return FALSE; } } elseif ($thisValue !== $otherValue) { $this->other = $other; return FALSE; } } } return TRUE; } /** * Checks if a given row is in the table * * @param array $row * * @return bool */ public function assertContainsRow(array $row) { return in_array($row, $this->data); } public function __toString() { $columns = $this->getTableMetaData()->getColumns(); $lineSeperator = str_repeat('+----------------------', count($columns)) . "+\n"; $lineLength = strlen($lineSeperator) - 1; $tableString = $lineSeperator; $tableString .= '| ' . str_pad($this->getTableMetaData()->getTableName(), $lineLength - 4, ' ', STR_PAD_RIGHT) . " |\n"; $tableString .= $lineSeperator; $tableString .= $this->rowToString($columns); $tableString .= $lineSeperator; $rowCount = $this->getRowCount(); for ($i = 0; $i < $rowCount; $i++) { $values = []; foreach ($columns as $columnName) { if ($this->other) { try { if ($this->getValue($i, $columnName) != $this->other->getValue($i, $columnName)) { $values[] = sprintf( '%s != actual %s', var_export($this->getValue($i, $columnName), TRUE), var_export($this->other->getValue($i, $columnName), TRUE) ); } else { $values[] = $this->getValue($i, $columnName); } } catch (\InvalidArgumentException $ex) { $values[] = $this->getValue($i, $columnName) . ': no row'; } } else { $values[] = $this->getValue($i, $columnName); } } $tableString .= $this->rowToString($values) . $lineSeperator; } return ($this->other ? '(table diff enabled)' : '') . "\n" . $tableString . "\n"; } protected function rowToString(Array $row) { $rowString = ''; foreach ($row as $value) { if (is_null($value)) { $value = 'NULL'; } $rowString .= '| ' . str_pad(substr($value, 0, 20), 20, ' ', STR_PAD_BOTH) . ' '; } return $rowString . "|\n"; } } dbunit-2.0.2/src/Extensions/Database/DataSet/AbstractTableMetaData.php000066400000000000000000000033411261611365500256130ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides basic functionality for table meta data. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_DataSet_AbstractTableMetaData implements PHPUnit_Extensions_Database_DataSet_ITableMetaData { /** * The names of all columns in the table. * * @var Array */ protected $columns; /** * The names of all the primary keys in the table. * * @var Array */ protected $primaryKeys; /** * @var string */ protected $tableName; /** * Returns the names of the columns in the table. * * @return array */ public function getColumns() { return $this->columns; } /** * Returns the names of the primary key columns in the table. * * @return array */ public function getPrimaryKeys() { return $this->primaryKeys; } /** * Returns the name of the table. * * @return string */ public function getTableName() { return $this->tableName; } /** * Asserts that the given tableMetaData matches this tableMetaData. * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $other */ public function matches(PHPUnit_Extensions_Database_DataSet_ITableMetaData $other) { if ($this->getTableName() != $other->getTableName() || $this->getColumns() != $other->getColumns()) { return FALSE; } return TRUE; } } dbunit-2.0.2/src/Extensions/Database/DataSet/AbstractXmlDataSet.php000066400000000000000000000063641261611365500252010ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default implementation of a data set. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_DataSet_AbstractXmlDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * @var array */ protected $tables; /** * @var SimpleXmlElement */ protected $xmlFileContents; /** * Creates a new dataset using the given tables. * * @param array $tables */ public function __construct($xmlFile) { if (!is_file($xmlFile)) { throw new InvalidArgumentException( "Could not find xml file: {$xmlFile}" ); } $libxmlErrorReporting = libxml_use_internal_errors(TRUE); $this->xmlFileContents = simplexml_load_file($xmlFile, 'SimpleXMLElement', LIBXML_COMPACT | LIBXML_PARSEHUGE); if (!$this->xmlFileContents) { $message = ''; foreach (libxml_get_errors() as $error) { $message .= print_r($error, true); } throw new RuntimeException($message); } libxml_clear_errors(); libxml_use_internal_errors($libxmlErrorReporting); $tableColumns = []; $tableValues = []; $this->getTableInfo($tableColumns, $tableValues); $this->createTables($tableColumns, $tableValues); } /** * Reads the simple xml object and creates the appropriate tables and meta * data for this dataset. */ protected abstract function getTableInfo(Array &$tableColumns, Array &$tableValues); protected function createTables(Array &$tableColumns, Array &$tableValues) { foreach ($tableValues as $tableName => $values) { $table = $this->getOrCreateTable($tableName, $tableColumns[$tableName]); foreach ($values as $value) { $table->addRow($value); } } } /** * Returns the table with the matching name. If the table does not exist * an empty one is created. * * @param string $tableName * @return PHPUnit_Extensions_Database_DataSet_ITable */ protected function getOrCreateTable($tableName, $tableColumns) { if (empty($this->tables[$tableName])) { $tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData($tableName, $tableColumns); $this->tables[$tableName] = new PHPUnit_Extensions_Database_DataSet_DefaultTable($tableMetaData); } return $this->tables[$tableName]; } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected function createIterator($reverse = FALSE) { return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse); } } dbunit-2.0.2/src/Extensions/Database/DataSet/ArrayDataSet.php000066400000000000000000000041571261611365500240310ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Implements the basic functionality of data sets using a PHP array. * * @since Class available since Release 1.3.2 */ class PHPUnit_Extensions_Database_DataSet_ArrayDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * @var array */ protected $tables = []; /** * Constructor to build a new ArrayDataSet with the given array. * The array parameter is an associative array of tables where the key is * the table name and the value an array of rows. Each row is an associative * array by itself with keys representing the field names and the values the * actual data. * For example: * array( * "addressbook" => array( * array("id" => 1, "name" => "...", "address" => "..."), * array("id" => 2, "name" => "...", "address" => "...") * ) * ) * * @param array $data */ public function __construct(array $data) { foreach ($data AS $tableName => $rows) { $columns = []; if (isset($rows[0])) { $columns = array_keys($rows[0]); } $metaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData($tableName, $columns); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($metaData); foreach ($rows AS $row) { $table->addRow($row); } $this->tables[$tableName] = $table; } } protected function createIterator($reverse = FALSE) { return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse); } public function getTable($tableName) { if (!isset($this->tables[$tableName])) { throw new InvalidArgumentException("$tableName is not a table in the current database."); } return $this->tables[$tableName]; } } ?>dbunit-2.0.2/src/Extensions/Database/DataSet/CompositeDataSet.php000066400000000000000000000050651261611365500247140ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates Composite Datasets * * Allows for creating datasets from multiple sources (csv, query, xml, etc.) * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_CompositeDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { protected $motherDataSet; /** * Creates a new Composite dataset * * You can pass in any data set that implements PHPUnit_Extensions_Database_DataSet_IDataSet * * @param string $delimiter * @param string $enclosure * @param string $escape */ public function __construct(Array $dataSets = []) { $this->motherDataset = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet(); foreach ($dataSets as $dataSet) { $this->addDataSet($dataSet); } } /** * Adds a new data set to the composite. * * The dataset may not define tables that already exist in the composite. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet */ public function addDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { foreach ($dataSet->getTableNames() as $tableName) { if (!in_array($tableName, $this->getTableNames())) { $this->motherDataset->addTable($dataSet->getTable($tableName)); } else { $other = $dataSet->getTable($tableName); $table = $this->getTable($tableName); if (!$table->getTableMetaData()->matches($other->getTableMetaData())) { throw new InvalidArgumentException("There is already a table named $tableName with different table definition"); } $table->addTableRows($dataSet->getTable($tableName)); } } } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected function createIterator($reverse = FALSE) { if ($reverse) { return $this->motherDataset->getReverseIterator(); } else { return $this->motherDataset->getIterator(); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/CsvDataSet.php000066400000000000000000000063751261611365500235120ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates CsvDataSets. * * You can incrementally add CSV files as tables to your datasets * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_CsvDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * @var array */ protected $tables = []; /** * @var string */ protected $delimiter = ','; /** * @var string */ protected $enclosure = '"'; /** * @var string */ protected $escape = '"'; /** * Creates a new CSV dataset * * You can pass in the parameters for how csv files will be read. * * @param string $delimiter * @param string $enclosure * @param string $escape */ public function __construct($delimiter = ',', $enclosure = '"', $escape = '"') { $this->delimiter = $delimiter; $this->enclosure = $enclosure; $this->escape = $escape; } /** * Adds a table to the dataset * * The table will be given the passed name. $csvFile should be a path to * a valid csv file (based on the arguments passed to the constructor.) * * @param string $tableName * @param string $csvFile */ public function addTable($tableName, $csvFile) { if (!is_file($csvFile)) { throw new InvalidArgumentException("Could not find csv file: {$csvFile}"); } if (!is_readable($csvFile)) { throw new InvalidArgumentException("Could not read csv file: {$csvFile}"); } $fh = fopen($csvFile, 'r'); $columns = $this->getCsvRow($fh); if ($columns === FALSE) { throw new InvalidArgumentException("Could not determine the headers from the given file {$csvFile}"); } $metaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData($tableName, $columns); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($metaData); while (($row = $this->getCsvRow($fh)) !== FALSE) { $table->addRow(array_combine($columns, $row)); } $this->tables[$tableName] = $table; } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected function createIterator($reverse = FALSE) { return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse); } /** * Returns a row from the csv file in an indexed array. * * @param resource $fh * @return array */ protected function getCsvRow($fh) { if (version_compare(PHP_VERSION, '5.3.0', '>')) { return fgetcsv($fh, NULL, $this->delimiter, $this->enclosure, $this->escape); } else { return fgetcsv($fh, NULL, $this->delimiter, $this->enclosure); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/DataSetFilter.php000066400000000000000000000115071261611365500241750ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A dataset decorator that allows filtering out tables and table columns from * results. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_DataSetFilter extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * The dataset being decorated. * @var PHPUnit_Extensions_Database_DataSet_IDataSet */ protected $originalDataSet; /** * The tables to exclude from the data set. * @var Array */ protected $excludeTables = []; /** * The tables to exclude from the data set. * @var Array */ protected $includeTables = []; /** * The columns to exclude from the data set. * @var Array */ protected $excludeColumns = []; /** * The columns to exclude from the data set. * @var Array */ protected $includeColumns = []; /** * Creates a new filtered data set. * * The $exclude tables should be an associative array using table names as * the key and an array of column names to exclude for the value. If you * would like to exclude a full table set the value of the table's entry * to the special string '*'. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $originalDataSet * @param Array $excludeTables @deprecated use set* methods instead. */ public function __construct(PHPUnit_Extensions_Database_DataSet_IDataSet $originalDataSet, array $excludeTables = []) { $this->originalDataSet = $originalDataSet; $tables = []; foreach ($excludeTables as $tableName => $values) { if (is_array($values)) { $this->setExcludeColumnsForTable($tableName, $values); } elseif ($values == '*') { $tables[] = $tableName; } else { $this->setExcludeColumnsForTable($tableName, (array) $values); } } $this->addExcludeTables($tables); } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected function createIterator($reverse = FALSE) { $original_tables = $this->originalDataSet->getIterator($reverse); $new_tables = []; foreach ($original_tables as $table) { /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ $tableName = $table->getTableMetaData()->getTableName(); if ((!in_array($tableName, $this->includeTables) && !empty($this->includeTables)) || in_array($tableName, $this->excludeTables) ) { continue; } elseif (!empty($this->excludeColumns[$tableName]) || !empty($this->includeColumns[$tableName])) { $new_table = new PHPUnit_Extensions_Database_DataSet_TableFilter($table); if (!empty($this->includeColumns[$tableName])) { $new_table->addIncludeColumns($this->includeColumns[$tableName]); } if (!empty($this->excludeColumns[$tableName])) { $new_table->addExcludeColumns($this->excludeColumns[$tableName]); } $new_tables[] = $new_table; } else { $new_tables[] = $table; } } return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($new_tables); } /** * Adds tables to be included in the data set. * @param array $tables */ public function addIncludeTables(Array $tables) { $this->includeTables = array_unique(array_merge($this->includeTables, $tables)); } /** * Adds tables to be included in the data set. * @param array $tables */ public function addExcludeTables(Array $tables) { $this->excludeTables = array_unique(array_merge($this->excludeTables, $tables)); } /** * Adds columns to include in the data set for the given table. * @param string $table * @param Array $columns */ public function setIncludeColumnsForTable($table, Array $columns) { $this->includeColumns[$table] = $columns; } /** * Adds columns to include in the data set for the given table. * @param string $table * @param Array $columns */ public function setExcludeColumnsForTable($table, Array $columns) { $this->excludeColumns[$table] = $columns; } } dbunit-2.0.2/src/Extensions/Database/DataSet/DefaultDataSet.php000066400000000000000000000026721261611365500243370ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default implementation of a data set. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_DefaultDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * An array of ITable objects. * * @var array */ protected $tables; /** * Creates a new dataset using the given tables. * * @param array $tables */ public function __construct(Array $tables = []) { $this->tables = $tables; } /** * Adds a table to the dataset. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ public function addTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { $this->tables[] = $table; } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected function createIterator($reverse = FALSE) { return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse); } } dbunit-2.0.2/src/Extensions/Database/DataSet/DefaultTable.php000066400000000000000000000041641261611365500240370ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides default table functionality. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_DefaultTable extends PHPUnit_Extensions_Database_DataSet_AbstractTable { /** * Creates a new table object using the given $tableMetaData * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData */ public function __construct(PHPUnit_Extensions_Database_DataSet_ITableMetaData $tableMetaData) { $this->setTableMetaData($tableMetaData); $this->data = []; } /** * Adds a row to the table with optional values. * * @param array $values */ public function addRow($values = []) { $this->data[] = array_replace( array_fill_keys($this->getTableMetaData()->getColumns(), NULL), $values ); } /** * Adds the rows in the passed table to the current table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ public function addTableRows(PHPUnit_Extensions_Database_DataSet_ITable $table) { $tableColumns = $this->getTableMetaData()->getColumns(); $rowCount = $table->getRowCount(); for ($i = 0; $i < $rowCount; $i++) { $newRow = []; foreach ($tableColumns as $columnName) { $newRow[$columnName] = $table->getValue($i, $columnName); } $this->addRow($newRow); } } /** * Sets the specified column of the specied row to the specified value. * * @param int $row * @param string $column * @param mixed $value */ public function setValue($row, $column, $value) { if (isset($this->data[$row])) { $this->data[$row][$column] = $value; } else { throw new InvalidArgumentException('The row given does not exist.'); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/DefaultTableIterator.php000066400000000000000000000046301261611365500255470ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default table iterator * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_DefaultTableIterator implements PHPUnit_Extensions_Database_DataSet_ITableIterator { /** * An array of tables in the iterator. * * @var Array */ protected $tables; /** * If this property is true then the tables will be iterated in reverse * order. * * @var bool */ protected $reverse; /** * Creates a new default table iterator object. * * @param array $tables * @param bool $reverse */ public function __construct(Array $tables, $reverse = FALSE) { $this->tables = $tables; $this->reverse = $reverse; $this->rewind(); } /** * Returns the current table. * * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function getTable() { return $this->current(); } /** * Returns the current table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData() { return $this->current()->getTableMetaData(); } /** * Returns the current table. * * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function current() { return current($this->tables); } /** * Returns the name of the current table. * * @return string */ public function key() { return $this->current()->getTableMetaData()->getTableName(); } /** * advances to the next element. */ public function next() { if ($this->reverse) { prev($this->tables); } else { next($this->tables); } } /** * Rewinds to the first element */ public function rewind() { if ($this->reverse) { end($this->tables); } else { reset($this->tables); } } /** * Returns true if the current index is valid * * @return bool */ public function valid() { return ($this->current() !== FALSE); } } dbunit-2.0.2/src/Extensions/Database/DataSet/DefaultTableMetaData.php000066400000000000000000000022231261611365500254320ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default implementation of table meta data * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData extends PHPUnit_Extensions_Database_DataSet_AbstractTableMetaData { /** * Creates a new default table meta data object. * * @param string $tableName * @param array $columns * @param array $primaryKeys */ public function __construct($tableName, Array $columns, Array $primaryKeys = []) { $this->tableName = $tableName; $this->columns = $columns; $this->primaryKeys = []; foreach ($primaryKeys as $columnName) { if (!in_array($columnName, $this->columns)) { throw new InvalidArgumentException('Primary key column passed that is not in the column list.'); } else { $this->primaryKeys[] = $columnName; } } } } dbunit-2.0.2/src/Extensions/Database/DataSet/FlatXmlDataSet.php000066400000000000000000000035001261611365500243110ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default implementation of a data set. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractXmlDataSet { protected function getTableInfo(Array &$tableColumns, Array &$tableValues) { if ($this->xmlFileContents->getName() != 'dataset') { throw new PHPUnit_Extensions_Database_Exception('The root element of a flat xml data set file must be called '); } foreach ($this->xmlFileContents->children() as $row) { $tableName = $row->getName(); if (!isset($tableColumns[$tableName])) { $tableColumns[$tableName] = []; $tableValues[$tableName] = []; } $values = []; foreach ($row->attributes() as $name => $value) { if (!in_array($name, $tableColumns[$tableName])) { $tableColumns[$tableName][] = $name; } $values[$name] = $value; } if (count($values)) { $tableValues[$tableName][] = $values; } } } public static function write(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset, $filename) { $pers = new PHPUnit_Extensions_Database_DataSet_Persistors_FlatXml(); $pers->setFileName($filename); try { $pers->write($dataset); } catch (RuntimeException $e) { throw new PHPUnit_Framework_Exception(__METHOD__ . ' called with an unwritable file.'); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/IDataSet.php000066400000000000000000000030331261611365500231330ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface for creating and reading data from data sets. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DataSet_IDataSet extends IteratorAggregate { /** * Returns an array of table names contained in the dataset. * * @return array */ public function getTableNames(); /** * Returns a table meta data object for the given table. * * @param string $tableName * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData($tableName); /** * Returns a table object for the given table. * * @param string $tableName * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function getTable($tableName); /** * Returns a reverse iterator for all table objects in the given dataset. * * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ public function getReverseIterator(); /** * Asserts that the given data set matches this data set. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $other */ public function matches(PHPUnit_Extensions_Database_DataSet_IDataSet $other); } dbunit-2.0.2/src/Extensions/Database/DataSet/IPersistable.php000066400000000000000000000012161261611365500240640ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * An interface for persisting datasets * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DataSet_IPersistable { /** * Writes the given dataset * * The previous dataset will be overwritten. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ public function write(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset); } dbunit-2.0.2/src/Extensions/Database/DataSet/ISpec.php000066400000000000000000000012471261611365500225050ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides an interface for creating data sets from data set spec strings. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DataSet_ISpec { /** * Creates a data set from a data set spec string. * * @param string $dataSetSpec * @return PHPUnit_Extensions_Database_DataSet_IDataSet */ public function getDataSet($dataSetSpec); } dbunit-2.0.2/src/Extensions/Database/DataSet/ITable.php000066400000000000000000000024301261611365500226350ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface for creating and reading data from data sets. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DataSet_ITable { /** * Returns the table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData(); /** * Returns the number of rows in this table. * * @return int */ public function getRowCount(); /** * Returns the value for the given column on the given row. * * @param int $row * @param int $column */ public function getValue($row, $column); /** * Returns the an associative array keyed by columns for the given row. * * @param int $row * @return array */ public function getRow($row); /** * Asserts that the given table matches this table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $other */ public function matches(PHPUnit_Extensions_Database_DataSet_ITable $other); } dbunit-2.0.2/src/Extensions/Database/DataSet/ITableIterator.php000066400000000000000000000014031261611365500243460ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface for creating and reading data from data sets. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DataSet_ITableIterator extends Iterator { /** * Returns the current table. * * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function getTable(); /** * Returns the current table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData(); } dbunit-2.0.2/src/Extensions/Database/DataSet/ITableMetaData.php000066400000000000000000000020611261611365500242360ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface for returning table meta data. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DataSet_ITableMetaData { /** * Returns the names of the columns in the table. * * @return array */ public function getColumns(); /** * Returns the names of the primary key columns in the table. * * @return array */ public function getPrimaryKeys(); /** * Returns the name of the table. * * @return string */ public function getTableName(); /** * Asserts that the given tableMetaData matches this tableMetaData. * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $other */ public function matches(PHPUnit_Extensions_Database_DataSet_ITableMetaData $other); } dbunit-2.0.2/src/Extensions/Database/DataSet/IYamlParser.php000066400000000000000000000010041261611365500236610ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * An interface for parsing YAML files. * * @since Class available since Release 1.3.1 */ interface PHPUnit_Extensions_Database_DataSet_IYamlParser { /** * @param string $yamlFile * @return array parsed YAML */ public function parseYaml($yamlFile); } dbunit-2.0.2/src/Extensions/Database/DataSet/MysqlXmlDataSet.php000066400000000000000000000100301261611365500245240ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Data set implementation for the output of mysqldump --xml. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_MysqlXmlDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractXmlDataSet { protected function getTableInfo(array &$tableColumns, array &$tableValues) { if ($this->xmlFileContents->getName() != 'mysqldump') { throw new PHPUnit_Extensions_Database_Exception('The root element of a MySQL XML data set file must be called '); } foreach ($this->xmlFileContents->xpath('./database/table_data') as $tableElement) { if (empty($tableElement['name'])) { throw new PHPUnit_Extensions_Database_Exception(' elements must include a name attribute'); } $tableName = (string) $tableElement['name']; if (!isset($tableColumns[$tableName])) { $tableColumns[$tableName] = []; } if (!isset($tableValues[$tableName])) { $tableValues[$tableName] = []; } foreach ($tableElement->xpath('./row') as $rowElement) { $rowValues = []; foreach ($rowElement->xpath('./field') as $columnElement) { if (empty($columnElement['name'])) { throw new PHPUnit_Extensions_Database_Exception(' element name attributes cannot be empty'); } $columnName = (string) $columnElement['name']; if (!in_array($columnName, $tableColumns[$tableName])) { $tableColumns[$tableName][] = $columnName; } } foreach ($tableColumns[$tableName] as $columnName) { $fields = $rowElement->xpath('./field[@name="' . $columnName . '"]'); $column = $fields[0]; $attr = $column->attributes('http://www.w3.org/2001/XMLSchema-instance'); if (isset($attr['type']) && (string) $attr['type'] === 'xs:hexBinary') { $columnValue = pack('H*',(string) $column); } else { $null = isset($column['nil']) || isset($attr[0]); $columnValue = $null ? NULL : (string) $column; } $rowValues[$columnName] = $columnValue; } $tableValues[$tableName][] = $rowValues; } } foreach ($this->xmlFileContents->xpath('./database/table_structure') as $tableElement) { if (empty($tableElement['name'])) { throw new PHPUnit_Extensions_Database_Exception(' elements must include a name attribute'); } $tableName = (string) $tableElement['name']; foreach ($tableElement->xpath('./field') as $fieldElement) { if (empty($fieldElement['Field'])) { throw new PHPUnit_Extensions_Database_Exception(' elements must include a Field attribute'); } $columnName = (string) $fieldElement['Field']; if (!in_array($columnName, $tableColumns[$tableName])) { $tableColumns[$tableName][] = $columnName; } } } } public static function write(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset, $filename) { $pers = new PHPUnit_Extensions_Database_DataSet_Persistors_MysqlXml; $pers->setFileName($filename); try { $pers->write($dataset); } catch (RuntimeException $e) { throw new PHPUnit_Framework_Exception(__METHOD__ . ' called with an unwritable file.'); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/Persistors/000077500000000000000000000000001261611365500231425ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/DataSet/Persistors/Abstract.php000066400000000000000000000050221261611365500254150ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * An abstract implementation of a dataset persistor. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_DataSet_Persistors_Abstract implements PHPUnit_Extensions_Database_DataSet_IPersistable { public function write(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { $this->saveDataSet($dataset); } /** * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ protected function saveDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { $this->startDataSet($dataset); foreach ($dataset as $table) { $this->saveTable($table); } $this->endDataSet($dataset); } /** * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function saveTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { $rowCount = $table->getRowCount(); $this->startTable($table); for ($i = 0; $i < $rowCount; $i++) { $this->row($table->getRow($i), $table); } $this->endTable($table); } /** * Override to save the start of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ abstract protected function startDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset); /** * Override to save the end of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ abstract protected function endDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset); /** * Override to save the start of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ abstract protected function startTable(PHPUnit_Extensions_Database_DataSet_ITable $table); /** * Override to save the end of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ abstract protected function endTable(PHPUnit_Extensions_Database_DataSet_ITable $table); /** * Override to save a table row. * * @param array $row * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ abstract protected function row(Array $row, PHPUnit_Extensions_Database_DataSet_ITable $table); } dbunit-2.0.2/src/Extensions/Database/DataSet/Persistors/Factory.php000066400000000000000000000034061261611365500252650ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates the appropriate Persistor based on a given type and spec. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Persistors_Factory { /** * Returns the persistor. * * @param string $type * @param string $spec * @return PHPUnit_Extensions_Database_DataSet_IPersistable */ public function getPersistorBySpec($type, $spec) { switch (strtolower($type)) { case 'xml': $xmlPersistor = new PHPUnit_Extensions_Database_DataSet_Persistors_Xml(); $xmlPersistor->setFileName($spec); return $xmlPersistor; case 'flatxml': $flatXmlPersistor = new PHPUnit_Extensions_Database_DataSet_Persistors_FlatXml(); $flatXmlPersistor->setFileName($spec); return $flatXmlPersistor; case 'yaml': $yamlPersistor = new PHPUnit_Extensions_Database_DataSet_Persistors_Yaml(); $yamlPersistor->setFileName($spec); return $yamlPersistor; case 'mysqlxml': $mysqlXmlPersistor = new PHPUnit_Extensions_Database_DataSet_Persistors_MysqlXml(); $mysqlXmlPersistor->setFileName($spec); return $mysqlXmlPersistor; default: throw new PHPUnit_Extensions_Database_Exception("I don't know what you want from me. PERSISTOR"); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/Persistors/FlatXml.php000066400000000000000000000056121261611365500252260ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A Flat XML dataset persistor. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Persistors_FlatXml extends PHPUnit_Extensions_Database_DataSet_Persistors_Abstract { /** * @var string */ protected $filename; /** * @var resource */ protected $fh; /** * Sets the filename that this persistor will save to. * * @param string $filename */ public function setFileName($filename) { $this->filename = $filename; } /** * Override to save the start of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ protected function startDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { $this->fh = fopen($this->filename, 'w'); if ($this->fh === FALSE) { throw new PHPUnit_Framework_Exception( "Could not open {$this->filename} for writing see " . __CLASS__ . '::setFileName()' ); } fwrite($this->fh, "\n"); fwrite($this->fh, "\n"); } /** * Override to save the end of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ protected function endDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { fwrite($this->fh, "\n"); } /** * Override to save the start of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function startTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { if ($table->getRowCount() == 0) { fwrite($this->fh, "\t<{$table->getTableMetaData()->getTableName()} />\n"); } } /** * Override to save the end of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function endTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { //do nothing } /** * Override to save a table row. * * @param array $row * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function row(Array $row, PHPUnit_Extensions_Database_DataSet_ITable $table) { fwrite($this->fh, "\t<{$table->getTableMetaData()->getTableName()}\n"); foreach ($table->getTableMetaData()->getColumns() as $columnName) { if (isset($row[$columnName])) { fwrite($this->fh, "\t\t{$columnName}=\"" . htmlspecialchars($row[$columnName]) . "\"\n"); } } fwrite($this->fh, "\t/>\n"); } } dbunit-2.0.2/src/Extensions/Database/DataSet/Persistors/MysqlXml.php000066400000000000000000000067351261611365500254540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A MySQL XML dataset persistor. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Persistors_MysqlXml extends PHPUnit_Extensions_Database_DataSet_Persistors_Abstract { /** * @var string */ protected $filename; /** * @var string */ protected $database; /** * @var resource */ protected $fh; /** * Sets the filename that this persistor will save to. * * @param string $filename */ public function setFileName($filename) { $this->filename = $filename; } /** * Sets the name of the database. * * @param string $database */ public function setDatabase($database) { $this->database = $database; } /** * Override to save the start of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ protected function startDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { $this->fh = fopen($this->filename, 'w'); if ($this->fh === FALSE) { throw new PHPUnit_Framework_Exception( "Could not open {$this->filename} for writing see " . __CLASS__ . '::setFileName()' ); } fwrite($this->fh, '' . "\n"); fwrite($this->fh, '' . "\n"); fwrite($this->fh, '' . "\n"); } /** * Override to save the end of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ protected function endDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { fwrite($this->fh, '' . "\n"); fwrite($this->fh, '' . "\n"); } /** * Override to save the start of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function startTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { fwrite($this->fh, "\t" . '' . "\n"); } /** * Override to save the end of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function endTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { fwrite($this->fh, "\t" . '' . "\n"); } /** * Override to save a table row. * * @param array $row * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function row(Array $row, PHPUnit_Extensions_Database_DataSet_ITable $table) { fwrite($this->fh, "\t" . '' . "\n"); foreach ($table->getTableMetaData()->getColumns() as $columnName) { fwrite($this->fh, "\t\t" . 'fh, '>' . htmlspecialchars($row[$columnName]) . '' . "\n"); } else { fwrite($this->fh, ' xsi:nil="true" />' . "\n"); } } fwrite($this->fh, "\t" . '' . "\n"); } } dbunit-2.0.2/src/Extensions/Database/DataSet/Persistors/Xml.php000066400000000000000000000060651261611365500244220ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A XML dataset persistor. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Persistors_Xml extends PHPUnit_Extensions_Database_DataSet_Persistors_Abstract { /** * @var string */ protected $filename; /** * @var resource */ protected $fh; /** * Sets the filename that this persistor will save to. * * @param string $filename */ public function setFileName($filename) { $this->filename = $filename; } /** * Override to save the start of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ protected function startDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { $this->fh = fopen($this->filename, 'w'); if ($this->fh === FALSE) { throw new PHPUnit_Framework_Exception( "Could not open {$this->filename} for writing see " . __CLASS__ . '::setFileName()' ); } fwrite($this->fh, "\n"); fwrite($this->fh, "\n"); } /** * Override to save the end of a dataset. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ protected function endDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { fwrite($this->fh, "\n"); } /** * Override to save the start of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function startTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { fwrite($this->fh, "\tgetTableMetaData()->getTableName()}\">\n"); foreach ($table->getTableMetaData()->getColumns() as $columnName) { fwrite($this->fh, "\t\t{$columnName}\n"); } } /** * Override to save the end of a table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function endTable(PHPUnit_Extensions_Database_DataSet_ITable $table) { fwrite($this->fh, "\t
\n"); } /** * Override to save a table row. * * @param array $row * @param PHPUnit_Extensions_Database_DataSet_ITable $table */ protected function row(Array $row, PHPUnit_Extensions_Database_DataSet_ITable $table) { fwrite($this->fh, "\t\t\n"); foreach ($table->getTableMetaData()->getColumns() as $columnName) { if (isset($row[$columnName])) { fwrite($this->fh, "\t\t\t" . htmlspecialchars($row[$columnName]) . "\n"); } else { fwrite($this->fh, "\t\t\t\n"); } } fwrite($this->fh, "\t\t\n"); } } dbunit-2.0.2/src/Extensions/Database/DataSet/Persistors/Yaml.php000066400000000000000000000033301261611365500245540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A yaml dataset persistor * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Persistors_Yaml implements PHPUnit_Extensions_Database_DataSet_IPersistable { /** * @var string */ protected $filename; /** * Sets the filename that this persistor will save to. * * @param string $filename */ public function setFileName($filename) { $this->filename = $filename; } /** * Writes the dataset to a yaml file * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset */ public function write(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset) { $phpArr = []; $emptyTables = []; foreach ($dataset as $table) { $tableName = $table->getTableMetaData()->getTableName(); $rowCount = $table->getRowCount(); if (!$rowCount) { $emptyTables[] = $tableName; continue; } $phpArr[$tableName] = []; for ($i = 0; $i < $rowCount; $i++) { $phpArr[$tableName][] = $table->getRow($i); } } $emptyTablesAsString = ''; if (count($emptyTables)) { $emptyTablesAsString = implode(":\n", $emptyTables) . ":\n\n"; } file_put_contents( $this->filename, Symfony\Component\Yaml\Yaml::dump($phpArr, 3) . $emptyTablesAsString ); } } dbunit-2.0.2/src/Extensions/Database/DataSet/QueryDataSet.php000066400000000000000000000046531261611365500240610ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides access to a database instance as a data set. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_QueryDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * An array of ITable objects. * * @var array */ protected $tables = []; /** * The database connection this dataset is using. * * @var PHPUnit_Extensions_Database_DB_IDatabaseConnection */ protected $databaseConnection; /** * Creates a new dataset using the given database connection. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection */ public function __construct(PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection) { $this->databaseConnection = $databaseConnection; } public function addTable($tableName, $query = NULL) { if ($query === NULL) { $query = 'SELECT * FROM ' . $tableName; } $this->tables[$tableName] = new PHPUnit_Extensions_Database_DataSet_QueryTable($tableName, $query, $this->databaseConnection); } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DB_TableIterator */ protected function createIterator($reverse = FALSE) { return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator($this->tables, $reverse); } /** * Returns a table object for the given table. * * @param string $tableName * @return PHPUnit_Extensions_Database_DB_Table */ public function getTable($tableName) { if (!isset($this->tables[$tableName])) { throw new InvalidArgumentException("$tableName is not a table in the current database."); } return $this->tables[$tableName]; } /** * Returns a list of table names for the database * * @return Array */ public function getTableNames() { return array_keys($this->tables); } } dbunit-2.0.2/src/Extensions/Database/DataSet/QueryTable.php000066400000000000000000000101261261611365500235530ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides the functionality to represent a database table. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_QueryTable extends PHPUnit_Extensions_Database_DataSet_AbstractTable { /** * @var string */ protected $query; /** * @var PHPUnit_Extensions_Database_DB_IDatabaseConnection */ protected $databaseConnection; /** * @var string */ protected $tableName; /** * Creates a new database query table object. * * @param string $table_name * @param string $query * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection */ public function __construct($tableName, $query, PHPUnit_Extensions_Database_DB_IDatabaseConnection $databaseConnection) { $this->query = $query; $this->databaseConnection = $databaseConnection; $this->tableName = $tableName; } /** * Returns the table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData() { $this->createTableMetaData(); return parent::getTableMetaData(); } /** * Checks if a given row is in the table * * @param array $row * * @return bool */ public function assertContainsRow(Array $row) { $this->loadData(); return parent::assertContainsRow($row); } /** * Returns the number of rows in this table. * * @return int */ public function getRowCount() { $this->loadData(); return parent::getRowCount(); } /** * Returns the value for the given column on the given row. * * @param int $row * @param int $column */ public function getValue($row, $column) { $this->loadData(); return parent::getValue($row, $column); } /** * Returns the an associative array keyed by columns for the given row. * * @param int $row * @return array */ public function getRow($row) { $this->loadData(); return parent::getRow($row); } /** * Asserts that the given table matches this table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $other */ public function matches(PHPUnit_Extensions_Database_DataSet_ITable $other) { $this->loadData(); return parent::matches($other); } protected function loadData() { if ($this->data === NULL) { $pdoStatement = $this->databaseConnection->getConnection()->query($this->query); $this->data = $pdoStatement->fetchAll(PDO::FETCH_ASSOC); } } protected function createTableMetaData() { if ($this->tableMetaData === NULL) { $this->loadData(); // if some rows are in the table $columns = []; if (isset($this->data[0])) // get column names from data $columns = array_keys($this->data[0]); else { // if no rows found, get column names from database $pdoStatement = $this->databaseConnection->getConnection()->prepare('SELECT column_name FROM information_schema.COLUMNS WHERE table_schema=:schema AND table_name=:table'); $pdoStatement->execute([ 'table' => $this->tableName, 'schema' => $this->databaseConnection->getSchema() ]); $columns = $pdoStatement->fetchAll(PDO::FETCH_COLUMN, 0); } // create metadata $this->tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData($this->tableName, $columns); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/ReplacementDataSet.php000066400000000000000000000052001261611365500252000ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Allows for replacing arbitrary values or portions of values with new data. * * A usage for this is replacing all values == '[NULL'] with a true NULL value * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_ReplacementDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * @var PHPUnit_Extensions_Database_DataSet_IDataSet */ protected $dataSet; /** * @var array */ protected $fullReplacements; /** * @var array */ protected $subStrReplacements; /** * Creates a new replacement dataset * * You can pass in any data set that implements PHPUnit_Extensions_Database_DataSet_IDataSet * * @param string $delimiter * @param string $enclosure * @param string $escape */ public function __construct(PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet, Array $fullReplacements = [], Array $subStrReplacements = []) { $this->dataSet = $dataSet; $this->fullReplacements = $fullReplacements; $this->subStrReplacements = $subStrReplacements; } /** * Adds a new full replacement * * Full replacements will only replace values if the FULL value is a match * * @param string $value * @param string $replacement */ public function addFullReplacement($value, $replacement) { $this->fullReplacements[$value] = $replacement; } /** * Adds a new substr replacement * * Substr replacements will replace all occurances of the substr in every column * * @param string $value * @param string $replacement */ public function addSubStrReplacement($value, $replacement) { $this->subStrReplacements[$value] = $replacement; } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected function createIterator($reverse = FALSE) { $innerIterator = $reverse ? $this->dataSet->getReverseIterator() : $this->dataSet->getIterator(); return new PHPUnit_Extensions_Database_DataSet_ReplacementTableIterator($innerIterator, $this->fullReplacements, $this->subStrReplacements); } } dbunit-2.0.2/src/Extensions/Database/DataSet/ReplacementTable.php000066400000000000000000000135501261611365500247110ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Allows for replacing arbitrary strings in your data sets with other values. * * @since Class available since Release 1.0.0 * @todo When setTableMetaData() is taken out of the AbstractTable this class should extend AbstractTable. */ class PHPUnit_Extensions_Database_DataSet_ReplacementTable implements PHPUnit_Extensions_Database_DataSet_ITable { /** * @var PHPUnit_Extensions_Database_DataSet_ITable */ protected $table; /** * @var array */ protected $fullReplacements; /** * @var array */ protected $subStrReplacements; /** * Creates a new replacement table * * @param PHPUnit_Extensions_Database_DataSet_ITable $table * @param array $fullReplacements * @param array $subStrReplacements */ public function __construct(PHPUnit_Extensions_Database_DataSet_ITable $table, Array $fullReplacements = [], Array $subStrReplacements = []) { $this->table = $table; $this->fullReplacements = $fullReplacements; $this->subStrReplacements = $subStrReplacements; } /** * Adds a new full replacement * * Full replacements will only replace values if the FULL value is a match * * @param string $value * @param string $replacement */ public function addFullReplacement($value, $replacement) { $this->fullReplacements[$value] = $replacement; } /** * Adds a new substr replacement * * Substr replacements will replace all occurances of the substr in every column * * @param string $value * @param string $replacement */ public function addSubStrReplacement($value, $replacement) { $this->subStrReplacements[$value] = $replacement; } /** * Returns the table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData() { return $this->table->getTableMetaData(); } /** * Returns the number of rows in this table. * * @return int */ public function getRowCount() { return $this->table->getRowCount(); } /** * Returns the value for the given column on the given row. * * @param int $row * @param int $column */ public function getValue($row, $column) { return $this->getReplacedValue($this->table->getValue($row, $column)); } /** * Returns the an associative array keyed by columns for the given row. * * @param int $row * @return array */ public function getRow($row) { $row = $this->table->getRow($row); return array_map([$this, 'getReplacedValue'], $row); } /** * Asserts that the given table matches this table. * * @param PHPUnit_Extensions_Database_DataSet_ITable $other */ public function matches(PHPUnit_Extensions_Database_DataSet_ITable $other) { $thisMetaData = $this->getTableMetaData(); $otherMetaData = $other->getTableMetaData(); if (!$thisMetaData->matches($otherMetaData) || $this->getRowCount() != $other->getRowCount()) { return FALSE; } $columns = $thisMetaData->getColumns(); $rowCount = $this->getRowCount(); for ($i = 0; $i < $rowCount; $i++) { foreach ($columns as $columnName) { $thisValue = $this->getValue($i, $columnName); $otherValue = $other->getValue($i, $columnName); if (is_numeric($thisValue) && is_numeric($otherValue)) { if ($thisValue != $otherValue) { return FALSE; } } elseif ($thisValue !== $otherValue) { return FALSE; } } } return TRUE; } public function __toString() { $columns = $this->getTableMetaData()->getColumns(); $lineSeperator = str_repeat('+----------------------', count($columns)) . "+\n"; $lineLength = strlen($lineSeperator) - 1; $tableString = $lineSeperator; $tableString .= '| ' . str_pad($this->getTableMetaData()->getTableName(), $lineLength - 4, ' ', STR_PAD_RIGHT) . " |\n"; $tableString .= $lineSeperator; $tableString .= $this->rowToString($columns); $tableString .= $lineSeperator; $rowCount = $this->getRowCount(); for ($i = 0; $i < $rowCount; $i++) { $values = []; foreach ($columns as $columnName) { $values[] = $this->getValue($i, $columnName); } $tableString .= $this->rowToString($values); $tableString .= $lineSeperator; } return "\n" . $tableString . "\n"; } protected function rowToString(Array $row) { $rowString = ''; foreach ($row as $value) { if (is_null($value)) { $value = 'NULL'; } $rowString .= '| ' . str_pad(substr($value, 0, 20), 20, ' ', STR_PAD_BOTH) . ' '; } return $rowString . "|\n"; } protected function getReplacedValue($value) { if (is_scalar($value) && array_key_exists((string) $value, $this->fullReplacements)) { return $this->fullReplacements[$value]; } else if (count($this->subStrReplacements) && isset($value)) { return str_replace(array_keys($this->subStrReplacements), array_values($this->subStrReplacements), $value); } else { return $value; } } } dbunit-2.0.2/src/Extensions/Database/DataSet/ReplacementTableIterator.php000066400000000000000000000067221261611365500264260ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default table iterator * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_ReplacementTableIterator implements OuterIterator, PHPUnit_Extensions_Database_DataSet_ITableIterator { /** * @var PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected $innerIterator; /** * @var array */ protected $fullReplacements; /** * @var array */ protected $subStrReplacements; /** * Creates a new replacement table iterator object. * * @param PHPUnit_Extensions_Database_DataSet_ITableIterator $innerIterator * @param array $fullReplacements * @param array $subStrReplacements */ public function __construct(PHPUnit_Extensions_Database_DataSet_ITableIterator $innerIterator, Array $fullReplacements = [], Array $subStrReplacements = []) { $this->innerIterator = $innerIterator; $this->fullReplacements = $fullReplacements; $this->subStrReplacements = $subStrReplacements; } /** * Adds a new full replacement * * Full replacements will only replace values if the FULL value is a match * * @param string $value * @param string $replacement */ public function addFullReplacement($value, $replacement) { $this->fullReplacements[$value] = $replacement; } /** * Adds a new substr replacement * * Substr replacements will replace all occurances of the substr in every column * * @param string $value * @param string $replacement */ public function addSubStrReplacement($value, $replacement) { $this->subStrReplacements[$value] = $replacement; } /** * Returns the current table. * * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function getTable() { return $this->current(); } /** * Returns the current table's meta data. * * @return PHPUnit_Extensions_Database_DataSet_ITableMetaData */ public function getTableMetaData() { $this->current()->getTableMetaData(); } /** * Returns the current table. * * @return PHPUnit_Extensions_Database_DataSet_ITable */ public function current() { return new PHPUnit_Extensions_Database_DataSet_ReplacementTable($this->innerIterator->current(), $this->fullReplacements, $this->subStrReplacements); } /** * Returns the name of the current table. * * @return string */ public function key() { return $this->current()->getTableMetaData()->getTableName(); } /** * advances to the next element. */ public function next() { $this->innerIterator->next(); } /** * Rewinds to the first element */ public function rewind() { $this->innerIterator->rewind(); } /** * Returns true if the current index is valid * * @return bool */ public function valid() { return $this->innerIterator->valid(); } public function getInnerIterator() { return $this->innerIterator; } } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/000077500000000000000000000000001261611365500220425ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/Csv.php000066400000000000000000000052001261611365500233030ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates CsvDataSets based off of a spec string. * * The format of the spec string is as follows: * * |table1:filename.csv,table2:filename2.csv * * The first portion of the spec including the pipe symbol '|' is optional. * If the pipe option is included than it may be preceded by up to four * characters specifying values for the following arguments in order: * delimiter (defaults to ',',) enclosure (defaults to '"',) escape (defaults to '"',). * * Any additional characters in the csv options will be discarded. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Specs_Csv implements PHPUnit_Extensions_Database_DataSet_ISpec { /** * Creates CSV Data Set from a data set spec. * * @param string $dataSetSpec * @return PHPUnit_Extensions_Database_DataSet_CsvDataSet */ public function getDataSet($dataSetSpec) { $csvDataSetArgs = $this->getCsvOptions($dataSetSpec); $csvDataSetRfl = new ReflectionClass('PHPUnit_Extensions_Database_DataSet_CsvDataSet'); $csvDataSet = $csvDataSetRfl->newInstanceArgs($csvDataSetArgs); foreach ($this->getTableFileMap($dataSetSpec) as $tableName => $file) { $csvDataSet->addTable($tableName, $file); } return $csvDataSet; } /** * Returns CSV options. * * Returns an array containing the options that will be passed to the * PHPUnit_Extensions_Database_DataSet_CsvDataSet constructor. The options * are determined by the given $dataSetSpec. * * @param string $dataSetSpec * @return array */ protected function getCsvOptions($dataSetSpec) { list($csvOptStr) = explode('|', $dataSetSpec, 2); return str_split($csvOptStr); } /** * Returns map of tables to files. * * Returns an associative array containing a mapping of tables (the key) * to files (the values.) The tables and files are determined by the given * $dataSetSpec * * @param string $dataSetSpec * @return array */ protected function getTableFileMap($dataSetSpec) { $tables = []; foreach (explode(',', $dataSetSpec) as $csvfile) { list($tableName, $file) = explode(':', $csvfile, 2); $tables[$tableName] = $file; } return $tables; } } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/DbQuery.php000066400000000000000000000043741261611365500241360ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates DefaultDataSets based off of a spec string. * * This spec class requires a list of databases to be set to the object before * it can return a list of databases. * * The format of the spec string is as follows: * * ::: * * The db label should be equal to one of the keys in the array of databases * passed to setDatabases(). * * The schema should be the primary schema you will be running the sql query * against. * * The table name should be set to what you would like the table name in the * dataset to be. * * The sql is the query you want to use to generate the table columns and data. * The column names in the table will be identical to the column aliases in the * query. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Specs_DbQuery implements PHPUnit_Extensions_Database_DataSet_ISpec, PHPUnit_Extensions_Database_IDatabaseListConsumer { /** * @var array */ protected $databases = []; /** * Sets the database for the spec * * @param array $databases */ public function setDatabases(array $databases) { $this->databases = $databases; } /** * Creates a Default Data Set with a query table from a data set spec. * * @param string $dataSetSpec * @return PHPUnit_Extensions_Database_DataSet_DefaultDataSet */ public function getDataSet($dataSetSpec) { list($dbLabel, $schema, $table, $sql) = explode(':', $dataSetSpec, 4); $databaseInfo = $this->databases[$dbLabel]; $pdoRflc = new ReflectionClass('PDO'); $pdo = $pdoRflc->newInstanceArgs(explode('|', $databaseInfo)); $dbConnection = new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection($pdo, $schema); $table = $dbConnection->createQueryTable($table, $sql); return new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table]); } } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/DbTable.php000066400000000000000000000042351261611365500240540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates a database dataset based off of a spec string. * * This spec class requires a list of databases to be set to the object before * it can return a list of databases. * * The format of the spec string is as follows: * * :: * * The db label should be equal to one of the keys in the array of databases * passed to setDatabases(). * * The schema should be the primary schema you will be choosing tables from. * * The tables should be a comma delimited list of all tables you would like to * pull data from. * * The sql is the query you want to use to generate the table columns and data. * The column names in the table will be identical to the column aliases in the * query. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Specs_DbTable implements PHPUnit_Extensions_Database_DataSet_ISpec, PHPUnit_Extensions_Database_IDatabaseListConsumer { /** * @var array */ protected $databases = []; /** * Sets the database for the spec * * @param array $databases */ public function setDatabases(array $databases) { $this->databases = $databases; } /** * Creates a DB Data Set from a data set spec. * * @param string $dataSetSpec * @return PHPUnit_Extensions_Database_DataSet_IDataSet */ public function getDataSet($dataSetSpec) { list($dbLabel, $schema, $tables) = explode(':', $dataSetSpec, 3); $databaseInfo = $this->databases[$dbLabel]; $pdoRflc = new ReflectionClass('PDO'); $pdo = $pdoRflc->newInstanceArgs(explode('|', $databaseInfo)); $dbConnection = new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection($pdo, $schema); return !empty($tables) ? $dbConnection->createDataSet(explode(',', $tables)) : $dbConnection->createDataSet(); } } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/Factory.php000066400000000000000000000027321261611365500241660ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates the appropriate DataSet Spec based on a given type. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Specs_Factory implements PHPUnit_Extensions_Database_DataSet_Specs_IFactory { /** * Returns the data set * * @param string $type * @return PHPUnit_Extensions_Database_DataSet_ISpec */ public function getDataSetSpecByType($type) { switch ($type) { case 'xml': return new PHPUnit_Extensions_Database_DataSet_Specs_Xml(); case 'flatxml': return new PHPUnit_Extensions_Database_DataSet_Specs_FlatXml(); case 'csv': return new PHPUnit_Extensions_Database_DataSet_Specs_Csv(); case 'yaml': return new PHPUnit_Extensions_Database_DataSet_Specs_Yaml(); case 'dbtable': return new PHPUnit_Extensions_Database_DataSet_Specs_DbTable(); case 'dbquery': return new PHPUnit_Extensions_Database_DataSet_Specs_DbQuery(); default: throw new PHPUnit_Extensions_Database_Exception("I don't know what you want from me."); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/FlatXml.php000066400000000000000000000017501261611365500241250ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates a FlatXML dataset based off of a spec string. * * The format of the spec string is as follows: * * * * The filename should be the location of a flat xml file relative to the * current working directory. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Specs_FlatXml implements PHPUnit_Extensions_Database_DataSet_ISpec { /** * Creates Flat XML Data Set from a data set spec. * * @param string $dataSetSpec * @return PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet */ public function getDataSet($dataSetSpec) { return new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet($dataSetSpec); } } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/IFactory.php000066400000000000000000000011541261611365500242740ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * An interface for data set spec factories. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_DataSet_Specs_IFactory { /** * Returns the data set * * @param string $type * @return PHPUnit_Extensions_Database_DataSet_ISpec */ public function getDataSetSpecByType($type); } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/Xml.php000066400000000000000000000017121261611365500233140ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates a XML dataset based off of a spec string. * * The format of the spec string is as follows: * * * * The filename should be the location of a xml file relative to the * current working directory. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Specs_Xml implements PHPUnit_Extensions_Database_DataSet_ISpec { /** * Creates XML Data Set from a data set spec. * * @param string $dataSetSpec * @return PHPUnit_Extensions_Database_DataSet_XmlDataSet */ public function getDataSet($dataSetSpec) { return new PHPUnit_Extensions_Database_DataSet_XmlDataSet($dataSetSpec); } } dbunit-2.0.2/src/Extensions/Database/DataSet/Specs/Yaml.php000066400000000000000000000017211261611365500234560ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates a YAML dataset based off of a spec string. * * The format of the spec string is as follows: * * * * The filename should be the location of a yaml file relative to the * current working directory. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_Specs_Yaml implements PHPUnit_Extensions_Database_DataSet_ISpec { /** * Creates YAML Data Set from a data set spec. * * @param string $dataSetSpec * @return PHPUnit_Extensions_Database_DataSet_YamlDataSet */ public function getDataSet($dataSetSpec) { return new PHPUnit_Extensions_Database_DataSet_YamlDataSet($dataSetSpec); } } dbunit-2.0.2/src/Extensions/Database/DataSet/SymfonyYamlParser.php000066400000000000000000000011171261611365500251420ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default YAML parser, using Symfony/Yaml. * * @since Class available since Release 1.3.1 */ class PHPUnit_Extensions_Database_DataSet_SymfonyYamlParser implements PHPUnit_Extensions_Database_DataSet_IYamlParser { public function parseYaml($yamlFile) { return Symfony\Component\Yaml\Yaml::parse(file_get_contents($yamlFile)); } } dbunit-2.0.2/src/Extensions/Database/DataSet/TableFilter.php000066400000000000000000000067271261611365500237070ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A table decorator that allows filtering out table columns from results. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_TableFilter extends PHPUnit_Extensions_Database_DataSet_AbstractTable { /** * The table meta data being decorated. * @var PHPUnit_Extensions_Database_DataSet_ITable */ protected $originalTable; /** * Creates a new table filter using the original table * * @param $originalTable PHPUnit_Extensions_Database_DataSet_ITable * @param $excludeColumns Array @deprecated, use the set* methods instead. */ public function __construct(PHPUnit_Extensions_Database_DataSet_ITable $originalTable, Array $excludeColumns = []) { $this->originalTable = $originalTable; $this->setTableMetaData(new PHPUnit_Extensions_Database_DataSet_TableMetaDataFilter($originalTable->getTableMetaData())); $this->addExcludeColumns($excludeColumns); } /** * Returns the number of rows in this table. * * @return int */ public function getRowCount() { return $this->originalTable->getRowCount(); } /** * Returns the value for the given column on the given row. * * @param int $row * @param int $column */ public function getValue($row, $column) { if (in_array($column, $this->getTableMetaData()->getColumns())) { return $this->originalTable->getValue($row, $column); } else { throw new InvalidArgumentException("The given row ({$row}) and column ({$column}) do not exist in table {$this->getTableMetaData()->getTableName()}"); } } /** * Sets the columns to include in the table. * @param Array $includeColumns */ public function addIncludeColumns(Array $includeColumns) { $this->tableMetaData->addIncludeColumns($includeColumns); } /** * Clears the included columns. */ public function clearIncludeColumns() { $this->tableMetaData->clearIncludeColumns(); } /** * Sets the columns to exclude from the table. * @param Array $excludeColumns */ public function addExcludeColumns(Array $excludeColumns) { $this->tableMetaData->addExcludeColumns($excludeColumns); } /** * Clears the included columns. */ public function clearExcludeColumns() { $this->tableMetaData->clearExcludeColumns(); } /** * Checks if a given row is in the table * * @param array $row * * @return bool */ public function assertContainsRow(Array $row) { $this->loadData(); return parent::assertContainsRow($row); } /** * Loads data into local data table if it's not already loaded */ protected function loadData() { if ($this->data === NULL) { $data = []; for($row = 0;$row < $this->originalTable->getRowCount();$row++) { $tRow = []; foreach($this->getTableMetaData()->getColumns() as $col) { $tRow[$col] = $this->getValue($row, $col); } $data[$row] = $tRow; } $this->data = $data; } } } dbunit-2.0.2/src/Extensions/Database/DataSet/TableMetaDataFilter.php000066400000000000000000000064711261611365500253040ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A TableMetaData decorator that allows filtering columns from another * metaData object. * * The if a whitelist (include) filter is specified, then only those columns * will be included. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_TableMetaDataFilter extends PHPUnit_Extensions_Database_DataSet_AbstractTableMetaData { /** * The table meta data being decorated. * @var PHPUnit_Extensions_Database_DataSet_ITableMetaData */ protected $originalMetaData; /** * The columns to exclude from the meta data. * @var Array */ protected $excludeColumns = []; /** * The columns to include from the meta data. * @var Array */ protected $includeColumns = []; /** * Creates a new filtered table meta data object filtering out * $excludeColumns. * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $originalMetaData * @param array $excludeColumns - Deprecated. Use the set* methods instead. */ public function __construct(PHPUnit_Extensions_Database_DataSet_ITableMetaData $originalMetaData, Array $excludeColumns = []) { $this->originalMetaData = $originalMetaData; $this->addExcludeColumns($excludeColumns); } /** * Returns the names of the columns in the table. * * @return array */ public function getColumns() { if (!empty($this->includeColumns)) { return array_values(array_intersect($this->originalMetaData->getColumns(), $this->includeColumns)); } elseif (!empty($this->excludeColumns)) { return array_values(array_diff($this->originalMetaData->getColumns(), $this->excludeColumns)); } else { return $this->originalMetaData->getColumns(); } } /** * Returns the names of the primary key columns in the table. * * @return array */ public function getPrimaryKeys() { return $this->originalMetaData->getPrimaryKeys(); } /** * Returns the name of the table. * * @return string */ public function getTableName() { return $this->originalMetaData->getTableName(); } /** * Sets the columns to include in the table. * @param Array $includeColumns */ public function addIncludeColumns(Array $includeColumns) { $this->includeColumns = array_unique(array_merge($this->includeColumns, $includeColumns)); } /** * Clears the included columns. */ public function clearIncludeColumns() { $this->includeColumns = []; } /** * Sets the columns to exclude from the table. * @param Array $excludeColumns */ public function addExcludeColumns(Array $excludeColumns) { $this->excludeColumns = array_unique(array_merge($this->excludeColumns, $excludeColumns)); } /** * Clears the excluded columns. */ public function clearExcludeColumns() { $this->excludeColumns = []; } } dbunit-2.0.2/src/Extensions/Database/DataSet/XmlDataSet.php000066400000000000000000000071641261611365500235140ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default implementation of a data set. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_XmlDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractXmlDataSet { protected function getTableInfo(Array &$tableColumns, Array &$tableValues) { if ($this->xmlFileContents->getName() != 'dataset') { throw new PHPUnit_Extensions_Database_Exception('The root element of an xml data set file must be called '); } foreach ($this->xmlFileContents->xpath('/dataset/table') as $tableElement) { if (empty($tableElement['name'])) { throw new PHPUnit_Extensions_Database_Exception('Table elements must include a name attribute specifying the table name.'); } $tableName = (string) $tableElement['name']; if (!isset($tableColumns[$tableName])) { $tableColumns[$tableName] = []; } if (!isset($tableValues[$tableName])) { $tableValues[$tableName] = []; } $tableInstanceColumns = []; foreach ($tableElement->xpath('./column') as $columnElement) { $columnName = (string) $columnElement; if (empty($columnName)) { throw new PHPUnit_Extensions_Database_Exception("Missing elements for table $tableName. Add one or more elements to the
element."); } if (!in_array($columnName, $tableColumns[$tableName])) { $tableColumns[$tableName][] = $columnName; } $tableInstanceColumns[] = $columnName; } foreach ($tableElement->xpath('./row') as $rowElement) { $rowValues = []; $index = 0; $numOfTableInstanceColumns = count($tableInstanceColumns); foreach ($rowElement->children() as $columnValue) { if ($index >= $numOfTableInstanceColumns) { throw new PHPUnit_Extensions_Database_Exception("Row contains more values than the number of columns defined for table $tableName."); } switch ($columnValue->getName()) { case 'value': $rowValues[$tableInstanceColumns[$index]] = (string) $columnValue; $index++; break; case 'null': $rowValues[$tableInstanceColumns[$index]] = NULL; $index++; break; default: throw new PHPUnit_Extensions_Database_Exception('Unknown element ' . $columnValue->getName() . ' in a row element.'); } } $tableValues[$tableName][] = $rowValues; } } } public static function write(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset, $filename) { $pers = new PHPUnit_Extensions_Database_DataSet_Persistors_Xml(); $pers->setFileName($filename); try { $pers->write($dataset); } catch (RuntimeException $e) { throw new PHPUnit_Framework_Exception(__METHOD__ . ' called with an unwritable file.'); } } } dbunit-2.0.2/src/Extensions/Database/DataSet/YamlDataSet.php000066400000000000000000000075741261611365500236630ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Creates YamlDataSets. * * You can incrementally add YAML files as tables to your datasets * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DataSet_YamlDataSet extends PHPUnit_Extensions_Database_DataSet_AbstractDataSet { /** * @var array */ protected $tables = []; /** * @var PHPUnit_Extensions_Database_DataSet_IYamlParser */ protected $parser; /** * Creates a new YAML dataset * * @param string $yamlFile * @param PHPUnit_Extensions_Database_DataSet_IYamlParser $parser */ public function __construct($yamlFile, $parser = NULL) { if ($parser == NULL) { $parser = new PHPUnit_Extensions_Database_DataSet_SymfonyYamlParser(); } $this->parser = $parser; $this->addYamlFile($yamlFile); } /** * Adds a new yaml file to the dataset. * @param string $yamlFile */ public function addYamlFile($yamlFile) { $data = $this->parser->parseYaml($yamlFile); foreach ($data as $tableName => $rows) { if (!isset($rows)) { $rows = []; } if (!is_array($rows)) { continue; } if (!array_key_exists($tableName, $this->tables)) { $columns = $this->getColumns($rows); $tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( $tableName, $columns ); $this->tables[$tableName] = new PHPUnit_Extensions_Database_DataSet_DefaultTable( $tableMetaData ); } foreach ($rows as $row) { $this->tables[$tableName]->addRow($row); } } } /** * Creates a unique list of columns from all the rows in a table. * If the table is defined another time in the Yaml, and if the Yaml * parser could return the multiple occerrences, then this would be * insufficient unless we grouped all the occurences of the table * into onwe row set. sfYaml, however, does not provide multiple tables * with the same name, it only supplies the last table. * * @params all the rows in a table. */ private function getColumns($rows) { $columns = []; foreach ($rows as $row) { $columns = array_merge($columns, array_keys($row)); } return array_values(array_unique($columns)); } /** * Creates an iterator over the tables in the data set. If $reverse is * true a reverse iterator will be returned. * * @param bool $reverse * @return PHPUnit_Extensions_Database_DataSet_ITableIterator */ protected function createIterator($reverse = FALSE) { return new PHPUnit_Extensions_Database_DataSet_DefaultTableIterator( $this->tables, $reverse ); } /** * Saves a given $dataset to $filename in YAML format * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataset * @param string $filename */ public static function write(PHPUnit_Extensions_Database_DataSet_IDataSet $dataset, $filename) { $pers = new PHPUnit_Extensions_Database_DataSet_Persistors_Yaml(); $pers->setFileName($filename); try { $pers->write($dataset); } catch (RuntimeException $e) { throw new PHPUnit_Framework_Exception( __METHOD__ . ' called with an unwritable file.' ); } } } dbunit-2.0.2/src/Extensions/Database/DefaultTester.php000066400000000000000000000022501261611365500227230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * This is the default implementation of the database tester. It receives its * connection object from the constructor. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_DefaultTester extends PHPUnit_Extensions_Database_AbstractTester { /** * @var PHPUnit_Extensions_Database_DB_IDatabaseConnection */ protected $connection; /** * Creates a new default database tester using the given connection. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection */ public function __construct(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { parent::__construct(); $this->connection = $connection; } /** * Returns the test database connection. * * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection */ public function getConnection() { return $this->connection; } } dbunit-2.0.2/src/Extensions/Database/Exception.php000066400000000000000000000010051261611365500221030ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Thrown for exceptions encountered with database operations. Provides * information regarding which operations failed and the query (if any) it * failed on. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Exception extends Exception { } dbunit-2.0.2/src/Extensions/Database/IDatabaseListConsumer.php000066400000000000000000000010731261611365500243370ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * An interface for classes that require a list of databases to operate. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_IDatabaseListConsumer { /** * Sets the database for the spec * * @param array $databases */ public function setDatabases(array $databases); } dbunit-2.0.2/src/Extensions/Database/ITester.php000066400000000000000000000042431261611365500215330ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * This is the interface for DatabaseTester objects. These objects are used to * add database testing to existing test cases using composition instead of * extension. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_ITester { /** * Closes the specified connection. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection */ public function closeConnection(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection); /** * Returns the test database connection. * * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection */ public function getConnection(); /** * Returns the test dataset. * * @return PHPUnit_Extensions_Database_DataSet_IDataSet */ public function getDataSet(); /** * TestCases must call this method inside setUp(). */ public function onSetUp(); /** * TestCases must call this method inside tearDown(). */ public function onTearDown(); /** * Sets the test dataset to use. * * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet */ public function setDataSet(PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet); /** * Sets the schema value. * * @param string $schema */ public function setSchema($schema); /** * Sets the DatabaseOperation to call when starting the test. * * @param PHPUnit_Extensions_Database_Operation_DatabaseOperation $setUpOperation */ public function setSetUpOperation(PHPUnit_Extensions_Database_Operation_IDatabaseOperation $setUpOperation); /** * Sets the DatabaseOperation to call when stopping the test. * * @param PHPUnit_Extensions_Database_Operation_DatabaseOperation $tearDownOperation */ public function setTearDownOperation(PHPUnit_Extensions_Database_Operation_IDatabaseOperation $tearDownOperation); } dbunit-2.0.2/src/Extensions/Database/Operation/000077500000000000000000000000001261611365500214005ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/Operation/Composite.php000066400000000000000000000036031261611365500240550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * This class facilitates combining database operations. To create a composite * operation pass an array of classes that implement * PHPUnit_Extensions_Database_Operation_IDatabaseOperation and they will be * executed in that order against all data sets. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Composite implements PHPUnit_Extensions_Database_Operation_IDatabaseOperation { /** * @var array */ protected $operations = []; /** * Creates a composite operation. * * @param array $operations */ public function __construct(Array $operations) { foreach ($operations as $operation) { if ($operation instanceof PHPUnit_Extensions_Database_Operation_IDatabaseOperation) { $this->operations[] = $operation; } else { throw new InvalidArgumentException('Only database operation instances can be passed to a composite database operation.'); } } } public function execute(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection, PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { try { foreach ($this->operations as $operation) { /* @var $operation PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ $operation->execute($connection, $dataSet); } } catch (PHPUnit_Extensions_Database_Operation_Exception $e) { throw new PHPUnit_Extensions_Database_Operation_Exception("COMPOSITE[{$e->getOperation()}]", $e->getQuery(), $e->getArgs(), $e->getTable(), $e->getError()); } } } dbunit-2.0.2/src/Extensions/Database/Operation/Delete.php000066400000000000000000000030171261611365500233140ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Deletes the rows in a given dataset using primary key columns. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Delete extends PHPUnit_Extensions_Database_Operation_RowBased { protected $operationName = 'DELETE'; protected $iteratorDirection = self::ITERATOR_TYPE_REVERSE; protected function buildOperationQuery(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { $keys = $databaseTableMetaData->getPrimaryKeys(); $whereStatement = 'WHERE ' . implode(' AND ', $this->buildPreparedColumnArray($keys, $connection)); $query = " DELETE FROM {$connection->quoteSchemaObject($table->getTableMetaData()->getTableName())} {$whereStatement} "; return $query; } protected function buildOperationArguments(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, $row) { $args = []; foreach ($databaseTableMetaData->getPrimaryKeys() as $columnName) { $args[] = $table->getValue($row, $columnName); } return $args; } } dbunit-2.0.2/src/Extensions/Database/Operation/DeleteAll.php000066400000000000000000000022261261611365500237460ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Deletes all rows from all tables in a dataset. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_DeleteAll implements PHPUnit_Extensions_Database_Operation_IDatabaseOperation { public function execute(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection, PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { foreach ($dataSet->getReverseIterator() as $table) { /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ $query = " DELETE FROM {$connection->quoteSchemaObject($table->getTableMetaData()->getTableName())} "; try { $connection->getConnection()->query($query); } catch (PDOException $e) { throw new PHPUnit_Extensions_Database_Operation_Exception('DELETE_ALL', $query, [], $table, $e->getMessage()); } } } } dbunit-2.0.2/src/Extensions/Database/Operation/Exception.php000066400000000000000000000040571261611365500240550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Thrown for exceptions encountered with database operations. Provides * information regarding which operations failed and the query (if any) it * failed on. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Exception extends RuntimeException { /** * @var string */ protected $operation; /** * @var string */ protected $preparedQuery; /** * @var array */ protected $preparedArgs; /** * @var PHPUnit_Extensions_Database_DataSet_ITable */ protected $table; /** * @var string */ protected $error; /** * Creates a new dbunit operation exception * * @param string $operation * @param string $current_query * @param PHPUnit_Extensions_Database_DataSet_ITable $current_table * @param string $error */ public function __construct($operation, $current_query, $current_args, $current_table, $error) { parent::__construct("{$operation} operation failed on query: {$current_query} using args: " . print_r($current_args, TRUE) . " [{$error}]"); $this->operation = $operation; $this->preparedQuery = $current_query; $this->preparedArgs = $current_args; $this->table = $current_table; $this->error = $error; } public function getOperation() { return $this->operation; } public function getQuery() { return $this->preparedQuery; } public function getTable() { return $this->table; } public function getArgs() { return $this->preparedArgs; } public function getError() { return $this->error; } } dbunit-2.0.2/src/Extensions/Database/Operation/Factory.php000066400000000000000000000054261261611365500235270ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A class factory to easily return database operations. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Factory { /** * Returns a null database operation * * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ public static function NONE() { return new PHPUnit_Extensions_Database_Operation_Null(); } /** * Returns a clean insert database operation. It will remove all contents * from the table prior to re-inserting rows. * * @param bool $cascadeTruncates Set to true to force truncates to cascade on databases that support this. * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ public static function CLEAN_INSERT($cascadeTruncates = FALSE) { return new PHPUnit_Extensions_Database_Operation_Composite([ self::TRUNCATE($cascadeTruncates), self::INSERT() ]); } /** * Returns an insert database operation. * * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ public static function INSERT() { return new PHPUnit_Extensions_Database_Operation_Insert(); } /** * Returns a truncate database operation. * * @param bool $cascadeTruncates Set to true to force truncates to cascade on databases that support this. * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ public static function TRUNCATE($cascadeTruncates = FALSE) { $truncate = new PHPUnit_Extensions_Database_Operation_Truncate(); $truncate->setCascade($cascadeTruncates); return $truncate; } /** * Returns a delete database operation. * * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ public static function DELETE() { return new PHPUnit_Extensions_Database_Operation_Delete(); } /** * Returns a delete_all database operation. * * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ public static function DELETE_ALL() { return new PHPUnit_Extensions_Database_Operation_DeleteAll(); } /** * Returns an update database operation. * * @return PHPUnit_Extensions_Database_Operation_IDatabaseOperation */ public static function UPDATE() { return new PHPUnit_Extensions_Database_Operation_Update(); } } dbunit-2.0.2/src/Extensions/Database/Operation/IDatabaseOperation.php000066400000000000000000000017241261611365500256130ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides a basic interface and functionality for executing database * operations against a connection using a specific dataSet. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_Operation_IDatabaseOperation { /** * Executes the database operation against the given $connection for the * given $dataSet. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet * @throws PHPUnit_Extensions_Database_Operation_Exception */ public function execute(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection, PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet); } dbunit-2.0.2/src/Extensions/Database/Operation/Insert.php000066400000000000000000000043211261611365500233550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * This class provides functionality for inserting rows from a dataset into a database. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Insert extends PHPUnit_Extensions_Database_Operation_RowBased { protected $operationName = 'INSERT'; protected function buildOperationQuery(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { $columnCount = count($table->getTableMetaData()->getColumns()); if ($columnCount > 0) { $placeHolders = implode(', ', array_fill(0, $columnCount, '?')); $columns = ''; foreach ($table->getTableMetaData()->getColumns() as $column) { $columns .= $connection->quoteSchemaObject($column) . ', '; } $columns = substr($columns, 0, -2); $query = " INSERT INTO {$connection->quoteSchemaObject($table->getTableMetaData()->getTableName())} ({$columns}) VALUES ({$placeHolders}) "; return $query; } else { return FALSE; } } protected function buildOperationArguments(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, $row) { $args = []; foreach ($table->getTableMetaData()->getColumns() as $columnName) { $args[] = $table->getValue($row, $columnName); } return $args; } protected function disablePrimaryKeys(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { if (count($databaseTableMetaData->getPrimaryKeys())) { return TRUE; } return FALSE; } } dbunit-2.0.2/src/Extensions/Database/Operation/Null.php000066400000000000000000000012071261611365500230230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * This class represents a null database operation. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Null implements PHPUnit_Extensions_Database_Operation_IDatabaseOperation { public function execute(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection, PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { /* do nothing */ } } dbunit-2.0.2/src/Extensions/Database/Operation/Replace.php000066400000000000000000000101401261611365500234600ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Updates the rows in a given dataset using primary key columns. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Replace extends PHPUnit_Extensions_Database_Operation_RowBased { protected $operationName = 'REPLACE'; protected function buildOperationQuery(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { $keys = $databaseTableMetaData->getPrimaryKeys(); $whereStatement = 'WHERE ' . implode(' AND ', $this->buildPreparedColumnArray($keys, $connection)); $query = " SELECT COUNT(*) FROM {$connection->quoteSchemaObject($table->getTableMetaData()->getTableName())} {$whereStatement} "; return $query; } protected function buildOperationArguments(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, $row) { $args = []; foreach ($databaseTableMetaData->getPrimaryKeys() as $columnName) { $args[] = $table->getValue($row, $columnName); } return $args; } /** * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet */ public function execute(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection, PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { $insertOperation = new PHPUnit_Extensions_Database_Operation_Insert; $updateOperation = new PHPUnit_Extensions_Database_Operation_Update; $databaseDataSet = $connection->createDataSet(); foreach ($dataSet as $table) { /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ $databaseTableMetaData = $databaseDataSet->getTableMetaData($table->getTableMetaData()->getTableName()); $insertQuery = $insertOperation->buildOperationQuery($databaseTableMetaData, $table, $connection); $updateQuery = $updateOperation->buildOperationQuery($databaseTableMetaData, $table, $connection); $selectQuery = $this->buildOperationQuery($databaseTableMetaData, $table, $connection); $insertStatement = $connection->getConnection()->prepare($insertQuery); $updateStatement = $connection->getConnection()->prepare($updateQuery); $selectStatement = $connection->getConnection()->prepare($selectQuery); $rowCount = $table->getRowCount(); for ($i = 0; $i < $rowCount; $i++) { $selectArgs = $this->buildOperationArguments($databaseTableMetaData, $table, $i); $query = $selectQuery; $args = $selectArgs; try { $selectStatement->execute($selectArgs); if ($selectStatement->fetchColumn(0) > 0) { $updateArgs = $updateOperation->buildOperationArguments($databaseTableMetaData, $table, $i); $query = $updateQuery; $args = $updateArgs; $updateStatement->execute($updateArgs); } else { $insertArgs = $insertOperation->buildOperationArguments($databaseTableMetaData, $table, $i); $query = $insertQuery; $args = $insertArgs; $insertStatement->execute($insertArgs); } } catch (Exception $e) { throw new PHPUnit_Extensions_Database_Operation_Exception( $this->operationName, $query, $args, $table, $e->getMessage() ); } } } } } dbunit-2.0.2/src/Extensions/Database/Operation/RowBased.php000066400000000000000000000110531261611365500236170ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Provides basic functionality for row based operations. * * To create a row based operation you must create two functions. The first * one, buildOperationQuery(), must return a query that will be used to create * a prepared statement. The second one, buildOperationArguments(), should * return an array containing arguments for each row. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_Operation_RowBased implements PHPUnit_Extensions_Database_Operation_IDatabaseOperation { const ITERATOR_TYPE_FORWARD = 0; const ITERATOR_TYPE_REVERSE = 1; protected $operationName; protected $iteratorDirection = self::ITERATOR_TYPE_FORWARD; /** * @return string|bool String containing the query or FALSE if a valid query cannot be constructed */ protected abstract function buildOperationQuery(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection); protected abstract function buildOperationArguments(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, $row); /** * Allows an operation to disable primary keys if necessary. * * @param PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData * @param PHPUnit_Extensions_Database_DataSet_ITable $table * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection */ protected function disablePrimaryKeys(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { return FALSE; } /** * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection * @param PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet */ public function execute(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection, PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { $databaseDataSet = $connection->createDataSet(); $dsIterator = $this->iteratorDirection == self::ITERATOR_TYPE_REVERSE ? $dataSet->getReverseIterator() : $dataSet->getIterator(); foreach ($dsIterator as $table) { $rowCount = $table->getRowCount(); if($rowCount == 0) continue; /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ $databaseTableMetaData = $databaseDataSet->getTableMetaData($table->getTableMetaData()->getTableName()); $query = $this->buildOperationQuery($databaseTableMetaData, $table, $connection); $disablePrimaryKeys = $this->disablePrimaryKeys($databaseTableMetaData, $table, $connection); if ($query === FALSE) { if ($table->getRowCount() > 0) { throw new PHPUnit_Extensions_Database_Operation_Exception($this->operationName, '', [], $table, 'Rows requested for insert, but no columns provided!'); } continue; } if ($disablePrimaryKeys) { $connection->disablePrimaryKeys($databaseTableMetaData->getTableName()); } $statement = $connection->getConnection()->prepare($query); for ($i = 0; $i < $rowCount; $i++) { $args = $this->buildOperationArguments($databaseTableMetaData, $table, $i); try { $statement->execute($args); } catch (Exception $e) { throw new PHPUnit_Extensions_Database_Operation_Exception( $this->operationName, $query, $args, $table, $e->getMessage() ); } } if ($disablePrimaryKeys) { $connection->enablePrimaryKeys($databaseTableMetaData->getTableName()); } } } protected function buildPreparedColumnArray($columns, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { $columnArray = []; foreach ($columns as $columnName) { $columnArray[] = "{$connection->quoteSchemaObject($columnName)} = ?"; } return $columnArray; } } dbunit-2.0.2/src/Extensions/Database/Operation/Truncate.php000066400000000000000000000046641261611365500237100ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Executes a truncate against all tables in a dataset. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Truncate implements PHPUnit_Extensions_Database_Operation_IDatabaseOperation { protected $useCascade = FALSE; public function setCascade($cascade = TRUE) { $this->useCascade = $cascade; } public function execute(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection, PHPUnit_Extensions_Database_DataSet_IDataSet $dataSet) { foreach ($dataSet->getReverseIterator() as $table) { /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ $query = " {$connection->getTruncateCommand()} {$connection->quoteSchemaObject($table->getTableMetaData()->getTableName())} "; if ($this->useCascade && $connection->allowsCascading()) { $query .= ' CASCADE'; } try { $this->disableForeignKeyChecksForMysql($connection); $connection->getConnection()->query($query); $this->enableForeignKeyChecksForMysql($connection); } catch (\Exception $e) { $this->enableForeignKeyChecksForMysql($connection); if ($e instanceof PDOException) { throw new PHPUnit_Extensions_Database_Operation_Exception('TRUNCATE', $query, [], $table, $e->getMessage()); } throw $e; } } } private function disableForeignKeyChecksForMysql(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { if ($this->isMysql($connection)) { $connection->getConnection()->query('SET FOREIGN_KEY_CHECKS = 0'); } } private function enableForeignKeyChecksForMysql(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { if ($this->isMysql($connection)) { $connection->getConnection()->query('SET FOREIGN_KEY_CHECKS = 1'); } } private function isMysql(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { return $connection->getConnection()->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql'; } } dbunit-2.0.2/src/Extensions/Database/Operation/Update.php000066400000000000000000000042341261611365500233360ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Updates the rows in a given dataset using primary key columns. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_Operation_Update extends PHPUnit_Extensions_Database_Operation_RowBased { protected $operationName = 'UPDATE'; protected function buildOperationQuery(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { $keys = $databaseTableMetaData->getPrimaryKeys(); $columns = $table->getTableMetaData()->getColumns(); $whereStatement = 'WHERE ' . implode(' AND ', $this->buildPreparedColumnArray($keys, $connection)); $setStatement = 'SET ' . implode(', ', $this->buildPreparedColumnArray($columns, $connection)); $query = " UPDATE {$connection->quoteSchemaObject($table->getTableMetaData()->getTableName())} {$setStatement} {$whereStatement} "; return $query; } protected function buildOperationArguments(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, $row) { $args = []; foreach ($table->getTableMetaData()->getColumns() as $columnName) { $args[] = $table->getValue($row, $columnName); } foreach ($databaseTableMetaData->getPrimaryKeys() as $columnName) { $args[] = $table->getValue($row, $columnName); } return $args; } protected function disablePrimaryKeys(PHPUnit_Extensions_Database_DataSet_ITableMetaData $databaseTableMetaData, PHPUnit_Extensions_Database_DataSet_ITable $table, PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { if (count($databaseTableMetaData->getPrimaryKeys())) { return TRUE; } return FALSE; } } dbunit-2.0.2/src/Extensions/Database/TestCase.php000066400000000000000000000010331261611365500216610ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A TestCase extension that provides functionality for testing and asserting * against a real database. * * @since Class available since Release 1.0.0 */ abstract class PHPUnit_Extensions_Database_TestCase extends PHPUnit_Framework_TestCase { use PHPUnit_Extensions_Database_TestCase_Trait; } dbunit-2.0.2/src/Extensions/Database/TestCaseTrait.php000066400000000000000000000204661261611365500227000ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ trait PHPUnit_Extensions_Database_TestCase_Trait { /** * @var PHPUnit_Extensions_Database_ITester */ protected $databaseTester; /** * Closes the specified connection. * * @param PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection */ protected function closeConnection(PHPUnit_Extensions_Database_DB_IDatabaseConnection $connection) { $this->getDatabaseTester()->closeConnection($connection); } /** * Returns the test database connection. * * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection */ protected abstract function getConnection(); /** * Gets the IDatabaseTester for this testCase. If the IDatabaseTester is * not set yet, this method calls newDatabaseTester() to obtain a new * instance. * * @return PHPUnit_Extensions_Database_ITester */ protected function getDatabaseTester() { if (empty($this->databaseTester)) { $this->databaseTester = $this->newDatabaseTester(); } return $this->databaseTester; } /** * Returns the test dataset. * * @return PHPUnit_Extensions_Database_DataSet_IDataSet */ protected abstract function getDataSet(); /** * Returns the database operation executed in test setup. * * @return PHPUnit_Extensions_Database_Operation_DatabaseOperation */ protected function getSetUpOperation() { return PHPUnit_Extensions_Database_Operation_Factory::CLEAN_INSERT(); } /** * Returns the database operation executed in test cleanup. * * @return PHPUnit_Extensions_Database_Operation_DatabaseOperation */ protected function getTearDownOperation() { return PHPUnit_Extensions_Database_Operation_Factory::NONE(); } /** * Creates a IDatabaseTester for this testCase. * * @return PHPUnit_Extensions_Database_ITester */ protected function newDatabaseTester() { return new PHPUnit_Extensions_Database_DefaultTester($this->getConnection()); } /** * Creates a new DefaultDatabaseConnection using the given PDO connection * and database schema name. * * @param PDO $connection * @param string $schema * @return PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection */ protected function createDefaultDBConnection(PDO $connection, $schema = '') { return new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection($connection, $schema); } /** * Creates a new ArrayDataSet with the given array. * The array parameter is an associative array of tables where the key is * the table name and the value an array of rows. Each row is an associative * array by itself with keys representing the field names and the values the * actual data. * For example: * array( * "addressbook" => array( * array("id" => 1, "name" => "...", "address" => "..."), * array("id" => 2, "name" => "...", "address" => "...") * ) * ) * * @param array $data * @return PHPUnit_Extensions_Database_DataSet_ArrayDataSet */ protected function createArrayDataSet(array $data) { return new PHPUnit_Extensions_Database_DataSet_ArrayDataSet($data); } /** * Creates a new FlatXmlDataSet with the given $xmlFile. (absolute path.) * * @param string $xmlFile * @return PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet */ protected function createFlatXMLDataSet($xmlFile) { return new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet($xmlFile); } /** * Creates a new XMLDataSet with the given $xmlFile. (absolute path.) * * @param string $xmlFile * @return PHPUnit_Extensions_Database_DataSet_XmlDataSet */ protected function createXMLDataSet($xmlFile) { return new PHPUnit_Extensions_Database_DataSet_XmlDataSet($xmlFile); } /** * Create a a new MysqlXmlDataSet with the given $xmlFile. (absolute path.) * * @param string $xmlFile * @return PHPUnit_Extensions_Database_DataSet_MysqlXmlDataSet * @since Method available since Release 1.0.0 */ protected function createMySQLXMLDataSet($xmlFile) { return new PHPUnit_Extensions_Database_DataSet_MysqlXmlDataSet($xmlFile); } /** * Returns an operation factory instance that can be used to instantiate * new operations. * * @return PHPUnit_Extensions_Database_Operation_Factory */ protected function getOperations() { return new PHPUnit_Extensions_Database_Operation_Factory(); } /** * Performs operation returned by getSetUpOperation(). */ protected function setUp() { parent::setUp(); $this->databaseTester = NULL; $this->getDatabaseTester()->setSetUpOperation($this->getSetUpOperation()); $this->getDatabaseTester()->setDataSet($this->getDataSet()); $this->getDatabaseTester()->onSetUp(); } /** * Performs operation returned by getTearDownOperation(). */ protected function tearDown() { $this->getDatabaseTester()->setTearDownOperation($this->getTearDownOperation()); $this->getDatabaseTester()->setDataSet($this->getDataSet()); $this->getDatabaseTester()->onTearDown(); /* * Destroy the tester after the test is run to keep DB connections * from piling up. */ $this->databaseTester = NULL; } /** * Asserts that two given tables are equal. * * @param PHPUnit_Extensions_Database_DataSet_ITable $expected * @param PHPUnit_Extensions_Database_DataSet_ITable $actual * @param string $message */ public static function assertTablesEqual(PHPUnit_Extensions_Database_DataSet_ITable $expected, PHPUnit_Extensions_Database_DataSet_ITable $actual, $message = '') { $constraint = new PHPUnit_Extensions_Database_Constraint_TableIsEqual($expected); self::assertThat($actual, $constraint, $message); } /** * Asserts that two given datasets are equal. * * @param PHPUnit_Extensions_Database_DataSet_ITable $expected * @param PHPUnit_Extensions_Database_DataSet_ITable $actual * @param string $message */ public static function assertDataSetsEqual(PHPUnit_Extensions_Database_DataSet_IDataSet $expected, PHPUnit_Extensions_Database_DataSet_IDataSet $actual, $message = '') { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($expected); self::assertThat($actual, $constraint, $message); } /** * Assert that a given table has a given amount of rows * * @param string $tableName Name of the table * @param int $expected Expected amount of rows in the table * @param string $message Optional message */ public function assertTableRowCount($tableName, $expected, $message = '') { $constraint = new PHPUnit_Extensions_Database_Constraint_TableRowCount($tableName, $expected); $actual = $this->getConnection()->getRowCount($tableName); self::assertThat($actual, $constraint, $message); } /** * Asserts that a given table contains a given row * * @param array $expectedRow Row expected to find * @param PHPUnit_Extensions_Database_DataSet_ITable $table Table to look into * @param string $message Optional message */ public function assertTableContains(array $expectedRow, PHPUnit_Extensions_Database_DataSet_ITable $table, $message = '') { self::assertThat($table->assertContainsRow($expectedRow), self::isTrue(), $message); } } dbunit-2.0.2/src/Extensions/Database/UI/000077500000000000000000000000001261611365500177555ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/UI/Command.php000066400000000000000000000025111261611365500220430ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Delegates database extension commands to the appropriate mode classes. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_UI_Command { /** * @var PHPUnit_Extensions_Database_UI_IModeFactory */ protected $modeFactory; /** * @param PHPUnit_Extensions_Database_UI_IModeFactory $modeFactory */ public function __construct(PHPUnit_Extensions_Database_UI_IModeFactory $modeFactory) { $this->modeFactory = $modeFactory; } /** * Executes the database extension ui. * * @param PHPUnit_Extensions_Database_UI_IMedium $medium * @param PHPUnit_Extensions_Database_UI_Context $context */ public function main(PHPUnit_Extensions_Database_UI_IMedium $medium, PHPUnit_Extensions_Database_UI_Context $context) { try { $medium->buildContext($context); $mode = $this->modeFactory->getMode($context->getMode()); $mode->execute($context->getModeArguments(), $medium); } catch (Exception $e) { $medium->handleException($e); } } } dbunit-2.0.2/src/Extensions/Database/UI/Context.php000066400000000000000000000020211261611365500221050ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Holds the context of a particular database extension ui call. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_UI_Context { /** * @var string */ protected $mode; /** * @var array */ protected $modeArguments; /** * @param string $mode */ public function setMode($mode) { $this->mode = $mode; } /** * @return string */ public function getMode() { return $this->mode; } /** * @param array $arguments */ public function setModeArguments(array $arguments) { $this->mode_arguments = $arguments; } /** * @return array */ public function getModeArguments() { return $this->mode_arguments; } } dbunit-2.0.2/src/Extensions/Database/UI/IMedium.php000066400000000000000000000015201261611365500220150ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Defines the interface necessary to create new mediums. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_UI_IMedium extends PHPUnit_Extensions_Database_UI_IMediumPrinter { /** * Builds the context for the application. * * @param PHPUnit_Extensions_Database_UI_Context $context */ public function buildContext(PHPUnit_Extensions_Database_UI_Context $context); /** * Handles the displaying of exceptions received from the application. * * @param Exception $e */ public function handleException(Exception $e); } dbunit-2.0.2/src/Extensions/Database/UI/IMediumPrinter.php000066400000000000000000000012461261611365500233660ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Defines the interface necessary to create new medium printers. * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_UI_IMediumPrinter { /** * Prints standard output messages. * * @param string $message */ public function output($message); /** * Prints standard error messages. * * @param string $message */ public function error($message); } dbunit-2.0.2/src/Extensions/Database/UI/IMode.php000066400000000000000000000013341261611365500214640ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Defines the interface necessary to create new modes * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_UI_IMode { /** * Executes the mode using the given arguments and medium. * * @param array $modeArguments * @param PHPUnit_Extensions_Database_UI_IMediumPrinter $medium */ public function execute(array $modeArguments, PHPUnit_Extensions_Database_UI_IMediumPrinter $medium); } dbunit-2.0.2/src/Extensions/Database/UI/IModeFactory.php000066400000000000000000000014121261611365500230110ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Defines the interface necessary to create new mode factories * * @since Class available since Release 1.0.0 */ interface PHPUnit_Extensions_Database_UI_IModeFactory { /** * Generates a new mode based on a given name. * * @param string $mode * @return PHPUnit_Extensions_Database_UI_IMode */ public function getMode($mode); /** * Returns the names of valid modes this factory can create. * * @return array */ public function getModeList(); } dbunit-2.0.2/src/Extensions/Database/UI/InvalidModeException.php000066400000000000000000000024241261611365500245420ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * An exception thrown when an invalid mode is requested from a mode factory. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_UI_InvalidModeException extends LogicException { /** * @var string */ protected $mode; /** * @var PHPUnit_Extensions_Database_UI_IModeFactory */ protected $modeFactory; /** * @param string $mode * @param string $msg * @param PHPUnit_Extensions_Database_UI_IModeFactory $modeFactory */ public function __construct($mode, $msg, PHPUnit_Extensions_Database_UI_IModeFactory $modeFactory) { $this->mode = $mode; $this->modeFactory = $modeFactory; parent::__construct($msg); } /** * @return string */ public function getMode() { return $this->mode; } /** * @return array */ public function getValidModes() { return $this->modeFactory->getModeList(); } } dbunit-2.0.2/src/Extensions/Database/UI/Mediums/000077500000000000000000000000001261611365500213605ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/UI/Mediums/Text.php000066400000000000000000000046371261611365500230270ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * A text medium for the database extension tool. * * This class builds the call context based on command line parameters and * prints output to stdout and stderr as appropriate. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_UI_Mediums_Text implements PHPUnit_Extensions_Database_UI_IMedium { /** * @var array */ protected $arguments; /** * @var string */ protected $command; /** * @param array $arguments */ public function __construct(Array $arguments) { $this->arguments = $arguments; } /** * Builds the context for the application. * * @param PHPUnit_Extensions_Database_UI_Context $context */ public function buildContext(PHPUnit_Extensions_Database_UI_Context $context) { $arguments = $this->arguments; $this->command = array_shift($arguments); $context->setMode(array_shift($arguments)); $context->setModeArguments($arguments); } /** * Handles the displaying of exceptions received from the application. * * @param Exception $e */ public function handleException(Exception $e) { try { throw $e; } catch (PHPUnit_Extensions_Database_UI_InvalidModeException $invalidMode) { if ($invalidMode->getMode() == '') { $this->error('Please Specify a Command!' . PHP_EOL); } else { $this->error('Command Does Not Exist: ' . $invalidMode->getMode() . PHP_EOL); } $this->error('Valid Commands:' . PHP_EOL); foreach ($invalidMode->getValidModes() as $mode) { $this->error(' ' . $mode . PHP_EOL); } } catch (Exception $e) { $this->error('Unknown Error: ' . $e->getMessage() . PHP_EOL); } } /** * Prints the message to stdout. * * @param string $message */ public function output($message) { echo $message; } /** * Prints the message to stderr * * @param string $message */ public function error($message) { fputs(STDERR, $message); } } dbunit-2.0.2/src/Extensions/Database/UI/ModeFactory.php000066400000000000000000000050751261611365500227110ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The default factory for db extension modes. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_UI_ModeFactory implements PHPUnit_Extensions_Database_UI_IModeFactory { /** * Generates a new mode based on a given name. * * @param string $mode * @return PHPUnit_Extensions_Database_UI_IMode */ public function getMode($mode) { if ($mode == '') { throw new PHPUnit_Extensions_Database_UI_InvalidModeException($mode, 'A mode was not provided.', $this); } $modeMap = $this->getModeMap(); if (isset($modeMap[$mode])) { $modeClass = $this->getModeClass($mode, $modeMap[$mode]); return new $modeClass(); } else { throw new PHPUnit_Extensions_Database_UI_InvalidModeException($mode, 'The mode does not exist. Attempting to load mode ' . $mode, $this); } } /** * Returns the names of valid modes this factory can create. * * @return array */ public function getModeList() { return array_keys($this->getModeMap()); } /** * Returns a map of modes to class name parts * * @return array */ protected function getModeMap() { return ['export-dataset' => 'ExportDataSet']; } /** * Given a $mode label and a $mode_name class part attempts to return the * class name necessary to instantiate the mode. * * @param string $mode * @param string $mode_name * @return string */ protected function getModeClass($mode, $mode_name) { $modeClass = 'PHPUnit_Extensions_Database_UI_Modes_' . $mode_name; $modeFile = dirname(__FILE__) . '/Modes/' . $mode_name . '.php'; if (class_exists($modeClass)) { return $modeClass; } if (!is_readable($modeFile)) { throw new PHPUnit_Extensions_Database_UI_InvalidModeException($mode, 'The mode\'s file could not be loaded. Trying file ' . $modeFile, $this); } require_once ($modeFile); if (!class_exists($modeClass)) { throw new PHPUnit_Extensions_Database_UI_InvalidModeException($mode, 'The mode class was not found in the file. Expecting class name ' . $modeClass, $this); } return $modeClass; } } dbunit-2.0.2/src/Extensions/Database/UI/Modes/000077500000000000000000000000001261611365500210245ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/UI/Modes/ExportDataSet.php000066400000000000000000000056551261611365500242770ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * The class for the export-dataset command. * * This command is used to convert existing data sets or data in the database * into a valid data set format. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_UI_Modes_ExportDataSet implements PHPUnit_Extensions_Database_UI_IMode { /** * Executes the export dataset command. * * @param array $modeArguments * @param PHPUnit_Extensions_Database_UI_IMediumPrinter $medium */ public function execute(array $modeArguments, PHPUnit_Extensions_Database_UI_IMediumPrinter $medium) { $arguments = new PHPUnit_Extensions_Database_UI_Modes_ExportDataSet_Arguments($modeArguments); if (FALSE && !$arguments->areValid()) { throw new InvalidArgumentException('The arguments for this command are incorrect.'); } $datasets = []; foreach ($arguments->getArgumentArray('dataset') as $argString) { $datasets[] = $this->getDataSetFromArgument($argString, $arguments->getDatabases()); } $finalDataset = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet($datasets); $outputDataset = $this->getPersistorFromArgument($arguments->getSingleArgument('output')); $outputDataset->write($finalDataset); } /** * Returns the correct dataset given an argument containing a dataset spec. * * @param string $argString * @param array $databaseList * @return PHPUnit_Extensions_Database_DataSet_IDataSet */ protected function getDataSetFromArgument($argString, $databaseList) { $dataSetSpecFactory = new PHPUnit_Extensions_Database_DataSet_Specs_Factory(); list($type, $dataSetSpecStr) = explode(':', $argString, 2); $dataSetSpec = $dataSetSpecFactory->getDataSetSpecByType($type); if ($dataSetSpec instanceof PHPUnit_Extensions_Database_IDatabaseListConsumer) { $dataSetSpec->setDatabases($databaseList); } return $dataSetSpec->getDataSet($dataSetSpecStr); } /** * Returns the correct persistor given an argument containing a persistor spec. * * @param string $argString * @return PHPUnit_Extensions_Database_DataSet_IPersistable */ protected function getPersistorFromArgument($argString) { $persistorFactory = new PHPUnit_Extensions_Database_DataSet_Persistors_Factory(); list($type, $spec) = explode(':', $argString, 2); return $persistorFactory->getPersistorBySpec($type, $spec); } } dbunit-2.0.2/src/Extensions/Database/UI/Modes/ExportDataSet/000077500000000000000000000000001261611365500235535ustar00rootroot00000000000000dbunit-2.0.2/src/Extensions/Database/UI/Modes/ExportDataSet/Arguments.php000066400000000000000000000050001261611365500262240ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * Represents arguments received from a medium. * * @since Class available since Release 1.0.0 */ class PHPUnit_Extensions_Database_UI_Modes_ExportDataSet_Arguments { /** * @var array */ protected $arguments = []; /** * @param array $arguments */ public function __construct(array $arguments) { foreach ($arguments as $argument) { list($argName, $argValue) = explode('=', $argument, 2); $argName = trim($argName, '-'); if (!isset($this->arguments[$argName])) { $this->arguments[$argName] = []; } $this->arguments[$argName][] = $argValue; } } /** * Returns an array of arguments matching the given $argName * * @param string $argName * @return array */ public function getArgumentArray($argName) { if ($this->argumentIsSet($argName)) { return $this->arguments[$argName]; } else { return NULL; } } /** * Returns a single argument value. * * If $argName points to an array the first argument will be returned. * * @param string $argName * @return mixed */ public function getSingleArgument($argName) { if ($this->argumentIsSet($argName)) { return reset($this->arguments[$argName]); } else { return NULL; } } /** * Returns whether an argument is set. * * @param string $argName * @return bool */ public function argumentIsSet($argName) { return array_key_exists($argName, $this->arguments); } /** * Returns an array containing the names of all arguments provided. * * @return array */ public function getArgumentNames() { return array_keys($this->arguments); } /** * Returns an array of database arguments keyed by name. * * @todo this should be moved. * @return array */ public function getDatabases() { $databases = $this->getArgumentArray('database'); $retDb = []; foreach ($databases as $db) { list($name, $arg) = explode(':', $db, 2); $retDb[$name] = $arg; } return $retDb; } } dbunit-2.0.2/tests/000077500000000000000000000000001261611365500141505ustar00rootroot00000000000000dbunit-2.0.2/tests/Constraint/000077500000000000000000000000001261611365500162745ustar00rootroot00000000000000dbunit-2.0.2/tests/Constraint/TableRowCountTest.php000066400000000000000000000020271261611365500223760ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_Constraint_TableRowCountTest extends PHPUnit_Framework_TestCase { public function testConstraint() { $constraint = new PHPUnit_Extensions_Database_Constraint_TableRowCount('name', 42); $this->assertTrue($constraint->evaluate(42, '', true)); $this->assertFalse($constraint->evaluate(24, '', true)); $this->assertEquals('is equal to expected row count 42', $constraint->toString()); try { $this->assertThat(24, $constraint, ''); } catch (PHPUnit_Framework_ExpectationFailedException $e) { $this->assertEquals( 'Failed asserting that 24 is equal to expected row count 42.', $e->getMessage() ); } } } dbunit-2.0.2/tests/DB/000077500000000000000000000000001261611365500144355ustar00rootroot00000000000000dbunit-2.0.2/tests/DB/DefaultDatabaseConnectionTest.php000066400000000000000000000016471261611365500230470ustar00rootroot00000000000000db = new PDO('sqlite::memory:'); $this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $this->db->exec('CREATE TABLE test (field1 VARCHAR(100))'); } public function testRowCountForEmptyTableReturnsZero() { $conn = new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection($this->db); $this->assertEquals(0, $conn->getRowCount('test')); } public function testRowCountForTableWithTwoRowsReturnsTwo() { $this->db->exec('INSERT INTO test (field1) VALUES (\'foobar\')'); $this->db->exec('INSERT INTO test (field1) VALUES (\'foobarbaz\')'); $conn = new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection($this->db); $this->assertEquals(2, $conn->getRowCount('test')); } } dbunit-2.0.2/tests/DataSet/000077500000000000000000000000001261611365500154755ustar00rootroot00000000000000dbunit-2.0.2/tests/DataSet/AbstractTableTest.php000066400000000000000000000211651261611365500215660ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_AbstractTableTest extends PHPUnit_Framework_TestCase { /** * @var PHPUnit_Extensions_Database_DataSet_QueryTable */ protected $table; public function setUp() { $tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table', ['id', 'column1'] ); $this->table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($tableMetaData); $this->table->addRow([ 'id' => 1, 'column1' => 'randomValue' ]); } /** * @param array $row * @param bool $exists * @dataProvider providerTableContainsRow */ public function testTableContainsRow($row, $exists) { $result = $this->table->assertContainsRow($row); $this->assertEquals($exists, $result); } public function providerTableContainsRow() { return [ [['id' => 1, 'column1' => 'randomValue'], true], [['id' => 1, 'column1' => 'notExistingValue'], false] ]; } public function testMatchesWithNonMatchingMetaData() { $tableMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $otherTable->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($otherMetaData)); $tableMetaData->expects($this->once()) ->method('matches') ->with($otherMetaData) ->will($this->returnValue(false)); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($tableMetaData); $this->assertFalse($table->matches($otherTable)); } public function testMatchesWithNonMatchingRowCount() { $tableMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $otherTable->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($otherMetaData)); $otherTable->expects($this->once()) ->method('getRowCount') ->will($this->returnValue(0)); $tableMetaData->expects($this->once()) ->method('matches') ->with($otherMetaData) ->will($this->returnValue(true)); $table = $this->getMock('PHPUnit_Extensions_Database_DataSet_DefaultTable', ['getRowCount'], [$tableMetaData]); $table->expects($this->once()) ->method('getRowCount') ->will($this->returnValue(1)); $this->assertFalse($table->matches($otherTable)); } /** * @param array $tableColumnValues * @param array $otherColumnValues * @param bool $matches * @dataProvider providerMatchesWithColumnValueComparisons */ public function testMatchesWithColumnValueComparisons($tableColumnValues, $otherColumnValues, $matches) { $tableMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $otherTable->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($otherMetaData)); $otherTable->expects($this->once()) ->method('getRowCount') ->will($this->returnValue(count($otherColumnValues))); $tableMetaData->expects($this->once()) ->method('getColumns') ->will($this->returnValue(array_keys(reset($tableColumnValues)))); $tableMetaData->expects($this->once()) ->method('matches') ->with($otherMetaData) ->will($this->returnValue(true)); $table = $this->getMock('PHPUnit_Extensions_Database_DataSet_DefaultTable', ['getRowCount', 'getValue'], [$tableMetaData]); $table->expects($this->any()) ->method('getRowCount') ->will($this->returnValue(count($tableColumnValues))); $tableMap = []; $otherMap = []; foreach ($tableColumnValues as $rowIndex => $rowData) { foreach ($rowData as $columnName => $columnValue) { $tableMap[] = [$rowIndex, $columnName, $columnValue]; $otherMap[] = [$rowIndex, $columnName, $otherColumnValues[$rowIndex][$columnName]]; } } $table->expects($this->any()) ->method('getValue') ->will($this->returnValueMap($tableMap)); $otherTable->expects($this->any()) ->method('getValue') ->will($this->returnValueMap($otherMap)); $this->assertSame($matches, $table->matches($otherTable)); } public function providerMatchesWithColumnValueComparisons() { return [ // One row, one column, matches [ [ ['id' => 1], ], [ ['id' => 1], ], true, ], // One row, one column, does not match [ [ ['id' => 1], ], [ ['id' => 2], ], false, ], // Multiple rows, one column, matches [ [ ['id' => 1], ['id' => 2], ], [ ['id' => 1], ['id' => 2], ], true, ], // Multiple rows, one column, do not match [ [ ['id' => 1], ['id' => 2], ], [ ['id' => 1], ['id' => 3], ], false, ], // Multiple rows, multiple columns, matches [ [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'bar'], ], [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'bar'], ], true, ], // Multiple rows, multiple columns, do not match [ [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'bar'], ], [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'baz'], ], false, ], // Int and int as string must match [ [ ['id' => 42], ], [ ['id' => '42'], ], true, ], // Float and float as string must match [ [ ['id' => 15.3], ], [ ['id' => '15.3'], ], true, ], // Int and float must match [ [ ['id' => 18.00], ], [ ['id' => 18], ], true, ], // 0 and empty string must not match [ [ ['id' => 0], ], [ ['id' => ''], ], false, ], // 0 and null must not match [ [ ['id' => 0], ], [ ['id' => null], ], false, ], // empty string and null must not match [ [ ['id' => ''], ], [ ['id' => null], ], false, ], ]; } } dbunit-2.0.2/tests/DataSet/CompositeDataSetTest.php000066400000000000000000000151471261611365500222660ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_CompositeDataSetTest extends PHPUnit_Framework_TestCase { protected $expectedDataSet1; protected $expectedDataSet2; protected $expectedDataSet3; public function setUp() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $table3MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table3', ['table3_id', 'column9', 'column10', 'column11', 'column12'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $table3 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table3MetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'tgfahgasdf', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => 'asfgklg' ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'fsdb, ghfdas' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => 'blah', 'column8' => '43asd "fhgj" sfadh' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => 'blah', 'column8' => 'thesethasdl asdflkjsadf asdfsadfhl "adsf, halsdf" sadfhlasdf' ]); $table3->addRow([ 'table3_id' => 1, 'column9' => 'sfgsda', 'column10' => 16, 'column11' => 45.57, 'column12' => 'sdfh .ds,ajfas asdf h' ]); $table3->addRow([ 'table3_id' => 2, 'column9' => 'afdstgb', 'column10' => 41, 'column11' => 46.645, 'column12' => '87yhasdf sadf yah;/a ' ]); $table3->addRow([ 'table3_id' => 3, 'column9' => 'gldsf', 'column10' => 46, 'column11' => 123.456, 'column12' => '0y8hosnd a/df7y olgbjs da' ]); $this->expectedDataSet1 = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); $this->expectedDataSet2 = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table3]); $this->expectedDataSet3 = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2, $table3]); } public function testCompositeDataSet() { $actual = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet([$this->expectedDataSet1, $this->expectedDataSet2]); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($this->expectedDataSet3, $actual); } public function testCompatibleTablesInDifferentDataSetsNonDuplicateRows() { $compatibleTable = new PHPUnit_Extensions_Database_DataSet_DefaultTable( $this->expectedDataSet3->getTable('table3')->getTableMetaData() ); $compatibleTable->addRow([ 'table3_id' => 4, 'column9' => 'asdasd', 'column10' => 17, 'column11' => 42.57, 'column12' => 'askldja' ]); $compositeDataSet = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet([ new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$compatibleTable]), $this->expectedDataSet2 ]); $this->assertEquals(4, $compositeDataSet->getTable('table3')->getRowCount()); } /** * @expectedException InvalidArgumentException * @expectedExceptionMessage There is already a table named table3 with different table definition */ public function testExceptionOnIncompatibleTablesSameTableNames() { $inCompatibleTableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table3', ['table3_id', 'column13', 'column14', 'column15', 'column16'] ); $inCompatibleTable = new PHPUnit_Extensions_Database_DataSet_DefaultTable($inCompatibleTableMetaData); $inCompatibleTable->addRow([ 'column13' => 'asdasda asdasd', 'column14' => 'aiafsjas asd', 'column15' => 'asdasdasd', 'column16' => 2141 ]); $compositeDataSet = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet([ $this->expectedDataSet2, new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$inCompatibleTable]) ]); } /** * @expectedException InvalidArgumentException * @expectedExceptionMessage There is already a table named table3 with different table definition */ public function testExceptionOnIncompatibleTablesSameTableNames2() { $inCompatibleTableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table3', ['table3_id', 'column13', 'column14', 'column15', 'column16'] ); $inCompatibleTable = new PHPUnit_Extensions_Database_DataSet_DefaultTable($inCompatibleTableMetaData); $inCompatibleTable->addRow([ 'column13' => 'asdasda asdasd', 'column14' => 'aiafsjas asd', 'column15' => 'asdasdasd', 'column16' => 2141 ]); $compositeDataSet = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet([ new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$inCompatibleTable]), $this->expectedDataSet2 ]); } } dbunit-2.0.2/tests/DataSet/CsvDataSetTest.php000066400000000000000000000054011261611365500210470ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_CsvDataSetTest extends PHPUnit_Framework_TestCase { protected $expectedDataSet; public function testCSVDataSet() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'tgfahgasdf', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => 'asfgklg' ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'fsdb, ghfdas' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => 'blah', 'column8' => '43asd "fhgj" sfadh' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => 'blah', 'column8' => 'thesethasdl asdflkjsadf asdfsadfhl "adsf, halsdf" sadfhlasdf' ]); $expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); $csvDataSet = new PHPUnit_Extensions_Database_DataSet_CsvDataSet(); $csvDataSet->addTable('table1', dirname(__FILE__) . '/../_files/CsvDataSets/table1.csv'); $csvDataSet->addTable('table2', dirname(__FILE__) . '/../_files/CsvDataSets/table2.csv'); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($expectedDataSet, $csvDataSet); } } dbunit-2.0.2/tests/DataSet/FilterTest.php000066400000000000000000000066311261611365500203010ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_FilterTest extends PHPUnit_Framework_TestCase { protected $expectedDataSet; public function setUp() { $this->expectedDataSet = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet( dirname(__FILE__) . '/../_files/XmlDataSets/FilteredTestFixture.xml' ); } public function testDeprecatedFilteredDataSetConstructor() { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($this->expectedDataSet); $dataSet = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet( dirname(__FILE__) . '/../_files/XmlDataSets/FilteredTestComparison.xml' ); $filteredDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet, [ 'table1' => ['table1_id'], 'table2' => '*', 'table3' => 'table3_id' ]); self::assertThat($filteredDataSet, $constraint); } public function testExcludeFilteredDataSet() { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($this->expectedDataSet); $dataSet = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet( dirname(__FILE__) . '/../_files/XmlDataSets/FilteredTestComparison.xml' ); $filteredDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet); $filteredDataSet->addExcludeTables(['table2']); $filteredDataSet->setExcludeColumnsForTable('table1', ['table1_id']); $filteredDataSet->setExcludeColumnsForTable('table3', ['table3_id']); self::assertThat($filteredDataSet, $constraint); } public function testIncludeFilteredDataSet() { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($this->expectedDataSet); $dataSet = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet( dirname(__FILE__) . '/../_files/XmlDataSets/FilteredTestComparison.xml' ); $filteredDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet); $filteredDataSet->addIncludeTables(['table1', 'table3']); $filteredDataSet->setIncludeColumnsForTable('table1', ['column1', 'column2', 'column3', 'column4']); $filteredDataSet->setIncludeColumnsForTable('table3', ['column9', 'column10', 'column11', 'column12']); self::assertThat($filteredDataSet, $constraint); } public function testIncludeExcludeMixedDataSet() { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($this->expectedDataSet); $dataSet = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet( dirname(__FILE__) . '/../_files/XmlDataSets/FilteredTestComparison.xml' ); $filteredDataSet = new PHPUnit_Extensions_Database_DataSet_DataSetFilter($dataSet); $filteredDataSet->addIncludeTables(['table1', 'table3']); $filteredDataSet->setExcludeColumnsForTable('table1', ['table1_id']); $filteredDataSet->setIncludeColumnsForTable('table3', ['column9', 'column10', 'column11', 'column12']); self::assertThat($filteredDataSet, $constraint); } } dbunit-2.0.2/tests/DataSet/PersistorTest.php000066400000000000000000000054771261611365500210550ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_PersistorTest extends PHPUnit_Framework_TestCase { public function testFlatXml() { $dataSetFile = dirname(__FILE__) . '/../_files/XmlDataSets/FlatXmlWriter.xml'; $filename = dirname(__FILE__) . '/' . uniqid() . '.xml'; $dataSet = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet($dataSetFile); PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet::write($dataSet, $filename); $this->assertXmlFileEqualsXmlFile($dataSetFile, $filename); unlink($filename); } public function testXml() { $dataSetFile = dirname(__FILE__) . '/../_files/XmlDataSets/XmlWriter.xml'; $filename = dirname(__FILE__) . '/' . uniqid() . '.xml'; $dataSet = new PHPUnit_Extensions_Database_DataSet_XmlDataSet($dataSetFile); PHPUnit_Extensions_Database_DataSet_XmlDataSet::write($dataSet, $filename); $this->assertXmlFileEqualsXmlFile($dataSetFile, $filename); unlink($filename); } public function testEntitiesFlatXml() { $metaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['col1', 'col2'], ['col1']); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($metaData); $table->addRow(['col1' => 1, 'col2' => 'test']); $dataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table]); $expectedFile = dirname(__FILE__) . '/../_files/XmlDataSets/FlatXmlWriterEntities.xml'; $filename = dirname(__FILE__) . '/' . uniqid() . '.xml'; PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet::write($dataSet, $filename); $this->assertXmlFileEqualsXmlFile($expectedFile, $filename); unlink($filename); } public function testEntitiesXml() { $metaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['col1', 'col2'], ['col1']); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($metaData); $table->addRow(['col1' => 1, 'col2' => 'test']); $dataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table]); $expectedFile = dirname(__FILE__) . '/../_files/XmlDataSets/XmlWriterEntities.xml'; $filename = dirname(__FILE__) . '/' . uniqid() . '.xml'; PHPUnit_Extensions_Database_DataSet_XmlDataSet::write($dataSet, $filename); $this->assertXmlFileEqualsXmlFile($expectedFile, $filename); unlink($filename); } } dbunit-2.0.2/tests/DataSet/QueryDataSetTest.php000066400000000000000000000060131261611365500214210ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_QueryDataSetTest extends PHPUnit_Extensions_Database_TestCase { /** * @var PHPUnit_Extensions_Database_DataSet_QueryDataSet */ protected $dataSet; protected $pdo; /** * @return PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection */ protected function getConnection() { return $this->createDefaultDBConnection($this->pdo, 'test'); } protected function getDataSet() { return $this->createFlatXMLDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/QueryDataSetTest.xml'); } public function setUp() { $this->pdo = DBUnitTestUtility::getSQLiteMemoryDB(); parent::setUp(); $this->dataSet = new PHPUnit_Extensions_Database_DataSet_QueryDataSet($this->getConnection()); $this->dataSet->addTable('table1'); $this->dataSet->addTable('query1', ' SELECT t1.column1 tc1, t2.column5 tc2 FROM table1 t1 JOIN table2 t2 ON t1.table1_id = t2.table2_id '); } public function testGetTable() { $expectedTable1 = $this->getConnection()->createDataSet(['table1'])->getTable('table1'); $expectedTable2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('query1', ['tc1', 'tc2']) ); $expectedTable2->addRow(['tc1' => 'bar', 'tc2' => 'blah']); $this->assertTablesEqual($expectedTable1, $this->dataSet->getTable('table1')); $this->assertTablesEqual($expectedTable2, $this->dataSet->getTable('query1')); } public function testGetTableNames() { $this->assertEquals(['table1', 'query1'], $this->dataSet->getTableNames()); } public function testCreateIterator() { $expectedTable1 = $this->getConnection()->createDataSet(['table1'])->getTable('table1'); $expectedTable2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('query1', ['tc1', 'tc2']) ); $expectedTable2->addRow(['tc1' => 'bar', 'tc2' => 'blah']); foreach ($this->dataSet as $i => $table) { /* @var $table PHPUnit_Extensions_Database_DataSet_ITable */ switch ($table->getTableMetaData()->getTableName()) { case 'table1': $this->assertTablesEqual($expectedTable1, $table); break; case 'query1': $this->assertTablesEqual($expectedTable2, $table); break; default: $this->fail('Proper keys not present from the iterator'); } } } } dbunit-2.0.2/tests/DataSet/QueryTableTest.php000066400000000000000000000064001261611365500211230ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_QueryTableTest extends PHPUnit_Framework_TestCase { /** * @var PHPUnit_Extensions_Database_DataSet_QueryTable */ protected $table; public function setUp() { $query = " SELECT 'value1' as col1, 'value2' as col2, 'value3' as col3 UNION SELECT 'value4' as col1, 'value5' as col2, 'value6' as col3 "; $this->table = new PHPUnit_Extensions_Database_DataSet_QueryTable( 'table1', $query, new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection(new PDO('sqlite::memory:'), 'test') ); } public static function providerTestGetValue() { return [ [0, 'col1', 'value1'], [0, 'col2', 'value2'], [0, 'col3', 'value3'], [1, 'col1', 'value4'], [1, 'col2', 'value5'], [1, 'col3', 'value6'], ]; } public function testGetTableMetaData() { $metaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['col1', 'col2', 'col3']); $this->assertEquals($metaData, $this->table->getTableMetaData()); } public function testGetRowCount() { $this->assertEquals(2, $this->table->getRowCount()); } /** * @dataProvider providerTestGetValue */ public function testGetValue($row, $column, $value) { $this->assertEquals($value, $this->table->getValue($row, $column)); } public function testGetRow() { $this->assertEquals(['col1' => 'value1', 'col2' => 'value2', 'col3' => 'value3'], $this->table->getRow(0)); } public function testAssertEquals() { $expected_table = new PHPUnit_Extensions_Database_DataSet_DefaultTable(new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['col1', 'col2', 'col3'])); $expected_table->addRow(['col1' => 'value1', 'col2' => 'value2', 'col3' => 'value3']); $expected_table->addRow(['col1' => 'value4', 'col2' => 'value5', 'col3' => 'value6']); $this->assertTrue($this->table->matches($expected_table)); } public function testAssertEqualsFails() { $expected_table = new PHPUnit_Extensions_Database_DataSet_DefaultTable(new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['col1', 'col2', 'col3'])); $expected_table->addRow(['col1' => 'value1', 'col2' => 'value2', 'col3' => 'value3']); $expected_table->addRow(['col1' => 'value4', 'col2' => 'value5', 'col3' => 'value6']); $expected_table->addRow(['col1' => 'value7', 'col2' => 'value8', 'col3' => 'value9']); $this->assertFalse($this->table->matches($expected_table)); } public function testAssertRowContains() { $this->assertTrue($this->table->assertContainsRow( ['col1' => 'value1', 'col2' => 'value2', 'col3' => 'value3'] )); } } dbunit-2.0.2/tests/DataSet/ReplacementDataSetTest.php000066400000000000000000000225501261611365500225570ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_ReplacementDataSetTest extends PHPUnit_Framework_TestCase { /** * @var PHPUnit_Extensions_Database_DataSet_DefaultDataSet */ protected $startingDataSet; public function setUp() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'My name is %%%name%%%', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => '[NULL]' ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'My name is %%%name%%%' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => '[NULL]', 'column8' => '43asdfhgj' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => '[NULL]', 'column8' => '[NULL] not really' ]); $this->startingDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); } public function testNoReplacement() { PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual( $this->startingDataSet, new PHPUnit_Extensions_Database_DataSet_ReplacementDataSet($this->startingDataSet) ); } public function testFullReplacement() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'My name is %%%name%%%', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => NULL ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'My name is %%%name%%%' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => NULL, 'column8' => '43asdfhgj' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => NULL, 'column8' => '[NULL] not really' ]); $expected = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementDataSet($this->startingDataSet); $actual->addFullReplacement('[NULL]', NULL); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($expected, $actual); } public function testSubStrReplacement() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'My name is Mike Lively', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => '[NULL]' ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'My name is Mike Lively' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => '[NULL]', 'column8' => '43asdfhgj' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => '[NULL]', 'column8' => '[NULL] not really' ]); $expected = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementDataSet($this->startingDataSet); $actual->addSubStrReplacement('%%%name%%%', 'Mike Lively'); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($expected, $actual); } public function testConstructorReplacements() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'My name is Mike Lively', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => NULL ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'My name is Mike Lively' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => NULL, 'column8' => '43asdfhgj' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => NULL, 'column8' => '[NULL] not really' ]); $expected = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementDataSet( $this->startingDataSet, ['[NULL]' => NULL], ['%%%name%%%' => 'Mike Lively'] ); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($expected, $actual); } } dbunit-2.0.2/tests/DataSet/ReplacementTableTest.php000066400000000000000000000351461261611365500222660ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_ReplacementTableTest extends PHPUnit_Framework_TestCase { /** * @var PHPUnit_Extensions_Database_DataSet_DefaultTable */ protected $startingTable; public function setUp() { $tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($tableMetaData); $table->addRow([ 'table1_id' => 1, 'column1' => 'My name is %%%name%%%', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => '[NULL] not really', 'column4' => '[NULL]' ]); $this->startingTable = $table; } public function testNoReplacement() { PHPUnit_Extensions_Database_TestCase::assertTablesEqual( $this->startingTable, new PHPUnit_Extensions_Database_DataSet_ReplacementTable($this->startingTable) ); } public function testFullReplacement() { $tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($tableMetaData); $table->addRow([ 'table1_id' => 1, 'column1' => 'My name is %%%name%%%', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => '[NULL] not really', 'column4' => NULL ]); $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementTable($this->startingTable); $actual->addFullReplacement('[NULL]', NULL); PHPUnit_Extensions_Database_TestCase::assertTablesEqual($table, $actual); } public function testSubStrReplacement() { $tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($tableMetaData); $table->addRow([ 'table1_id' => 1, 'column1' => 'My name is Mike Lively', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => '[NULL] not really', 'column4' => '[NULL]' ]); $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementTable($this->startingTable); $actual->addSubStrReplacement('%%%name%%%', 'Mike Lively'); PHPUnit_Extensions_Database_TestCase::assertTablesEqual($table, $actual); } public function testConstructorReplacements() { $tableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table = new PHPUnit_Extensions_Database_DataSet_DefaultTable($tableMetaData); $table->addRow([ 'table1_id' => 1, 'column1' => 'My name is Mike Lively', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => '[NULL] not really', 'column4' => NULL ]); $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementTable( $this->startingTable, ['[NULL]' => NULL], ['%%%name%%%' => 'Mike Lively'] ); PHPUnit_Extensions_Database_TestCase::assertTablesEqual($table, $actual); } public function testGetRow() { $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementTable( $this->startingTable, ['[NULL]' => NULL], ['%%%name%%%' => 'Mike Lively'] ); $this->assertEquals( [ 'table1_id' => 1, 'column1' => 'My name is Mike Lively', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ], $actual->getRow(0) ); $this->assertEquals( [ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => '[NULL] not really', 'column4' => NULL ], $actual->getRow(2) ); } public function testGetValue() { $actual = new PHPUnit_Extensions_Database_DataSet_ReplacementTable( $this->startingTable, ['[NULL]' => NULL], ['%%%name%%%' => 'Mike Lively'] ); $this->assertNull($actual->getValue(2, 'column4')); $this->assertEquals('My name is Mike Lively', $actual->getValue(0, 'column1')); } public function testMatchesWithNonMatchingMetaData() { $tableMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $table = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $table->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($tableMetaData)); $otherTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $otherTable->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($otherMetaData)); $tableMetaData->expects($this->once()) ->method('matches') ->with($otherMetaData) ->will($this->returnValue(false)); $replacementTable = new PHPUnit_Extensions_Database_DataSet_ReplacementTable($table); $this->assertFalse($replacementTable->matches($otherTable)); } public function testMatchesWithNonMatchingRowCount() { $tableMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $table = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $table->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($tableMetaData)); $otherTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $otherTable->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($otherMetaData)); $otherTable->expects($this->once()) ->method('getRowCount') ->will($this->returnValue(0)); $tableMetaData->expects($this->once()) ->method('matches') ->with($otherMetaData) ->will($this->returnValue(true)); $replacementTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ReplacementTable', ['getRowCount'], [$table]); $replacementTable->expects($this->once()) ->method('getRowCount') ->will($this->returnValue(1)); $this->assertFalse($replacementTable->matches($otherTable)); } /** * @param array $tableColumnValues * @param array $otherColumnValues * @param bool $matches * @dataProvider providerMatchesWithColumnValueComparisons */ public function testMatchesWithColumnValueComparisons($tableColumnValues, $otherColumnValues, $matches) { $tableMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $otherMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $table = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $table->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($tableMetaData)); $otherTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $otherTable->expects($this->once()) ->method('getTableMetaData') ->will($this->returnValue($otherMetaData)); $otherTable->expects($this->once()) ->method('getRowCount') ->will($this->returnValue(count($otherColumnValues))); $tableMetaData->expects($this->once()) ->method('getColumns') ->will($this->returnValue(array_keys(reset($tableColumnValues)))); $tableMetaData->expects($this->once()) ->method('matches') ->with($otherMetaData) ->will($this->returnValue(true)); $replacementTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ReplacementTable', ['getRowCount', 'getValue'], [$table]); $replacementTable->expects($this->any()) ->method('getRowCount') ->will($this->returnValue(count($tableColumnValues))); $tableMap = []; $otherMap = []; foreach ($tableColumnValues as $rowIndex => $rowData) { foreach ($rowData as $columnName => $columnValue) { $tableMap[] = [$rowIndex, $columnName, $columnValue]; $otherMap[] = [$rowIndex, $columnName, $otherColumnValues[$rowIndex][$columnName]]; } } $replacementTable->expects($this->any()) ->method('getValue') ->will($this->returnValueMap($tableMap)); $otherTable->expects($this->any()) ->method('getValue') ->will($this->returnValueMap($otherMap)); $this->assertSame($matches, $replacementTable->matches($otherTable)); } public function providerMatchesWithColumnValueComparisons() { return [ // One row, one column, matches [ [ ['id' => 1], ], [ ['id' => 1], ], true, ], // One row, one column, does not match [ [ ['id' => 1], ], [ ['id' => 2], ], false, ], // Multiple rows, one column, matches [ [ ['id' => 1], ['id' => 2], ], [ ['id' => 1], ['id' => 2], ], true, ], // Multiple rows, one column, do not match [ [ ['id' => 1], ['id' => 2], ], [ ['id' => 1], ['id' => 3], ], false, ], // Multiple rows, multiple columns, matches [ [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'bar'], ], [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'bar'], ], true, ], // Multiple rows, multiple columns, do not match [ [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'bar'], ], [ ['id' => 1, 'name' => 'foo'], ['id' => 2, 'name' => 'baz'], ], false, ], // Int and int as string must match [ [ ['id' => 42], ], [ ['id' => '42'], ], true, ], // Float and float as string must match [ [ ['id' => 15.3], ], [ ['id' => '15.3'], ], true, ], // Int and float must match [ [ ['id' => 18.00], ], [ ['id' => 18], ], true, ], // 0 and empty string must not match [ [ ['id' => 0], ], [ ['id' => ''], ], false, ], // 0 and null must not match [ [ ['id' => 0], ], [ ['id' => null], ], false, ], // empty string and null must not match [ [ ['id' => ''], ], [ ['id' => null], ], false, ], ]; } } dbunit-2.0.2/tests/DataSet/XmlDataSetsTest.php000066400000000000000000000065751261611365500212540ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_XmlDataSetsTest extends PHPUnit_Framework_TestCase { protected $expectedDataSet; public function setUp() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'tgfahgasdf', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => 'asfgklg' ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'fsdbghfdas' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => NULL, 'column8' => '43asdfhgj' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => NULL, 'column8' => NULL ]); $this->expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); } public function testFlatXmlDataSet() { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($this->expectedDataSet); $xmlFlatDataSet = new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/FlatXmlDataSet.xml'); self::assertThat($xmlFlatDataSet, $constraint); } public function testXmlDataSet() { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($this->expectedDataSet); $xmlDataSet = new PHPUnit_Extensions_Database_DataSet_XmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/XmlDataSet.xml'); self::assertThat($xmlDataSet, $constraint); } public function testMysqlXmlDataSet() { $constraint = new PHPUnit_Extensions_Database_Constraint_DataSetIsEqual($this->expectedDataSet); $mysqlXmlDataSet = new PHPUnit_Extensions_Database_DataSet_MysqlXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/MysqlXmlDataSet.xml'); self::assertThat($mysqlXmlDataSet, $constraint); } } dbunit-2.0.2/tests/DataSet/YamlDataSetTest.php000066400000000000000000000103351261611365500212200ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since File available since Release 1.0.0 */ class Extensions_Database_DataSet_YamlDataSetTest extends PHPUnit_Framework_TestCase { protected $expectedDataSet; public function testYamlDataSet() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table1', ['table1_id', 'column1', 'column2', 'column3', 'column4', 'extraColumn'] ); $table2MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'table2', ['table2_id', 'column5', 'column6', 'column7', 'column8'] ); $emptyTableMetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'emptyTable', [] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table2MetaData); $emptyTable = new PHPUnit_Extensions_Database_DataSet_DefaultTable($emptyTableMetaData); $table1->addRow([ 'table1_id' => 1, 'column1' => 'tgfahgasdf', 'column2' => 200, 'column3' => 34.64, 'column4' => 'yghkf;a hahfg8ja h;' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'hk;afg', 'column2' => 654, 'column3' => 46.54, 'column4' => '24rwehhads', 'extraColumn' => 'causes no worries' ]); $table1->addRow([ 'table1_id' => 3, 'column1' => 'ha;gyt', 'column2' => 462, 'column3' => 1654.4, 'column4' => 'asfgklg' ]); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fhah', 'column6' => 456, 'column7' => 46.5, 'column8' => 'fsdb, ghfdas' ]); $table2->addRow([ 'table2_id' => 2, 'column5' => 'asdhfoih', 'column6' => 654, 'column7' => 'blah', 'column8' => '43asd "fhgj" sfadh' ]); $table2->addRow([ 'table2_id' => 3, 'column5' => 'ajsdlkfguitah', 'column6' => 654, 'column7' => 'blah', 'column8' => 'thesethasdl asdflkjsadf asdfsadfhl "adsf, halsdf" sadfhlasdf' ]); $expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2, $emptyTable]); $yamlDataSet = new PHPUnit_Extensions_Database_DataSet_YamlDataSet(dirname(__FILE__) . '/../_files/YamlDataSets/testDataSet.yaml'); PHPUnit_Extensions_Database_DataSet_YamlDataSet::write($yamlDataSet, sys_get_temp_dir() . '/yaml.dataset'); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($expectedDataSet, $yamlDataSet); } public function testAlternateParser() { $table1MetaData = new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData( 'math_table', ['answer'] ); $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable($table1MetaData); $table1->addRow([ 'answer' => 'pi/2' ]); $expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1]); $parser = new Extensions_Database_DataSet_YamlDataSetTest_PiOver2Parser(); $yamlDataSet = new PHPUnit_Extensions_Database_DataSet_YamlDataSet( dirname(__FILE__) . '/../_files/YamlDataSets/testDataSet.yaml', $parser); PHPUnit_Extensions_Database_TestCase::assertDataSetsEqual($expectedDataSet, $yamlDataSet); } } /** * A trivial YAML parser that always returns the same array. * * @since Class available since Release 1.3.1 */ class Extensions_Database_DataSet_YamlDataSetTest_PiOver2Parser implements PHPUnit_Extensions_Database_DataSet_IYamlParser { public function parseYaml($yamlFile) { return ['math_table' => [ ['answer' => 'pi/2']]]; } } dbunit-2.0.2/tests/Operation/000077500000000000000000000000001261611365500161105ustar00rootroot00000000000000dbunit-2.0.2/tests/Operation/OperationsMySQLTest.php000066400000000000000000000077521261611365500225050ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ require_once dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'DatabaseTestUtility.php'; /** * @version SVN: $Id$ * @since File available since Release 1.0.0 */ class Extensions_Database_Operation_OperationsMySQLTest extends PHPUnit_Extensions_Database_TestCase { protected function setUp() { if (!extension_loaded('pdo_mysql')) { $this->markTestSkipped('pdo_mysql is required to run this test.'); } if (!defined('PHPUNIT_TESTSUITE_EXTENSION_DATABASE_MYSQL_DSN')) { $this->markTestSkipped('No MySQL server configured for this test.'); } parent::setUp(); } public function getConnection() { return new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection(DBUnitTestUtility::getMySQLDB(), 'mysql'); } public function getDataSet() { return new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/OperationsMySQLTestFixture.xml'); } /** * @covers PHPUnit_Extensions_Database_Operation_Truncate::execute */ public function testTruncate() { $truncateOperation = new PHPUnit_Extensions_Database_Operation_Truncate(); $truncateOperation->execute($this->getConnection(), $this->getDataSet()); $expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([ new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['table1_id', 'column1', 'column2', 'column3', 'column4']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table2', ['table2_id', 'table1_id', 'column5', 'column6', 'column7', 'column8']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table3', ['table3_id', 'table2_id', 'column9', 'column10', 'column11', 'column12']) ), ]); $this->assertDataSetsEqual($expectedDataSet, $this->getConnection()->createDataSet()); } public function getCompositeDataSet() { $compositeDataset = new PHPUnit_Extensions_Database_DataSet_CompositeDataSet(); $dataset = $this->createXMLDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/TruncateCompositeTest.xml'); $compositeDataset->addDataSet($dataset); return $compositeDataset; } public function testTruncateComposite() { $truncateOperation = new PHPUnit_Extensions_Database_Operation_Truncate(); $truncateOperation->execute($this->getConnection(), $this->getCompositeDataSet()); $expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([ new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['table1_id', 'column1', 'column2', 'column3', 'column4']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table2', ['table2_id', 'table1_id', 'column5', 'column6', 'column7', 'column8']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table3', ['table3_id', 'table2_id', 'column9', 'column10', 'column11', 'column12']) ), ]); $this->assertDataSetsEqual($expectedDataSet, $this->getConnection()->createDataSet()); } } dbunit-2.0.2/tests/Operation/OperationsTest.php000066400000000000000000000151311261611365500216050ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ require_once dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'DatabaseTestUtility.php'; /** * @since File available since Release 1.0.0 */ class Extensions_Database_Operation_OperationsTest extends PHPUnit_Extensions_Database_TestCase { protected function setUp() { if (!extension_loaded('pdo_sqlite')) { $this->markTestSkipped('PDO/SQLite is required to run this test.'); } parent::setUp(); } public function getConnection() { return new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection(DBUnitTestUtility::getSQLiteMemoryDB(), 'sqlite'); } public function getDataSet() { return new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/OperationsTestFixture.xml'); } public function testDelete() { $deleteOperation = new PHPUnit_Extensions_Database_Operation_Delete(); $deleteOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/DeleteOperationTest.xml')); $this->assertDataSetsEqual(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/DeleteOperationResult.xml'), $this->getConnection()->createDataSet()); } public function testDeleteAll() { $deleteAllOperation = new PHPUnit_Extensions_Database_Operation_DeleteAll(); $deleteAllOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/DeleteAllOperationTest.xml')); $expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([ new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['table1_id', 'column1', 'column2', 'column3', 'column4']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table2', ['table2_id', 'column5', 'column6', 'column7', 'column8']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table3', ['table3_id', 'column9', 'column10', 'column11', 'column12']) ), ]); $this->assertDataSetsEqual($expectedDataSet, $this->getConnection()->createDataSet()); } public function testTruncate() { $truncateOperation = new PHPUnit_Extensions_Database_Operation_Truncate(); $truncateOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/DeleteAllOperationTest.xml')); $expectedDataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([ new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['table1_id', 'column1', 'column2', 'column3', 'column4']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table2', ['table2_id', 'column5', 'column6', 'column7', 'column8']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table3', ['table3_id', 'column9', 'column10', 'column11', 'column12']) ), ]); $this->assertDataSetsEqual($expectedDataSet, $this->getConnection()->createDataSet()); } public function testInsert() { $insertOperation = new PHPUnit_Extensions_Database_Operation_Insert(); $insertOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/InsertOperationTest.xml')); $this->assertDataSetsEqual(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/InsertOperationResult.xml'), $this->getConnection()->createDataSet()); } public function testUpdate() { $updateOperation = new PHPUnit_Extensions_Database_Operation_Update(); $updateOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/UpdateOperationTest.xml')); $this->assertDataSetsEqual(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/UpdateOperationResult.xml'), $this->getConnection()->createDataSet()); } public function testReplace() { $replaceOperation = new PHPUnit_Extensions_Database_Operation_Replace(); $replaceOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/ReplaceOperationTest.xml')); $this->assertDataSetsEqual(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/ReplaceOperationResult.xml'), $this->getConnection()->createDataSet()); } public function testInsertEmptyTable() { $insertOperation = new PHPUnit_Extensions_Database_Operation_Insert(); $insertOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/EmptyTableInsertTest.xml')); $this->assertDataSetsEqual(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/EmptyTableInsertResult.xml'), $this->getConnection()->createDataSet()); } public function testInsertAllEmptyTables() { $insertOperation = new PHPUnit_Extensions_Database_Operation_Insert(); $insertOperation->execute($this->getConnection(), new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/AllEmptyTableInsertTest.xml')); $this->assertDataSetsEqual(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/AllEmptyTableInsertResult.xml'), $this->getConnection()->createDataSet()); } } dbunit-2.0.2/tests/Operation/RowBasedTest.php000066400000000000000000000156671261611365500212060ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ require_once dirname(dirname(__FILE__)) . DIRECTORY_SEPARATOR . '_files' . DIRECTORY_SEPARATOR . 'DatabaseTestUtility.php'; /** * @since File available since Release 1.0.0 */ class Extensions_Database_Operation_RowBasedTest extends PHPUnit_Extensions_Database_TestCase { protected function setUp() { if (!extension_loaded('pdo_sqlite')) { $this->markTestSkipped('PDO/SQLite is required to run this test.'); } parent::setUp(); } public function getConnection() { return new PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection(DBUnitTestUtility::getSQLiteMemoryDB(), 'sqlite'); } public function getDataSet() { $tables = [ new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['table1_id', 'column1', 'column2', 'column3', 'column4']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table2', ['table2_id', 'column5', 'column6', 'column7', 'column8']) ), new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table3', ['table3_id', 'column9', 'column10', 'column11', 'column12']) ), ]; return new PHPUnit_Extensions_Database_DataSet_DefaultDataSet($tables); } public function testExecute() { $connection = $this->getConnection(); /* @var $connection PHPUnit_Extensions_Database_DB_DefaultDatabaseConnection */ $table1 = new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table1', ['table1_id', 'column1', 'column2', 'column3', 'column4']) ); $table1->addRow([ 'table1_id' => 1, 'column1' => 'foo', 'column2' => 42, 'column3' => 4.2, 'column4' => 'bar' ]); $table1->addRow([ 'table1_id' => 2, 'column1' => 'qwerty', 'column2' => 23, 'column3' => 2.3, 'column4' => 'dvorak' ]); $table2 = new PHPUnit_Extensions_Database_DataSet_DefaultTable( new PHPUnit_Extensions_Database_DataSet_DefaultTableMetaData('table2', ['table2_id', 'column5', 'column6', 'column7', 'column8']) ); $table2->addRow([ 'table2_id' => 1, 'column5' => 'fdyhkn', 'column6' => 64, 'column7' => 4568.64, 'column8' => 'hkladfg' ]); $dataSet = new PHPUnit_Extensions_Database_DataSet_DefaultDataSet([$table1, $table2]); $mockOperation = $this->getMock('PHPUnit_Extensions_Database_Operation_RowBased', ['buildOperationQuery', 'buildOperationArguments']); /* @var $mockOperation PHPUnit_Framework_MockObject_MockObject */ $mockOperation->expects($this->at(0)) ->method('buildOperationQuery') ->with($connection->createDataSet()->getTableMetaData('table1'), $table1) ->will( $this->returnValue('INSERT INTO table1 (table1_id, column1, column2, column3, column4) VALUES (?, ?, ?, ?, ?)') ); $mockOperation->expects($this->at(1)) ->method('buildOperationArguments') ->with($connection->createDataSet()->getTableMetaData('table1'), $table1, 0) ->will( $this->returnValue([1, 'foo', 42, 4.2, 'bar']) ); $mockOperation->expects($this->at(2)) ->method('buildOperationArguments') ->with($connection->createDataSet()->getTableMetaData('table1'), $table1, 1) ->will( $this->returnValue([2, 'qwerty', 23, 2.3, 'dvorak']) ); $mockOperation->expects($this->at(3)) ->method('buildOperationQuery') ->with($connection->createDataSet()->getTableMetaData('table2'), $table2) ->will( $this->returnValue('INSERT INTO table2 (table2_id, column5, column6, column7, column8) VALUES (?, ?, ?, ?, ?)') ); $mockOperation->expects($this->at(4)) ->method('buildOperationArguments') ->with($connection->createDataSet()->getTableMetaData('table2'), $table2, 0) ->will( $this->returnValue([1, 'fdyhkn', 64, 4568.64, 'hkladfg']) ); /* @var $mockOperation PHPUnit_Extensions_Database_Operation_RowBased */ $mockOperation->execute($connection, $dataSet); $this->assertDataSetsEqual(new PHPUnit_Extensions_Database_DataSet_FlatXmlDataSet(dirname(__FILE__) . '/../_files/XmlDataSets/RowBasedExecute.xml'), $connection->createDataSet(['table1', 'table2'])); } public function testExecuteWithBadQuery() { $mockDatabaseDataSet = $this->getMock('PHPUnit_Extensions_Database_DataSet_DefaultDataSet'); $mockDatabaseDataSet->expects($this->never())->method('getTableMetaData'); $mockConnection = $this->getMock('PHPUnit_Extensions_Database_DB_IDatabaseConnection'); $mockConnection->expects($this->once())->method('createDataSet')->will($this->returnValue($mockDatabaseDataSet)); foreach (['getConnection', 'disablePrimaryKeys', 'enablePrimaryKeys'] as $method) { $mockConnection->expects($this->never())->method($method); } $mockTableMetaData = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITableMetaData'); $mockTableMetaData->expects($this->any())->method('getTableName')->will($this->returnValue('table')); $mockTable = $this->getMock('PHPUnit_Extensions_Database_DataSet_ITable'); $mockTable->expects($this->any())->method('getTableMetaData')->will($this->returnValue($mockTableMetaData)); $mockTable->expects($this->once())->method('getRowCount')->will($this->returnValue(0)); $mockDataSet = $this->getMock('PHPUnit_Extensions_Database_DataSet_DefaultDataSet'); $mockDataSet->expects($this->once())->method('getIterator')->will($this->returnValue(new ArrayIterator([$mockTable]))); $mockOperation = $this->getMock('PHPUnit_Extensions_Database_Operation_RowBased', ['buildOperationQuery', 'buildOperationArguments']); $mockOperation->expects($this->never())->method('buildOperationArguments'); $mockOperation->expects($this->never())->method('buildOperationQuery'); $mockOperation->execute($mockConnection, $mockDataSet); } } dbunit-2.0.2/tests/_files/000077500000000000000000000000001261611365500154115ustar00rootroot00000000000000dbunit-2.0.2/tests/_files/CsvDataSets/000077500000000000000000000000001261611365500175755ustar00rootroot00000000000000dbunit-2.0.2/tests/_files/CsvDataSets/table1.csv000066400000000000000000000002221261611365500214560ustar00rootroot00000000000000table1_id,column1,column2,column3,column4 1,tgfahgasdf,200,34.64,"yghkf;a hahfg8ja h;" 2,hk;afg,654,46.54,24rwehhads 3,ha;gyt,462,1654.4,asfgklg dbunit-2.0.2/tests/_files/CsvDataSets/table2.csv000066400000000000000000000003161261611365500214630ustar00rootroot00000000000000table2_id,column5,column6,column7,column8 1,fhah,456,46.5,"fsdb, ghfdas" 2,asdhfoih,654,blah,"43asd ""fhgj"" sfadh" 3,ajsdlkfguitah,654,blah,"thesethasdl asdflkjsadf asdfsadfhl ""adsf, halsdf"" sadfhlasdf" dbunit-2.0.2/tests/_files/DatabaseTestUtility.php000066400000000000000000000074611261611365500220620ustar00rootroot00000000000000 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ /** * @since Class available since Release 1.0.0 */ class DBUnitTestUtility { protected static $connection; protected static $mySQLConnection; public static function getSQLiteMemoryDB() { if (self::$connection === NULL) { self::$connection = new PDO('sqlite::memory:'); self::setUpDatabase(self::$connection); } return self::$connection; } /** * Creates connection to test MySQL database * * MySQL server must be installed locally, with root access * and empty password and listening on unix socket * * @return PDO * @see DBUnitTestUtility::setUpMySqlDatabase() */ public static function getMySQLDB() { if (self::$mySQLConnection === NULL) { self::$mySQLConnection = new PDO(PHPUNIT_TESTSUITE_EXTENSION_DATABASE_MYSQL_DSN, PHPUNIT_TESTSUITE_EXTENSION_DATABASE_MYSQL_USERNAME, PHPUNIT_TESTSUITE_EXTENSION_DATABASE_MYSQL_PASSWORD); self::setUpMySQLDatabase(self::$mySQLConnection); } return self::$mySQLConnection; } protected static function setUpDatabase(PDO $connection) { $connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $connection->exec( 'CREATE TABLE IF NOT EXISTS table1 ( table1_id INTEGER PRIMARY KEY AUTOINCREMENT, column1 VARCHAR(20), column2 INT(10), column3 DECIMAL(6,2), column4 TEXT )' ); $connection->exec( 'CREATE TABLE IF NOT EXISTS table2 ( table2_id INTEGER PRIMARY KEY AUTOINCREMENT, column5 VARCHAR(20), column6 INT(10), column7 DECIMAL(6,2), column8 TEXT )' ); $connection->exec( 'CREATE TABLE IF NOT EXISTS table3 ( table3_id INTEGER PRIMARY KEY AUTOINCREMENT, column9 VARCHAR(20), column10 INT(10), column11 DECIMAL(6,2), column12 TEXT )' ); } /** * Creates default testing schema for MySQL database * * Tables must containt foreign keys and use InnoDb storage engine * for constraint tests to be executed properly * * @param PDO $connection PDO instance representing connection to MySQL database * @see DBUnitTestUtility::getMySQLDB() */ protected static function setUpMySqlDatabase(PDO $connection) { $connection->exec( 'CREATE TABLE IF NOT EXISTS table1 ( table1_id INTEGER AUTO_INCREMENT, column1 VARCHAR(20), column2 INT(10), column3 DECIMAL(6,2), column4 TEXT, PRIMARY KEY (table1_id) ) ENGINE=INNODB; '); $connection->exec( 'CREATE TABLE IF NOT EXISTS table2 ( table2_id INTEGER AUTO_INCREMENT, table1_id INTEGER, column5 VARCHAR(20), column6 INT(10), column7 DECIMAL(6,2), column8 TEXT, PRIMARY KEY (table2_id), FOREIGN KEY (table1_id) REFERENCES table1(table1_id) ) ENGINE=INNODB; '); $connection->exec( 'CREATE TABLE IF NOT EXISTS table3 ( table3_id INTEGER AUTO_INCREMENT, table2_id INTEGER, column9 VARCHAR(20), column10 INT(10), column11 DECIMAL(6,2), column12 TEXT, PRIMARY KEY (table3_id), FOREIGN KEY (table2_id) REFERENCES table2(table2_id) ) ENGINE=INNODB; '); } } dbunit-2.0.2/tests/_files/XmlDataSets/000077500000000000000000000000001261611365500176025ustar00rootroot00000000000000dbunit-2.0.2/tests/_files/XmlDataSets/AllEmptyTableInsertResult.xml000066400000000000000000000012221261611365500254040ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/AllEmptyTableInsertTest.xml000066400000000000000000000001121261611365500250420ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/DeleteAllOperationTest.xml000066400000000000000000000002231261611365500246750ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/DeleteOperationResult.xml000066400000000000000000000007131261611365500246070ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/DeleteOperationTest.xml000066400000000000000000000001661261611365500242520ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/EmptyTableInsertResult.xml000066400000000000000000000016161261611365500247620ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/EmptyTableInsertTest.xml000066400000000000000000000005061261611365500244200ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/FilteredTestComparison.xml000066400000000000000000000012221261611365500247520ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/FilteredTestFixture.xml000066400000000000000000000007551261611365500243000ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/FlatXmlDataSet.xml000066400000000000000000000011361261611365500231420ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/FlatXmlWriter.xml000066400000000000000000000010101261611365500230600ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/FlatXmlWriterEntities.xml000066400000000000000000000002651261611365500246000ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/InsertOperationResult.xml000066400000000000000000000017711261611365500246560ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/InsertOperationTest.xml000066400000000000000000000006431261611365500243140ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/MysqlXmlDataSet.xml000066400000000000000000000033161261611365500233630ustar00rootroot00000000000000 1 tgfahgasdf 200 34.64 yghkf;a hahfg8ja h; 2 hk;afg 654 46.54 24rwehhads 3 ha;gyt 462 1654.4 asfgklg 1 fhah 456 46.5 fsdbghfdas 2 asdhfoih 654 43asdfhgj 3 ajsdlkfguitah 654 dbunit-2.0.2/tests/_files/XmlDataSets/OperationsMySQLTestFixture.xml000066400000000000000000000012761261611365500255520ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/OperationsTestFixture.xml000066400000000000000000000012221261611365500246530ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/QueryDataSetTest.xml000066400000000000000000000007641261611365500235460ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/ReplaceOperationResult.xml000066400000000000000000000020001261611365500247470ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/ReplaceOperationTest.xml000066400000000000000000000013201261611365500244140ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/RowBasedExecute.xml000066400000000000000000000005111261611365500233520ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/TruncateCompositeTest.xml000066400000000000000000000023021261611365500246310ustar00rootroot00000000000000
table1_idcolumn1column2column3column4 1
table2_idtable1_idcolumn5column6column7column8 1 1
table3_idtable2_idcolumn9column10column11column12 1 1
dbunit-2.0.2/tests/_files/XmlDataSets/UpdateOperationResult.xml000066400000000000000000000013231261611365500246250ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/UpdateOperationTest.xml000066400000000000000000000006431261611365500242720ustar00rootroot00000000000000 dbunit-2.0.2/tests/_files/XmlDataSets/XmlDataSet.xml000066400000000000000000000041561261611365500223400ustar00rootroot00000000000000 table1_idcolumn1column2column3column4 1 tgfahgasdf 200 34.64 yghkf;a hahfg8ja h; 2 hk;afg 654 46.54 24rwehhads 3 ha;gyt 462 1654.4 asfgklg
table2_idcolumn5column6column7column8 1 fhah 456 46.5 fsdbghfdas 2 asdhfoih 654 43asdfhgj 3 ajsdlkfguitah 654
dbunit-2.0.2/tests/_files/XmlDataSets/XmlWriter.xml000066400000000000000000000012461261611365500222640ustar00rootroot00000000000000 col1col2col3 val1 val2 val3 val4 val5 val6 val7
col1col2col3
 dbunit-2.0.2/tests/_files/XmlDataSets/XmlWriterEntities.xml000066400000000000000000000004721261611365500237710ustar00rootroot00000000000000 col1col2 1 <?xml version="1.0"?><myxml>test</myxml>
dbunit-2.0.2/tests/_files/YamlDataSets/000077500000000000000000000000001261611365500177445ustar00rootroot00000000000000dbunit-2.0.2/tests/_files/YamlDataSets/testDataSet.yaml000066400000000000000000000014101261611365500230510ustar00rootroot00000000000000table1: - table1_id: 1 column1: "tgfahgasdf" column2: 200 column3: 34.64 column4: "yghkf;a hahfg8ja h;" - table1_id: 2 column1: "hk;afg" column2: 654 column3: 46.54 column4: 24rwehhads extraColumn: 'causes no worries' - table1_id: 3 column1: ha;gyt column2: 462 column3: 1654.4 column4: asfgklg table2: - table2_id: 1 column5: fhah column6: 456 column7: 46.5 column8: "fsdb, ghfdas" - table2_id: 2 column5: asdhfoih column6: 654 column7: blah column8: "43asd \"fhgj\" sfadh" - table2_id: 3 column5: ajsdlkfguitah column6: 654 column7: blah column8: |- thesethasdl asdflkjsadf asdfsadfhl "adsf, halsdf" sadfhlasdf emptyTable: