StefanoTreeTest\Integration\Adapter\AdapterTestAbstract

Complexity

Total Complexity

34

Size/Duplication

Total Lines	354
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	tearDown()	0	5	1
	getAdapter()	0	1	?
A	getDataSet()	0	4	1
A	testLockTreeDoesNotFail()	0	5	1
A	testDbTransactionDoesNotFail()	0	12	1
A	testUpdateData()	0	7	1
A	testUpdateDataDoesNotChangeMetadata()	0	15	1
A	testInsertData()	0	9	1
A	testInsertDataDoesNotChangeMetadata()	0	17	1
A	testDeleteBranch()	0	7	1
A	testMoveLeftIndexes()	0	7	1
A	testMoveRightIndexes()	0	7	1
A	testUpdateParentId()	0	7	1
A	testUpdateLevels()	0	7	1
A	testMoveBranch()	0	7	1
A	testGetRoots()	0	8	1
A	testGetRoot()	0	8	1
A	testGetNodeReturnNullIfNodeDoesNotExist()	0	6	1
A	testGetNode()	0	8	1
A	testGetNodeInfoReturnNullIfNodeInfoDoesNotExist()	0	6	1
A	testGetNodeInfo()	0	11	1
A	testGetChildrenNodeInfoReturnEmptyArrayIfNodeDoesNotHaveChildrenNodes()	0	7	1
A	testGetChildrenNodeInfo()	0	21	1
A	testUpdateNodeMetadata()	0	9	1
A	testGetAncestorsReturnEmptyArrayIfNodeDoestNotExist()	0	7	1
A	testGetAncestors()	0	10	1
A	testGetAncestorsFromLevel()	0	10	1
A	testGetAncestorsExcludeLastNode()	0	18	1
A	testGetDescendantsReturnEmptyArrayIfNodeDoesNotExist()	0	7	1
A	testGetDescendants()	0	10	1
A	testGetDescendantsDefinedNodeId()	0	10	1
A	testGetDescendantsFromLevel()	0	10	1
A	testGetDescendantsFixLevels()	0	10	1
A	testGetDescendantsExcludeBranch()	0	10	1

<?php

declare(strict_types=1);

namespace StefanoTreeTest\Integration\Adapter;

use StefanoTree\NestedSet\Adapter\AdapterInterface as TreeAdapterInterface;
use StefanoTree\NestedSet\NodeInfo;
use StefanoTreeTest\IntegrationTestCase;

abstract class AdapterTestAbstract extends IntegrationTestCase
{
    /**
     * @var TreeAdapterInterface
     */
    protected $adapter;

    protected function setUp()
    {
        $this->adapter = $this->getAdapter();

        parent::setUp();
    }

    protected function tearDown()
    {
        $this->adapter = null;
        parent::tearDown();
    }

    /**
     * @return TreeAdapterInterface
     */
    abstract protected function getAdapter();

    protected function getDataSet()
    {
        return $this->createMySQLXMLDataSet(__DIR__.'/_files/adapter/initDataSet.xml');
    }

    public function testLockTreeDoesNotFail()
    {
        $this->adapter
            ->lockTree();
    }

    public function testDbTransactionDoesNotFail()
    {
        $this->adapter
            ->beginTransaction();
        $this->adapter
            ->commitTransaction();

        $this->adapter
            ->beginTransaction();
        $this->adapter
            ->rollbackTransaction();
    }

    public function testUpdateData()
    {
        $this->adapter
            ->update(2, array('name' => 'changed'));

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testUpdateData.xml');
    }

    public function testUpdateDataDoesNotChangeMetadata()
    {
        $data = array(
            'name' => 'changed',
            'lft' => 'a',
            'rgt' => 'b',
            'parent_id' => 'c',
            'level' => 'd',
        );

        $this->adapter
            ->update(2, $data);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testUpdateData.xml');
    }

    public function testInsertData()
    {
        $nodeInfo = new NodeInfo(null, 6, 100, 1000, 1001, null);

        $this->adapter
            ->insert($nodeInfo, array('name' => 'some-name'));

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testInsertData.xml');
    }

    public function testInsertDataDoesNotChangeMetadata()
    {
        $nodeInfo = new NodeInfo(null, 6, 100, 1000, 1001, null);

        $data = array(
            'name' => 'some-name',
            'lft' => 'a',
            'rgt' => 'b',
            'parent_id' => 'c',
            'level' => 'd',
        );

        $this->adapter
            ->insert($nodeInfo, $data);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testInsertData.xml');
    }

    public function testDeleteBranch()
    {
        $this->adapter
            ->delete(3);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testDeleteBranch.xml');
    }

    public function testMoveLeftIndexes()
    {
        $this->adapter
            ->moveLeftIndexes(12, 500);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testMoveLeftIndexes.xml');
    }

    public function testMoveRightIndexes()
    {
        $this->adapter
            ->moveRightIndexes(15, 500);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testMoveRightIndexes.xml');
    }

    public function testUpdateParentId()
    {
        $this->adapter
            ->updateParentId(3, 22);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testUpdateParentId.xml');
    }

    public function testUpdateLevels()
    {
        $this->adapter
            ->updateLevels(16, 35, 500);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testUpdateLevels.xml');
    }

    public function testMoveBranch()
    {
        $this->adapter
            ->moveBranch(17, 32, 500);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testMoveBranch.xml');
    }

    public function testGetRoots()
    {
        $roots = $this->adapter
            ->getRoots();

        $expected = include __DIR__.'/_files/adapter/testGetRoots.php';
        $this->assertEquals($expected, $roots);
    }

    public function testGetRoot()
    {
        $roots = $this->adapter
            ->getRoot();

        $expected = include __DIR__.'/_files/adapter/testGetRoot.php';
        $this->assertEquals($expected, $roots);
    }

    public function testGetNodeReturnNullIfNodeDoesNotExist()
    {
        $node = $this->adapter
            ->getNode(1000000);
        $this->assertNull($node);
    }

    public function testGetNode()
    {
        $node = $this->adapter
            ->getNode(11);

        $expected = include __DIR__.'/_files/adapter/testGetNode.php';
        $this->assertEquals($expected, $node);
    }

    public function testGetNodeInfoReturnNullIfNodeInfoDoesNotExist()
    {
        $nodeInfo = $this->adapter
            ->getNodeInfo(10000000);
        $this->assertNull($nodeInfo);
    }

    public function testGetNodeInfo()
    {
        $nodeInfo = $this->adapter
            ->getNodeInfo(10);

        $this->assertEquals($nodeInfo->getId(), 10);
        $this->assertEquals($nodeInfo->getParentId(), 5);
        $this->assertEquals($nodeInfo->getLeft(), 4);
        $this->assertEquals($nodeInfo->getRight(), 11);
        $this->assertEquals($nodeInfo->getLevel(), 3);
    }

    public function testGetChildrenNodeInfoReturnEmptyArrayIfNodeDoesNotHaveChildrenNodes()
    {
        $nodeInfo = $this->adapter
            ->getChildrenNodeInfo(7);

        $this->assertEquals(array(), $nodeInfo);
    }

    public function testGetChildrenNodeInfo()
    {
        $nodeInfo = $this->adapter
            ->getChildrenNodeInfo(4);

        $this->assertCount(2, $nodeInfo);

        // check first node info
        $this->assertEquals($nodeInfo[0]->getId(), 8);
        $this->assertEquals($nodeInfo[0]->getParentId(), 4);
        $this->assertEquals($nodeInfo[0]->getLeft(), 37);
        $this->assertEquals($nodeInfo[0]->getRight(), 38);
        $this->assertEquals($nodeInfo[0]->getLevel(), 2);

        // check second node info
        $this->assertEquals($nodeInfo[1]->getId(), 9);
        $this->assertEquals($nodeInfo[1]->getParentId(), 4);
        $this->assertEquals($nodeInfo[1]->getLeft(), 39);
        $this->assertEquals($nodeInfo[1]->getRight(), 48);
        $this->assertEquals($nodeInfo[1]->getLevel(), 2);
    }

    public function testUpdateNodeMetadata()
    {
        $nodeInfo = new NodeInfo(2, 100, 101, 102, 103, null);

        $this->adapter
            ->updateNodeMetadata($nodeInfo);

        $this->assertCompareDataSet(array('tree_traversal'), __DIR__.'/_files/adapter/testUpdateNodeMetadata.xml');
    }

    public function testGetAncestorsReturnEmptyArrayIfNodeDoestNotExist()
    {
        $path = $this->adapter
            ->getAncestors(1000);

        $this->assertEquals(array(), $path);
    }

    public function testGetAncestors()
    {
        $path = $this->adapter
            ->getAncestors(10);

        $this->assertCount(4, $path);

        $expected = include __DIR__.'/_files/adapter/testGetAncestors.php';
        $this->assertEquals($expected, $path);
    }

    public function testGetAncestorsFromLevel()
    {
        $path = $this->adapter
            ->getAncestors(10, 2);

        $this->assertCount(2, $path);

        $expected = include __DIR__.'/_files/adapter/testGetAncestorsStartFromLevel.php';
        $this->assertEquals($expected, $path);
    }

    public function testGetAncestorsExcludeLastNode()
    {
        // test exclude last node
        $path = $this->adapter
            ->getAncestors(10, 0, 1);

        $this->assertCount(3, $path);
        $expected = include __DIR__.'/_files/adapter/testGetAncestorsExcludeLastNode.php';
        $this->assertEquals($expected, $path);

        // test exclude last two node
        $path = $this->adapter
            ->getAncestors(10, 0, 2);

        $this->assertCount(2, $path);
        $expected = include __DIR__.'/_files/adapter/testGetAncestorsExcludeTwoLastNode.php';
        $this->assertEquals($expected, $path);
    }

    public function testGetDescendantsReturnEmptyArrayIfNodeDoesNotExist()
    {
        $nodes = $this->adapter
            ->getDescendants(1000);

        $this->assertEquals(array(), $nodes);
    }

    public function testGetDescendants()
    {
        $nodes = $this->adapter
            ->getDescendants(1);

        $this->assertCount(25, $nodes);

        $expected = include __DIR__.'/_files/adapter/testGetDescendants.php';
        $this->assertEquals($expected, $nodes);
    }

    public function testGetDescendantsDefinedNodeId()
    {
        $nodes = $this->adapter
            ->getDescendants(6);

        $this->assertCount(8, $nodes);

        $expected = include __DIR__.'/_files/adapter/testGetDescendantsDefinedNodeId.php';
        $this->assertEquals($expected, $nodes);
    }

    public function testGetDescendantsFromLevel()
    {
        $nodes = $this->adapter
            ->getDescendants(6, 2);

        $this->assertCount(5, $nodes);

        $expected = include __DIR__.'/_files/adapter/testGetDescendantsFromLevel.php';
        $this->assertEquals($expected, $nodes);
    }

    public function testGetDescendantsFixLevels()
    {
        $nodes = $this->adapter
            ->getDescendants(6, 2, 2);

        $this->assertCount(3, $nodes);

        $expected = include __DIR__.'/_files/adapter/testGetDescendantsFixLevels.php';
        $this->assertEquals($expected, $nodes);
    }

    public function testGetDescendantsExcludeBranch()
    {
        $nodes = $this->adapter
            ->getDescendants(1, 0, null, 9);

        $this->assertCount(20, $nodes);

        $expected = include __DIR__.'/_files/adapter/testGetDescendantsExcludeBranch.php';
        $this->assertEquals($expected, $nodes);
    }
}