MenuServiceTest::testDeleteShouldThrowException() - Code Metrics - Inspection of "delete commented code" - phpsrbija/unfinished - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (4042af)

by Aleksandar

created 2017-07-02 10:29 UTC

MenuServiceTest::testDeleteShouldThrowException() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	28
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	25
nc	1
nop	0
dl	0
loc	28
rs	8.8571
c	1
b	0
f	0

<?php

declare(strict_types=1);

namespace Menu\Test\Service;

use Zend\Stdlib\ArrayObject;

class MenuServiceTest extends \PHPUnit_Framework_TestCase
{
    public function testGetNestedAllShouldReturnArray()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['selectAll', 'toArray'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('selectAll')
            ->willReturnSelf();
        $menuMapper->expects(static::once())
            ->method('toArray')
            ->willReturn([]);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertInternalType('array', $menuService->getNestedAll());
    }

    public function testGetShouldReturnArray()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['get'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('get')
            ->willReturn([]);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertInternalType('array', $menuService->get(1));
    }

    public function testAddMenuItemWithPageIdShouldReturnTrue()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuFilter->expects(static::once())
            ->method('getInputFilter')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('setData')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('isValid')
            ->willReturn(true);
        $menuFilter->expects(static::once())
            ->method('getValues')
            ->willReturn(['page_id' => 1, 'category_id' => false, 'href' => false]);
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['insertMenuItem', 'get'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('insertMenuItem')
            ->willReturn(true);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->setMethods(['getPage'])
            ->disableOriginalConstructor()
            ->getMock();
        $pageService->expects(static::once())
            ->method('getPage')
            ->willReturn(new \Page\Entity\Page());
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => false, 'href' => false]));
    }

    public function testAddMenuItemWithCategoryIdShouldReturnTrue()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuFilter->expects(static::once())
            ->method('getInputFilter')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('setData')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('isValid')
            ->willReturn(true);
        $menuFilter->expects(static::once())
            ->method('getValues')
            ->willReturn(['page_id' => false, 'category_id' => 1, 'href' => false]);
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['insertMenuItem', 'get'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('insertMenuItem')
            ->willReturn(true);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->setMethods(['getCategory'])
            ->disableOriginalConstructor()
            ->getMock();
        $categoryService->expects(static::once())
            ->method('getCategory')
            ->willReturn(new ArrayObject(['category_uuid' => 'test']));
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => false, 'href' => false]));
    }

    /**
     * @expectedExceptionMessage test error
     * @expectedException \Std\FilterException
     */
    public function testAddMenuItemWithCategoryIdShouldThrowFilterException()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->setMethods(['getInputFilter', 'setData', 'isValid', 'getMessages'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuFilter->expects(static::once())
            ->method('getInputFilter')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('setData')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('isValid')
            ->willReturn(false);
        $menuFilter->expects(static::once())
            ->method('getMessages')
            ->willReturn(['test error']);
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['get'])
            ->disableOriginalConstructor()
            ->getMock();
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => false, 'href' => false]));
    }

    /**
     * @expectedExceptionMessage You need to set only one link. Post, Category or Href.
     * @expectedException \Exception
     */
    public function testAddMenuItemWithCategoryIdShouldThrowException()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->setMethods(['getInputFilter', 'setData', 'isValid'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuFilter->expects(static::once())
            ->method('getInputFilter')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('setData')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('isValid')
            ->willReturn(true);
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['get'])
            ->disableOriginalConstructor()
            ->getMock();
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => 1, 'href' => 1]));
    }

    public function testAddMenuItemWithHrefShouldReturnTrue()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuFilter->expects(static::once())
            ->method('getInputFilter')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('setData')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('isValid')
            ->willReturn(true);
        $menuFilter->expects(static::once())
            ->method('getValues')
            ->willReturn(['page_id' => false, 'category_id' => false, 'href' => 'test']);
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['insertMenuItem', 'get'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('insertMenuItem')
            ->willReturn(true);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->addMenuItem(['page_id' => false, 'category_id' => false, 'href' => 'test']));
    }

    public function testUpdateMenuItemShouldReturnTrue()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuFilter->expects(static::once())
            ->method('getInputFilter')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('setData')
            ->willReturnSelf();
        $menuFilter->expects(static::once())
            ->method('isValid')
            ->willReturn(true);
        $menuFilter->expects(static::once())
            ->method('getValues')
            ->willReturn(['page_id' => false, 'category_id' => false, 'href' => 'test']);
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['updateMenuItem'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('updateMenuItem')
            ->willReturn(true);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->updateMenuItem(['page_id' => false, 'category_id' => false, 'href' => 'test'], 1));
    }

    public function testDeleteShouldReturnTrue()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['select', 'delete'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('select')
            ->willReturn(new \Zend\Db\ResultSet\ResultSet());
        $menuMapper->expects(static::once())
            ->method('delete')
            ->willReturn(true);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->delete(1));
    }

    /**
     * @expectedException \Exception
     * @expectedExceptionMessage This Menu Item has child items
     */
    public function testDeleteShouldThrowException()
    {
        $resultSet = $this->getMockBuilder(\Zend\Db\ResultSet\ResultSet::class)
            ->setMethods(['count'])
            ->getMockForAbstractClass();
        $resultSet->expects(static::once())
            ->method('count')
            ->willReturn(1);
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['select'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('select')
            ->willReturn($resultSet);
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->delete(1));
    }

    public function testGetForSelectShouldReturnResultSet()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['forSelect'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::once())
            ->method('forSelect')
            ->willReturn(new \Zend\Db\ResultSet\ResultSet());

        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertInstanceOf(\Zend\Db\ResultSet\ResultSet::class, $menuService->getForSelect());
    }

    public function testUpdateMenuOrderShouldReturnTrueWhenNoOrderReceived()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->disableOriginalConstructor()
            ->getMock();
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->updateMenuOrder(false));
    }

    /**
     * @expectedExceptionMessage test error
     * @expectedException \Exception
     */
    public function testUpdateMenuOrderShouldRethrowException()
    {
        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['getAdapter'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::exactly(2))
            ->method('getAdapter')
            ->willThrowException(new \Exception('test error'));
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->updateMenuOrder(true));
    }

    public function testUpdateMenuOrderShouldReturnTrue()
    {
        $child = new \stdClass();
        $child->id = 1;
        $parent = new \stdClass();
        $parent->children = [$child];
        $parent->id = 2;

        $menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
            ->setMethods(['getAdapter', 'getDriver', 'getConnection', 'beginTransaction', 'commit', 'update'])
            ->disableOriginalConstructor()
            ->getMock();
        $menuMapper->expects(static::exactly(2))
            ->method('getDriver')
            ->willReturnSelf();
        $menuMapper->expects(static::exactly(2))
            ->method('getConnection')
            ->willReturnSelf();
        $menuMapper->expects(static::exactly(2))
            ->method('getAdapter')
            ->willReturnSelf();
        $menuMapper->expects(static::exactly(1))
            ->method('beginTransaction')
            ->willReturnSelf();
        $menuMapper->expects(static::exactly(1))
            ->method('commit')
            ->willReturnSelf();
        $menuMapper->expects(static::exactly(2))
            ->method('update')
            ->willReturnSelf();
        $categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $pageService = $this->getMockBuilder(\Page\Service\PageService::class)
            ->disableOriginalConstructor()
            ->getMock();
        $menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);

        static::assertSame(true, $menuService->updateMenuOrder([$parent]));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Menu\Test\Service;
6
7			use Zend\Stdlib\ArrayObject;
8
9			class MenuServiceTest extends \PHPUnit_Framework_TestCase
10			{
11			public function testGetNestedAllShouldReturnArray()
12			{
13			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
14			->disableOriginalConstructor()
15			->getMock();
16			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
17			->setMethods(['selectAll', 'toArray'])
18			->disableOriginalConstructor()
19			->getMock();
20			$menuMapper->expects(static::once())
21			->method('selectAll')
22			->willReturnSelf();
23			$menuMapper->expects(static::once())
24			->method('toArray')
25			->willReturn([]);
26			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
27			->disableOriginalConstructor()
28			->getMock();
29			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
30			->disableOriginalConstructor()
31			->getMock();
32			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
33
34			static::assertInternalType('array', $menuService->getNestedAll());
35			}
36
37			public function testGetShouldReturnArray()
38			{
39			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
40			->disableOriginalConstructor()
41			->getMock();
42			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
43			->setMethods(['get'])
44			->disableOriginalConstructor()
45			->getMock();
46			$menuMapper->expects(static::once())
47			->method('get')
48			->willReturn([]);
49			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
50			->disableOriginalConstructor()
51			->getMock();
52			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
53			->disableOriginalConstructor()
54			->getMock();
55			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
56
57			static::assertInternalType('array', $menuService->get(1));
58			}
59
60			public function testAddMenuItemWithPageIdShouldReturnTrue()
61			{
62			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
63			->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
64			->disableOriginalConstructor()
65			->getMock();
66			$menuFilter->expects(static::once())
67			->method('getInputFilter')
68			->willReturnSelf();
69			$menuFilter->expects(static::once())
70			->method('setData')
71			->willReturnSelf();
72			$menuFilter->expects(static::once())
73			->method('isValid')
74			->willReturn(true);
75			$menuFilter->expects(static::once())
76			->method('getValues')
77			->willReturn(['page_id' => 1, 'category_id' => false, 'href' => false]);
78			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
79			->setMethods(['insertMenuItem', 'get'])
80			->disableOriginalConstructor()
81			->getMock();
82			$menuMapper->expects(static::once())
83			->method('insertMenuItem')
84			->willReturn(true);
85			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
86			->disableOriginalConstructor()
87			->getMock();
88			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
89			->setMethods(['getPage'])
90			->disableOriginalConstructor()
91			->getMock();
92			$pageService->expects(static::once())
93			->method('getPage')
94			->willReturn(new \Page\Entity\Page());
95			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
96
97			static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => false, 'href' => false]));
98			}
99
100			public function testAddMenuItemWithCategoryIdShouldReturnTrue()
101			{
102			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
103			->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
104			->disableOriginalConstructor()
105			->getMock();
106			$menuFilter->expects(static::once())
107			->method('getInputFilter')
108			->willReturnSelf();
109			$menuFilter->expects(static::once())
110			->method('setData')
111			->willReturnSelf();
112			$menuFilter->expects(static::once())
113			->method('isValid')
114			->willReturn(true);
115			$menuFilter->expects(static::once())
116			->method('getValues')
117			->willReturn(['page_id' => false, 'category_id' => 1, 'href' => false]);
118			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
119			->setMethods(['insertMenuItem', 'get'])
120			->disableOriginalConstructor()
121			->getMock();
122			$menuMapper->expects(static::once())
123			->method('insertMenuItem')
124			->willReturn(true);
125			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
126			->setMethods(['getCategory'])
127			->disableOriginalConstructor()
128			->getMock();
129			$categoryService->expects(static::once())
130			->method('getCategory')
131			->willReturn(new ArrayObject(['category_uuid' => 'test']));
132			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
133			->disableOriginalConstructor()
134			->getMock();
135			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
136
137			static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => false, 'href' => false]));
138			}
139
140			/**
141			* @expectedExceptionMessage test error
142			* @expectedException \Std\FilterException
143			*/
144			public function testAddMenuItemWithCategoryIdShouldThrowFilterException()
145			{
146			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
147			->setMethods(['getInputFilter', 'setData', 'isValid', 'getMessages'])
148			->disableOriginalConstructor()
149			->getMock();
150			$menuFilter->expects(static::once())
151			->method('getInputFilter')
152			->willReturnSelf();
153			$menuFilter->expects(static::once())
154			->method('setData')
155			->willReturnSelf();
156			$menuFilter->expects(static::once())
157			->method('isValid')
158			->willReturn(false);
159			$menuFilter->expects(static::once())
160			->method('getMessages')
161			->willReturn(['test error']);
162			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
163			->setMethods(['get'])
164			->disableOriginalConstructor()
165			->getMock();
166			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
167			->disableOriginalConstructor()
168			->getMock();
169			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
170			->disableOriginalConstructor()
171			->getMock();
172			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
173
174			static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => false, 'href' => false]));
175			}
176
177			/**
178			* @expectedExceptionMessage You need to set only one link. Post, Category or Href.
179			* @expectedException \Exception
180			*/
181			public function testAddMenuItemWithCategoryIdShouldThrowException()
182			{
183			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
184			->setMethods(['getInputFilter', 'setData', 'isValid'])
185			->disableOriginalConstructor()
186			->getMock();
187			$menuFilter->expects(static::once())
188			->method('getInputFilter')
189			->willReturnSelf();
190			$menuFilter->expects(static::once())
191			->method('setData')
192			->willReturnSelf();
193			$menuFilter->expects(static::once())
194			->method('isValid')
195			->willReturn(true);
196			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
197			->setMethods(['get'])
198			->disableOriginalConstructor()
199			->getMock();
200			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
201			->disableOriginalConstructor()
202			->getMock();
203			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
204			->disableOriginalConstructor()
205			->getMock();
206			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
207
208			static::assertSame(true, $menuService->addMenuItem(['page_id' => 1, 'category_id' => 1, 'href' => 1]));
209			}
210
211			public function testAddMenuItemWithHrefShouldReturnTrue()
212			{
213			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
214			->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
215			->disableOriginalConstructor()
216			->getMock();
217			$menuFilter->expects(static::once())
218			->method('getInputFilter')
219			->willReturnSelf();
220			$menuFilter->expects(static::once())
221			->method('setData')
222			->willReturnSelf();
223			$menuFilter->expects(static::once())
224			->method('isValid')
225			->willReturn(true);
226			$menuFilter->expects(static::once())
227			->method('getValues')
228			->willReturn(['page_id' => false, 'category_id' => false, 'href' => 'test']);
229			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
230			->setMethods(['insertMenuItem', 'get'])
231			->disableOriginalConstructor()
232			->getMock();
233			$menuMapper->expects(static::once())
234			->method('insertMenuItem')
235			->willReturn(true);
236			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
237			->disableOriginalConstructor()
238			->getMock();
239			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
240			->disableOriginalConstructor()
241			->getMock();
242			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
243
244			static::assertSame(true, $menuService->addMenuItem(['page_id' => false, 'category_id' => false, 'href' => 'test']));
245			}
246
247			public function testUpdateMenuItemShouldReturnTrue()
248			{
249			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
250			->setMethods(['getInputFilter', 'setData', 'isValid', 'getValues'])
251			->disableOriginalConstructor()
252			->getMock();
253			$menuFilter->expects(static::once())
254			->method('getInputFilter')
255			->willReturnSelf();
256			$menuFilter->expects(static::once())
257			->method('setData')
258			->willReturnSelf();
259			$menuFilter->expects(static::once())
260			->method('isValid')
261			->willReturn(true);
262			$menuFilter->expects(static::once())
263			->method('getValues')
264			->willReturn(['page_id' => false, 'category_id' => false, 'href' => 'test']);
265			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
266			->setMethods(['updateMenuItem'])
267			->disableOriginalConstructor()
268			->getMock();
269			$menuMapper->expects(static::once())
270			->method('updateMenuItem')
271			->willReturn(true);
272			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
273			->disableOriginalConstructor()
274			->getMock();
275			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
276			->disableOriginalConstructor()
277			->getMock();
278			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
279
280			static::assertSame(true, $menuService->updateMenuItem(['page_id' => false, 'category_id' => false, 'href' => 'test'], 1));
281			}
282
283			public function testDeleteShouldReturnTrue()
284			{
285			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
286			->disableOriginalConstructor()
287			->getMock();
288			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
289			->setMethods(['select', 'delete'])
290			->disableOriginalConstructor()
291			->getMock();
292			$menuMapper->expects(static::once())
293			->method('select')
294			->willReturn(new \Zend\Db\ResultSet\ResultSet());
295			$menuMapper->expects(static::once())
296			->method('delete')
297			->willReturn(true);
298			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
299			->disableOriginalConstructor()
300			->getMock();
301			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
302			->disableOriginalConstructor()
303			->getMock();
304			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
305
306			static::assertSame(true, $menuService->delete(1));
307			}
308
309			/**
310			* @expectedException \Exception
311			* @expectedExceptionMessage This Menu Item has child items
312			*/
313			public function testDeleteShouldThrowException()
314			{
315			$resultSet = $this->getMockBuilder(\Zend\Db\ResultSet\ResultSet::class)
316			->setMethods(['count'])
317			->getMockForAbstractClass();
318			$resultSet->expects(static::once())
319			->method('count')
320			->willReturn(1);
321			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
322			->disableOriginalConstructor()
323			->getMock();
324			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
325			->setMethods(['select'])
326			->disableOriginalConstructor()
327			->getMock();
328			$menuMapper->expects(static::once())
329			->method('select')
330			->willReturn($resultSet);
331			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
332			->disableOriginalConstructor()
333			->getMock();
334			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
335			->disableOriginalConstructor()
336			->getMock();
337			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
338
339			static::assertSame(true, $menuService->delete(1));
340			}
341
342			public function testGetForSelectShouldReturnResultSet()
343			{
344			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
345			->disableOriginalConstructor()
346			->getMock();
347			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
348			->setMethods(['forSelect'])
349			->disableOriginalConstructor()
350			->getMock();
351			$menuMapper->expects(static::once())
352			->method('forSelect')
353			->willReturn(new \Zend\Db\ResultSet\ResultSet());
354
355			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
356			->disableOriginalConstructor()
357			->getMock();
358			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
359			->disableOriginalConstructor()
360			->getMock();
361			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
362
363			static::assertInstanceOf(\Zend\Db\ResultSet\ResultSet::class, $menuService->getForSelect());
364			}
365
366			public function testUpdateMenuOrderShouldReturnTrueWhenNoOrderReceived()
367			{
368			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
369			->disableOriginalConstructor()
370			->getMock();
371			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
372			->disableOriginalConstructor()
373			->getMock();
374			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
375			->disableOriginalConstructor()
376			->getMock();
377			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
378			->disableOriginalConstructor()
379			->getMock();
380			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
381
382			static::assertSame(true, $menuService->updateMenuOrder(false));
383			}
384
385			/**
386			* @expectedExceptionMessage test error
387			* @expectedException \Exception
388			*/
389			public function testUpdateMenuOrderShouldRethrowException()
390			{
391			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
392			->disableOriginalConstructor()
393			->getMock();
394			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
395			->setMethods(['getAdapter'])
396			->disableOriginalConstructor()
397			->getMock();
398			$menuMapper->expects(static::exactly(2))
399			->method('getAdapter')
400			->willThrowException(new \Exception('test error'));
401			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
402			->disableOriginalConstructor()
403			->getMock();
404			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
405			->disableOriginalConstructor()
406			->getMock();
407			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
408
409			static::assertSame(true, $menuService->updateMenuOrder(true));
410			}
411
412			public function testUpdateMenuOrderShouldReturnTrue()
413			{
414			$child = new \stdClass();
415			$child->id = 1;
416			$parent = new \stdClass();
417			$parent->children = [$child];
418			$parent->id = 2;
419
420			$menuFilter = $this->getMockBuilder(\Menu\Filter\MenuFilter::class)
421			->disableOriginalConstructor()
422			->getMock();
423			$menuMapper = $this->getMockBuilder(\Menu\Mapper\MenuMapper::class)
424			->setMethods(['getAdapter', 'getDriver', 'getConnection', 'beginTransaction', 'commit', 'update'])
425			->disableOriginalConstructor()
426			->getMock();
427			$menuMapper->expects(static::exactly(2))
428			->method('getDriver')
429			->willReturnSelf();
430			$menuMapper->expects(static::exactly(2))
431			->method('getConnection')
432			->willReturnSelf();
433			$menuMapper->expects(static::exactly(2))
434			->method('getAdapter')
435			->willReturnSelf();
436			$menuMapper->expects(static::exactly(1))
437			->method('beginTransaction')
438			->willReturnSelf();
439			$menuMapper->expects(static::exactly(1))
440			->method('commit')
441			->willReturnSelf();
442			$menuMapper->expects(static::exactly(2))
443			->method('update')
444			->willReturnSelf();
445			$categoryService = $this->getMockBuilder(\Category\Service\CategoryService::class)
446			->disableOriginalConstructor()
447			->getMock();
448			$pageService = $this->getMockBuilder(\Page\Service\PageService::class)
449			->disableOriginalConstructor()
450			->getMock();
451			$menuService = new \Menu\Service\MenuService($menuMapper, $menuFilter, $categoryService, $pageService);
452
453			static::assertSame(true, $menuService->updateMenuOrder([$parent]));
454			}
455			}
456

phpsrbija / unfinished

Branch — master (4042af)

MenuServiceTest::testDeleteShouldThrowException() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like