PdoClientTest::delete() - Code Metrics - Inspection of "add code analisys to scrutinizer" - hgraca/php-micro-orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — master (754829)

by Herberto
created 2016-12-11 16:23 UTC
PdoClientTest::delete() A

↳ Parent: PdoClientTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	23
Code Lines	17
Duplication

Lines	23
Ratio	100 %
Importance

Changes
Metric	Value
dl	23
loc	23
rs	9.0856
c	0
b	0
f	0
cc	1
eloc	17
nc	1
nop	0
<?php

namespace Hgraca\MicroOrm\Test\Repository\Client;

use Hgraca\Helper\InstanceHelper;
use Hgraca\MicroOrm\DataSource\Pdo\PdoClient;
use Hgraca\MicroOrm\Test\Stub\Bar;
use Hgraca\MicroOrm\Test\Stub\Foo;
use Mockery;
use Mockery\MockInterface;
use PDO;
use PDOStatement;
use PHPUnit_Framework_TestCase;

final class PdoClientTest extends PHPUnit_Framework_TestCase
{
    /** @var MockInterface|PDO */
    private $pdo;

    /** @var PdoClient */
    private $client;

    /**
     * @before
     */
    protected function setUpClient()
    {
        $this->pdo    = Mockery::mock(PDO::class);
        $this->client = new PdoClient($this->pdo);
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::select
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlFilter
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlOrderBy
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function select()
    {
        $table = 'DummyTable';
        $filter = [
            'propA' => true,
            'propB' => null,
        ];
        $orderBy = [
            'propA' => 'ASC',
            'propB' => 'DESC',
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->once()
            ->with('SELECT * FROM `DummyTable` WHERE `propA`=:propA_filter AND `propB` IS :propB_filter ORDER BY propA ASC, propB DESC')
            ->andReturn($pdoStatementMock);

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propA_filter', $filter['propA'], PDO::PARAM_BOOL)->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propB_filter', $filter['propB'], PDO::PARAM_NULL)->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('fetchAll')->once()->with(PDO::FETCH_ASSOC)->andReturn(
            $expectedResult = [
                ['propA' => 1, 'propB' => 2],
                ['propA' => 3, 'propB' => 4],
            ]
        );

        self::assertEquals($expectedResult, $this->client->select($table, $filter, $orderBy));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::select
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlFilter
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlOrderBy
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function select_WithNoFilter()
    {
        $table   = 'DummyTable';
        $filter  = [];
        $orderBy = [
            'propA' => 'ASC',
            'propB' => 'DESC',
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->once()
            ->with('SELECT * FROM `DummyTable` ORDER BY propA ASC, propB DESC')
            ->andReturn($pdoStatementMock);

        $pdoStatementMock->shouldNotReceive('bindValue');

        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('fetchAll')->once()->with(PDO::FETCH_ASSOC)->andReturn(
            $expectedResult = [
                ['propA' => 1, 'propB' => 2],
                ['propA' => 3, 'propB' => 4],
            ]
        );

        self::assertEquals($expectedResult, $this->client->select($table, $filter, $orderBy));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::select
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlFilter
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlOrderBy
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function select_WithNoOrderBy()
    {
        $table   = 'DummyTable';
        $filter  = [
            'propA' => true,
            'propB' => null,
        ];
        $orderBy = [];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->once()
            ->with('SELECT * FROM `DummyTable` WHERE `propA`=:propA_filter AND `propB` IS :propB_filter')
            ->andReturn($pdoStatementMock);

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propA_filter', $filter['propA'], PDO::PARAM_BOOL)->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propB_filter', $filter['propB'], PDO::PARAM_NULL)->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('fetchAll')->once()->with(PDO::FETCH_ASSOC)->andReturn(
            $expectedResult = [
                ['propA' => 1, 'propB' => 2],
                ['propA' => 3, 'propB' => 4],
            ]
        );

        self::assertEquals($expectedResult, $this->client->select($table, $filter, $orderBy));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::insert
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createInsertSql
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlFilter
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function insert()

    {
        $table  = 'DummyTable';
        $data = [
            'propA' => true,
            'propB' => null,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->once()
            ->with('INSERT INTO `DummyTable` (`propA`, `propB`) VALUES (:propA, :propB)')
            ->andReturn($pdoStatementMock);

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propA', $data['propA'], PDO::PARAM_BOOL)->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propB', $data['propB'], PDO::PARAM_NULL)->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('rowCount')->once()->andReturn($rowCount = 1);

        self::assertEquals($rowCount, $this->client->insert($table, $data));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::update
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createUpdateSql
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlFilter
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function update()
    {
        $table  = 'DummyTable';
        $data = [
            'propC' => true,
        ];
        $filter = [
            'propA' => true,
            'propB' => null,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->once()
            ->with('UPDATE `DummyTable` SET `propC`=:propC WHERE `propA`=:propA_filter AND `propB` IS :propB_filter')
            ->andReturn($pdoStatementMock);

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propA_filter', $filter['propA'], PDO::PARAM_BOOL)->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propB_filter', $filter['propB'], PDO::PARAM_NULL)->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propC', $data['propC'], PDO::PARAM_BOOL)->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('rowCount')->once()->andReturn($rowCount = 1);

        self::assertEquals($rowCount, $this->client->update($table, $filter, $data));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::delete
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::createSqlFilter
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function delete()

    {
        $table           = 'DummyTable';
        $filter = [
            'propA' => true,
            'propB' => 3,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->once()
            ->with('DELETE FROM `DummyTable` WHERE `propA`=:propA_filter AND `propB`=:propB_filter')
            ->andReturn($pdoStatementMock);

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propA_filter', $filter['propA'], PDO::PARAM_BOOL)->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()->with(':propB_filter', $filter['propB'], PDO::PARAM_INT)->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('rowCount')->once()->andReturn($rowCount = 1);

        self::assertEquals($rowCount, $this->client->delete($table, $filter));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::executeQuery
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::fetchData
     */
    public function executeQuery_ReturnsArray()
    {
        $sql           = 'some dummy sql';
        $parameterList = [
            'trueVal' => true,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')->once()->with($sql)->andReturn($pdoStatementMock);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':trueVal_filter', $parameterList['trueVal'], PDO::PARAM_BOOL)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('fetchAll')->once()->with(PDO::FETCH_ASSOC)->andReturn(
            $expectedResult = [
                ['propA' => 1, 'propB' => 2],
                ['propA' => 3, 'propB' => 4],
            ]
        );

        self::assertEquals($expectedResult, $this->client->executeQuery($sql, $parameterList));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::executeQuery
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::fetchData
     */
    public function executeQuery_ReturnsObjects()
    {
        $sql           = 'some dummy sql';
        $parameterList = [
            'trueVal' => true,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')->once()->with($sql)->andReturn($pdoStatementMock);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':trueVal_filter', $parameterList['trueVal'], PDO::PARAM_BOOL)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $classFqcn = Bar::class;
        $pdoStatementMock->shouldReceive('fetchAll')->once()->with(PDO::FETCH_CLASS, $classFqcn)->andReturn(
            $expectedResult = [
                $obj1 = new Bar(),
                $obj2 = new Bar(),
            ]
        );
        InstanceHelper::setProtectedProperty($obj1, 'propA', 1);
        InstanceHelper::setProtectedProperty($obj1, 'propB', 2);
        InstanceHelper::setProtectedProperty($obj2, 'propA', 3);
        InstanceHelper::setProtectedProperty($obj2, 'propB', 4);

        self::assertEquals($expectedResult, $this->client->executeQuery($sql, $parameterList, $classFqcn));
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::executeCommand
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::execute
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::resolvePdoType
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function executeCommand()
    {
        $sql           = 'some dummy sql';
        $parameterList = [
            'trueVal'   => true,
            'stringVal' => 'some string',
            'intVal'    => 1,
            'floatVal'  => 1.5,
            'nullVal'   => null,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')->once()->with($sql)->andReturn($pdoStatementMock);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':trueVal_filter', $parameterList['trueVal'], PDO::PARAM_BOOL)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':stringVal_filter', $parameterList['stringVal'], PDO::PARAM_STR)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':intVal_filter', $parameterList['intVal'], PDO::PARAM_INT)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':floatVal_filter', strval($parameterList['floatVal']), PDO::PARAM_STR)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':nullVal_filter', $parameterList['nullVal'], PDO::PARAM_NULL)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(true);
        $pdoStatementMock->shouldReceive('rowCount')->once()->andReturn($rowCount = 1);

        self::assertEquals($rowCount, $this->client->executeCommand($sql, $parameterList));
    }

    /**
     * @test
     *
     * @small
     *
     * @expectedException \Hgraca\MicroOrm\DataSource\Exception\BindingMicroOrmException
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::executeCommand
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::execute
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::bindParameterList
     */
    public function executeCommand_ShouldThrowExceptionIfCantBind()
    {
        $sql           = 'some dummy sql';
        $filterList = [
            'trueVal' => true,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')->once()->with($sql)->andReturn($pdoStatementMock);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':trueVal_filter', $filterList['trueVal'], PDO::PARAM_BOOL)
            ->andReturn(false);

        $this->client->executeCommand($sql, $filterList);
    }

    /**
     * @test
     *
     * @small
     *
     * @expectedException \Hgraca\MicroOrm\DataSource\Exception\ExecutionMicroOrmException
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::executeCommand
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::execute
     */
    public function executeCommand_ShouldThrowExceptionIfCantExecute()
    {
        $sql           = 'some dummy sql';
        $parameterList = [
            'trueVal' => true,
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')->once()->with($sql)->andReturn($pdoStatementMock);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $pdoStatementMock->shouldReceive('bindValue')
            ->once()
            ->with(':trueVal_filter', $parameterList['trueVal'], PDO::PARAM_BOOL)
            ->andReturn(true);
        $pdoStatementMock->shouldReceive('execute')->once()->andReturn(false);
        $pdoStatementMock->shouldReceive('errorCode')->once()->andReturn('123');
        $pdoStatementMock->shouldReceive('errorInfo')->once()->andReturn(['some error info']);

        $this->client->executeCommand($sql, $parameterList);
    }

    /**
     * @test
     *
     * @small
     *
     * @expectedException \Hgraca\MicroOrm\DataSource\Exception\TypeResolutionMicroOrmException
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::executeCommand
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::execute
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::resolvePdoType
     */
    public function executeCommand_ShouldThrowExceptionIfCantResolvePdoType()
    {
        $sql           = 'some dummy sql';
        $parameterList = [
            'trueVal' => new Foo(),
        ];

        $pdoStatementMock = Mockery::mock(PDOStatement::class);
        $this->pdo->shouldReceive('prepare')->once()->with($sql)->andReturn($pdoStatementMock);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $pdoStatementMock->shouldNotReceive('bindValue');


        $this->client->executeCommand($sql, $parameterList);
    }

    /**
     * @test
     *
     * @small
     *
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::__construct
     * @covers \Hgraca\MicroOrm\DataSource\Pdo\PdoClient::getLastInsertId
     */
    public function getLastInsertId()
    {
        $id = '123';
        $this->pdo->shouldReceive('lastInsertId')->once()->andReturn($id);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        self::assertEquals($id, $this->client->getLastInsertId());
    }
}

Branch — master (754829)

PdoClientTest::delete() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

hgraca / php-micro-orm

Branch — master (754829)

PdoClientTest::delete() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
