Graze\DataNode\Test\Unit\NodeCollectionTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	testIsCollection()	0	3	1
A	testToString()	0	4	1
A	testFirstWithCallbackWillReturnDefaultIfNoMatchesAreFound()	0	18	1
A	testCallingApplyWillModifyTheContentsUsingReference()	0	16	1
A	testCloneWillCloneTheChildObjects()	0	12	2
A	testCanAddADataNode()	0	5	1
A	testLastWithCallbackWillReturnDefaultIfNoMatchesAreFound()	0	18	1
A	testCallingApplyWillModifyTheContentsUsingReturnValue()	0	17	1
A	testAddingANonDataNodeWillThrowAnException()	0	8	1
A	testLastWithCallbackWillReturnTheFirstThatMatches()	0	17	1
A	testLastWithNoCallbackWillReturnTheFirstEntry()	0	8	1
A	testFirstWithNoCallbackWillReturnTheFirstEntry()	0	8	1
A	testFirstWithCallbackWillReturnTheFirstThatMatches()	0	17	1

<?php
/**
 * This file is part of graze/data-node
 *
 * Copyright (c) 2016 Nature Delivered Ltd. <https://www.graze.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license https://github.com/graze/data-node/blob/master/LICENSE.md
 * @link    https://github.com/graze/data-node
 */

namespace Graze\DataNode\Test\Unit;

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

class NodeCollectionTest extends AbstractTestCase
{
    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()
    {
        $node = m::mock(NodeInterface::class);
        $node->shouldReceive('someMethod')

The call to Mockery\MockInterface::shouldReceive() has too many arguments starting with '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()
    {
        $node = m::mock(NodeInterface::class);
        $node->shouldReceive('someMethod')

The call to Mockery\MockInterface::shouldReceive() has too many arguments starting with '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()
    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);

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

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

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

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

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

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

        $first->shouldReceive('thisOne')

The call to Mockery\MockInterface::shouldReceive() has too many arguments starting with '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()
    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);
        $third = m::mock(NodeInterface::class);

        $first->shouldReceive('thisOne')

The call to Mockery\MockInterface::shouldReceive() has too many arguments starting with '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()
    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);
        $default = m::mock(NodeInterface::class);

        $first->shouldReceive('thisOne')

The call to Mockery\MockInterface::shouldReceive() has too many arguments starting with '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()
    {
        $first = m::mock(NodeInterface::class);
        $second = m::mock(NodeInterface::class);
        $default = m::mock(NodeInterface::class);

        $first->shouldReceive('thisOne')

The call to Mockery\MockInterface::shouldReceive() has too many arguments starting with '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");
    }
}