Graze\DataNode\Test\Unit\Node\NodeCollectionTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	184
Duplicated Lines	71.2 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes	3
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	testIsCollection()	0	4	1
A	testCanAddADataNode()	0	6	1
A	testAddingANonDataNodeWillThrowAnException()	0	9	1
A	testCallingApplyWillModifyTheContentsUsingReference()	17	17	1
A	testCallingApplyWillModifyTheContentsUsingReturnValue()	18	18	1
A	testFirstWithNoCallbackWillReturnTheFirstEntry()	9	9	1
A	testLastWithNoCallbackWillReturnTheFirstEntry()	9	9	1
A	testFirstWithCallbackWillReturnTheFirstThatMatches()	19	19	1
A	testLastWithCallbackWillReturnTheFirstThatMatches()	19	19	1
A	testFirstWithCallbackWillReturnDefaultIfNoMatchesAreFound()	20	20	1
A	testLastWithCallbackWillReturnDefaultIfNoMatchesAreFound()	20	20	1
A	testCloneWillCloneTheChildObjects()	0	14	2
A	testToString()	0	5	1

<?php

namespace Graze\DataNode\Test\Unit\Node;

use Graze\DataNode\NodeCollection;
use Graze\DataNode\NodeInterface;
use Graze\DataNode\Test\TestCase;
use Graze\DataStructure\Collection\Collection;
use InvalidArgumentException;
use Mockery as m;

class NodeCollectionTest extends TestCase
{
    public function testIsCollection()
    {
        static::assertInstanceOf(Collection::class, new NodeCollection());
    }

    public function testCanAddADataNode()
    {
        $collection = new NodeCollection();
        $node = m::mock(NodeInterface::class);
        static::assertSame($collection, $collection->add($node));
    }

    public function testAddingANonDataNodeWillThrowAnException()
    {
        $node = m::mock('Graze\Extensible\ExtensibleInterface');

        $this->expectException(InvalidArgumentException::class);

        $collection = new NodeCollection();
        $collection->add($node);
    }

    public function testCallingApplyWillModifyTheContentsUsingReference()

This method seems to be duplicated in your project.

    {
        $node = m::mock(NodeInterface::class);
        $node->shouldReceive('someMethod')
             ->once()
             ->andReturn(null);

        $collection = new NodeCollection();
        $collection->add($node);

        $collection->apply(function ($item) {
            $item->someMethod();
        });

        $item = $collection->getAll()[0];
        static::assertSame($node, $item);
    }

    public function testCallingApplyWillModifyTheContentsUsingReturnValue()

This method seems to be duplicated in your project.

    {
        $node = m::mock(NodeInterface::class);
        $node->shouldReceive('someMethod')
             ->once()
             ->andReturn(null);

        $collection = new NodeCollection();
        $collection->add($node);

        $collection->apply(function ($item) {
            $item->someMethod();
            return $item;
        });

        $item = $collection->getAll()[0];
        static::assertSame($node, $item);
    }

    public function testFirstWithNoCallbackWillReturnTheFirstEntry()

This method seems to be duplicated in your project.

    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);

        $collection = new NodeCollection([$first, $second]);

        static::assertSame($first, $collection->first());
    }

    public function testLastWithNoCallbackWillReturnTheFirstEntry()

This method seems to be duplicated in your project.

    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);

        $collection = new NodeCollection([$first, $second]);

        static::assertSame($second, $collection->last());
    }

    public function testFirstWithCallbackWillReturnTheFirstThatMatches()

This method seems to be duplicated in your project.

    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);
        $third = m::mock(NodeInterface::class);

        $first->shouldReceive('thisOne')
              ->andReturn(false);
        $second->shouldReceive('thisOne')
               ->andReturn(true);
        $third->shouldReceive('thosOne')
              ->andReturn(true);

        $collection = new NodeCollection([$first, $second, $third]);

        static::assertSame($second, $collection->first(function ($item) {
            return $item->thisOne();
        }));
    }

    public function testLastWithCallbackWillReturnTheFirstThatMatches()

This method seems to be duplicated in your project.

    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);
        $third = m::mock(NodeInterface::class);

        $first->shouldReceive('thisOne')
              ->andReturn(true);
        $second->shouldReceive('thisOne')
               ->andReturn(true);
        $third->shouldReceive('thisOne')
              ->andReturn(false);

        $collection = new NodeCollection([$first, $second, $third]);

        static::assertSame($second, $collection->last(function ($item) {
            return $item->thisOne();
        }));
    }

    public function testFirstWithCallbackWillReturnDefaultIfNoMatchesAreFound()

This method seems to be duplicated in your project.

    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);
        $default = m::mock(NodeInterface::class);

        $first->shouldReceive('thisOne')
              ->andReturn(false);
        $second->shouldReceive('thisOne')
               ->andReturn(false);

        $collection = new NodeCollection([$first, $second]);

        static::assertSame($default, $collection->first(function ($item) {
            return $item->thisOne();
        }, $default));
        static::assertNull($collection->first(function ($item) {
            return $item->thisOne();
        }));
    }

    public function testLastWithCallbackWillReturnDefaultIfNoMatchesAreFound()

This method seems to be duplicated in your project.

    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);
        $default = m::mock(NodeInterface::class);

        $first->shouldReceive('thisOne')
              ->andReturn(false);
        $second->shouldReceive('thisOne')
               ->andReturn(false);

        $collection = new NodeCollection([$first, $second]);

        static::assertSame($default, $collection->last(function ($item) {
            return $item->thisOne();
        }, $default));
        static::assertNull($collection->last(function ($item) {
            return $item->thisOne();
        }));
    }

    public function testCloneWillCloneTheChildObjects()
    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);

        $collection = new NodeCollection([$first, $second]);
        $collection2 = $collection->getClone();

        static::assertNotSame($collection, $collection2);
        static::assertEquals($collection->count(), $collection2->count());
        for ($i = 0; $i < $collection->count(); $i++) {
            static::assertNotSame($collection->getAll()[$i], $collection2->getAll()[$i]);
        }
    }

    public function testToString()
    {
        $collection = new NodeCollection();
        static::assertEquals("NodeCollection", "$collection");
    }
}