ResultAcknowledgementHandlerTest::testHandleNonTrueResponse() - Code Metrics - Inspection of "Support PHP 5.5" - graze/queue - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#39)

by Will

created 2017-03-24 09:20 UTC

testHandleNonTrueResponse() A

↳ Parent: ResultAcknowledgementHandlerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	12
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	7
nc	1
nop	0

<?php

/**
 * This file is part of graze/queue.
 *
 * Copyright (c) 2015 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/queue/blob/master/LICENSE MIT
 *
 * @link    https://github.com/graze/queue
 */

namespace Graze\Queue\Handler;

use ArrayIterator;
use Closure;
use Graze\Queue\Adapter\AdapterInterface;
use Graze\Queue\Message\MessageInterface;
use Mockery as m;
use Mockery\MockInterface;
use PHPUnit_Framework_TestCase as TestCase;

class ResultAcknowledgementHandlerTest extends TestCase
{
    /** @var AdapterInterface|MockInterface */
    private $adapter;
    /** @var ResultAcknowledgementHandler */
    private $handler;
    /** @var MessageInterface|MockInterface */
    private $message;
    /** @var ArrayIterator */
    private $messages;

    public function setUp()
    {
        $this->adapter = m::mock('Graze\Queue\Adapter\AdapterInterface');

        $this->message = m::mock('Graze\Queue\Message\MessageInterface');
        $this->messages = new ArrayIterator([$this->message]);

        $this->handler = new EagerAcknowledgementHandler();

    }

    public function testHandleTrueResult()
    {
        $handler = new ResultAcknowledgementHandler(function ($result) {
            return $result === true;
        }, $this->handler);

        $this->message->shouldReceive('isValid')->once()->withNoArgs()->andReturn(true);
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.
}
        $this->adapter->shouldReceive('acknowledge')->once()->with(m::mustBe([$this->message]));
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.
}

        $msgs = [];
        $handler($this->messages, $this->adapter, function ($msg, Closure $done) use (&$msgs) {

            $msgs[] = $msg;
            return true;
        });

        assertThat($msgs, is(identicalTo(iterator_to_array($this->messages))));
    }

    public function testHandleNonTrueResponse()
    {
        $handler = new ResultAcknowledgementHandler(function ($result) {
            return $result === true;
        }, $this->handler);

        $this->message->shouldReceive('isValid')->once()->withNoArgs()->andReturn(true);
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.
}

        $handler($this->messages, $this->adapter, function ($msg, Closure $done) use (&$msgs) {

            return false;
        });
    }

    public function testCustomResultAcknowledgementHandler()
    {
        $handler = new ResultAcknowledgementHandler(function ($result) {
            return $result === false;
        }, $this->handler);

        $this->message->shouldReceive('isValid')->once()->withNoArgs()->andReturn(true);
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.
}
        $this->adapter->shouldReceive('acknowledge')->once()->with(m::mustBe([$this->message]));
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.
}

        $handler($this->messages, $this->adapter, function ($msg) {

            return false;
        });
    }
}


1			<?php
2
3			/**
4			* This file is part of graze/queue.
5			*
6			* Copyright (c) 2015 Nature Delivered Ltd. <https://www.graze.com>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*
11			* @license https://github.com/graze/queue/blob/master/LICENSE MIT
12			*
13			* @link https://github.com/graze/queue
14			*/
15
16			namespace Graze\Queue\Handler;
17
18			use ArrayIterator;
19			use Closure;
20			use Graze\Queue\Adapter\AdapterInterface;
21			use Graze\Queue\Message\MessageInterface;
22			use Mockery as m;
23			use Mockery\MockInterface;
24			use PHPUnit_Framework_TestCase as TestCase;
25
26			class ResultAcknowledgementHandlerTest extends TestCase
27			{
28			/** @var AdapterInterface\|MockInterface */
29			private $adapter;
30			/** @var ResultAcknowledgementHandler */
31			private $handler;
32			/** @var MessageInterface\|MockInterface */
33			private $message;
34			/** @var ArrayIterator */
35			private $messages;
36
37			public function setUp()
38			{
39			$this->adapter = m::mock('Graze\Queue\Adapter\AdapterInterface');
40
41			$this->message = m::mock('Graze\Queue\Message\MessageInterface');
42			$this->messages = new ArrayIterator([$this->message]);
43
44			$this->handler = new EagerAcknowledgementHandler();
			0 ignored issues – show Documentation Bug introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report It seems like `new \Graze\Queue\Handler...cknowledgementHandler()` of type `object<Graze\Queue\Handl...AcknowledgementHandler>` is incompatible with the declared type `object<Graze\Queue\Handl...AcknowledgementHandler>` of property `$handler`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
45			}
46
47			public function testHandleTrueResult()
48			{
49			$handler = new ResultAcknowledgementHandler(function ($result) {
50			return $result === true;
51			}, $this->handler);
52
53			$this->message->shouldReceive('isValid')->once()->withNoArgs()->andReturn(true);
			0 ignored issues – show Bug introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The method `shouldReceive` does only exist in `Mockery\MockInterface`, but not in `Graze\Queue\Message\MessageInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
54			$this->adapter->shouldReceive('acknowledge')->once()->with(m::mustBe([$this->message]));
			0 ignored issues – show Bug introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The method `shouldReceive` does only exist in `Mockery\MockInterface`, but not in `Graze\Queue\Adapter\AdapterInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
55
56			$msgs = [];
57			$handler($this->messages, $this->adapter, function ($msg, Closure $done) use (&$msgs) {
			0 ignored issues – show Unused Code introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The parameter `$done` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
58			$msgs[] = $msg;
59			return true;
60			});
61
62			assertThat($msgs, is(identicalTo(iterator_to_array($this->messages))));
63			}
64
65			public function testHandleNonTrueResponse()
66			{
67			$handler = new ResultAcknowledgementHandler(function ($result) {
68			return $result === true;
69			}, $this->handler);
70
71			$this->message->shouldReceive('isValid')->once()->withNoArgs()->andReturn(true);
			0 ignored issues – show Bug introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The method `shouldReceive` does only exist in `Mockery\MockInterface`, but not in `Graze\Queue\Message\MessageInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
72
73			$handler($this->messages, $this->adapter, function ($msg, Closure $done) use (&$msgs) {
			0 ignored issues – show Unused Code introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The parameter `$msg` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The parameter `$done` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
74			return false;
75			});
76			}
77
78			public function testCustomResultAcknowledgementHandler()
79			{
80			$handler = new ResultAcknowledgementHandler(function ($result) {
81			return $result === false;
82			}, $this->handler);
83
84			$this->message->shouldReceive('isValid')->once()->withNoArgs()->andReturn(true);
			0 ignored issues – show Bug introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The method `shouldReceive` does only exist in `Mockery\MockInterface`, but not in `Graze\Queue\Message\MessageInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
85			$this->adapter->shouldReceive('acknowledge')->once()->with(m::mustBe([$this->message]));
			0 ignored issues – show Bug introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The method `shouldReceive` does only exist in `Mockery\MockInterface`, but not in `Graze\Queue\Adapter\AdapterInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
86
87			$handler($this->messages, $this->adapter, function ($msg) {
			0 ignored issues – show Unused Code introduced 2017-03-20 18:12 UTC by Report Bug Copy Issue Report The parameter `$msg` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
88			return false;
89			});
90			}
91			}
92

graze / queue

Pull Request — master (#39)

testHandleNonTrueResponse() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like