Crate\Test\DBAL\Functional\WriteTest

Complexity

Total Complexity

15

Size/Duplication

Total Lines	174
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	1

<?php
class WriteTest extends DBALFunctionalTestCase
{
    static private $generated = false;

    public function setUp() : void
    {
        parent::setUp();

        if (self::$generated === false) {
            self::$generated = true;
            /* @var $sm \Doctrine\DBAL\Schema\AbstractSchemaManager */
            $table = new \Doctrine\DBAL\Schema\Table("write_table");
            $table->addColumn('test_int', Type::INTEGER);
            $table->addColumn('test_string', Type::STRING);
            $table->addColumn('test_float', Type::FLOAT);
            $table->addColumn('test_array', Type::TARRAY, array('columnDefinition'=>'ARRAY(STRING)'));
            $table->addColumn("test_map", MapType::NAME);
            $table->addColumn("test_bool", Type::BOOLEAN);

            $platformOptions = array(
                'type'   => MapType::STRICT,
                'fields' => array(
                    new Column('id',    Type::getType(Type::INTEGER), array()),
                    new Column('name',  Type::getType(Type::STRING), array()),
                    new Column('value', Type::getType(Type::FLOAT), array()),
                ),
            );
            $table->addColumn('test_obj', MapType::NAME, array('platformOptions'=>$platformOptions));

            $sm = $this->_conn->getSchemaManager();
            $sm->createTable($table);
        }
    }

    public function tearDown() : void
    {
        if (self::$generated === true) {
            $this->execute('drop table write_table');
            self::$generated = false;
        }
    }


    /**
     * @group DBAL-80
     */
    public function testExecuteUpdateFirstTypeIsNull()
    {
        $sql = "INSERT INTO write_table (test_string, test_int) VALUES (?, ?)";
        $this->_conn->executeUpdate($sql, array("text", 1111), array(null, PDO::PARAM_INT));
        $this->refresh('write_table');

        $sql = "SELECT test_obj, test_string, test_int FROM write_table WHERE test_string = ? AND test_int = ?";
        $this->assertEquals($this->_conn->fetchColumn($sql, array("text", 1111)), null);
        $this->assertEquals($this->_conn->fetchColumn($sql, array("text", 1111), 1), "text");
        $this->assertEquals($this->_conn->fetchColumn($sql, array("text", 1111), 2), 1111);
    }

    public function testExecuteUpdate()
    {
        $sql = "INSERT INTO write_table (test_int) VALUES ( " . $this->_conn->quote(1, PDO::PARAM_INT) . ")";
        $affected = $this->_conn->executeUpdate($sql);

        $this->assertEquals(1, $affected, "executeUpdate() should return the number of affected rows!");
    }

    public function testExecuteUpdateWithTypes()
    {
        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
        $affected = $this->_conn->executeUpdate($sql, array(1, 'foo'), array(\PDO::PARAM_INT, \PDO::PARAM_STR));

        $this->assertEquals(1, $affected, "executeUpdate() should return the number of affected rows!");
    }

    public function testPrepareRowCountReturnsAffectedRows()
    {
        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
        $stmt = $this->_conn->prepare($sql);

        $stmt->bindValue(1, 1);
        $stmt->bindValue(2, "foo");
        $stmt->execute();

        $this->assertEquals(1, $stmt->rowCount());
    }

    public function testPrepareWithPdoTypes()
    {
        $sql = "INSERT INTO write_table (test_int, test_string) VALUES (?, ?)";
        $stmt = $this->_conn->prepare($sql);

        $stmt->bindValue(1, 1, \PDO::PARAM_INT);
        $stmt->bindValue(2, "foo", \PDO::PARAM_STR);
        $stmt->execute();

        $this->assertEquals(1, $stmt->rowCount());
    }

    public function testPrepareWithDbalTypes()
    {
        $sql = "INSERT INTO write_table (test_int, test_string, test_float, test_obj) VALUES (?, ?, ?, ?)";
        $stmt = $this->_conn->prepare($sql);

        $stmt->bindValue(1, 1, Type::getType('integer'));
        $stmt->bindValue(2, "foo", Type::getType('string'));
        $stmt->bindValue(3, 3.141592, Type::getType('float'));
        $stmt->bindValue(4, array('id'=>1, 'name'=>'christian', 'value'=>1.234), Type::getType('map'));
        $stmt->execute();

        $this->assertEquals(1, $stmt->rowCount());
    }

    public function testPrepareWithDbalTypeNames()
    {
        $sql = "INSERT INTO write_table (test_int, test_string, test_float, test_map, test_bool) VALUES (?, ?, ?, ?, ?)";
        $stmt = $this->_conn->prepare($sql);

        $stmt->bindValue(1, 1, 'integer');
        $stmt->bindValue(2, "foo", 'string');
        $stmt->bindValue(3, 3.141592, 'float');
        $stmt->bindValue(4, array('id'=>1, 'name'=>'christian', 'value'=>1.234), 'map');
        $stmt->bindValue(5, true, 'boolean');
        $stmt->execute();

        $this->assertEquals(1, $stmt->rowCount());
    }

    public function insertRows()
    {
        $this->assertEquals(1, $this->_conn->insert('write_table', array(
            'test_int' => 1,
            'test_string' => 'foo',
            'test_float' => 1.234,
            'test_array' => array('foo','bar'),
            'test_obj' => array('id'=>1, 'name'=>'foo', 'value'=>1.234),
        ), array('integer','string','float','array','map')));
        $this->assertEquals(1, $this->_conn->insert('write_table', array(
            'test_int' => 2,
            'test_string' => 'bar',
            'test_float' => 2.345,
            'test_array' => array('bar','foo'),
            'test_obj' => array('id'=>2, 'name'=>'bar', 'value'=>2.345),
        ), array('integer','string','float','array','map')));

        $this->refresh('write_table');
    }

    public function testInsert()
    {
        $this->insertRows();
    }

    public function testDelete()
    {
        $this->insertRows();

        $this->assertEquals(1, $this->_conn->delete('write_table', array('test_int' => 2)));
        $this->refresh('write_table');
        $this->assertEquals(1, count($this->_conn->fetchAll('SELECT * FROM write_table')));

        $this->assertEquals(1, $this->_conn->delete('write_table', array('test_int' => 1)));
        $this->refresh('write_table');
        $this->assertEquals(0, count($this->_conn->fetchAll('SELECT * FROM write_table')));
    }

    public function testUpdate()
    {
        $this->insertRows();

        $this->assertEquals(1, $this->_conn->update('write_table', array('test_string' => 'bar'), array('test_string' => 'foo')));
        $this->refresh('write_table');
        $this->assertEquals(2, $this->_conn->update('write_table', array('test_string' => 'baz'), array('test_string' => 'bar')));
        $this->refresh('write_table');
        $this->assertEquals(0, $this->_conn->update('write_table', array('test_string' => 'baz'), array('test_string' => 'bar')));
    }