AddresscheckTest::testIsCheckNeededForQuoteMinBasket() - Code Metrics - Inspection of "MAG2-42 - Added compatibility to Magento 2.2" - PAYONE-GmbH/magento-2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#114)

by Florian

created 2017-10-20 13:29 UTC

testIsCheckNeededForQuoteMinBasket() A

↳ Parent: AddresscheckTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	9
Ratio	100 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	9
loc	9
rs	9.6666
cc	1
eloc	6
nc	1
nop	0

<?php

/**
 * PAYONE Magento 2 Connector is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * PAYONE Magento 2 Connector is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with PAYONE Magento 2 Connector. If not, see <http://www.gnu.org/licenses/>.
 *
 * PHP version 5
 *
 * @category  Payone
 * @package   Payone_Magento2_Plugin
 * @author    FATCHIP GmbH <[email protected]>
 * @copyright 2003 - 2017 Payone GmbH
 * @license   <http://www.gnu.org/licenses/> GNU Lesser General Public License
 * @link      http://www.payone.de
 */

namespace Payone\Core\Test\Unit\Model\Risk;

use Payone\Core\Model\Risk\Addresscheck as ClassToTest;
use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
use Payone\Core\Model\Api\Request\Addresscheck;
use Payone\Core\Helper\Database;
use Payone\Core\Helper\Toolkit;
use Magento\Checkout\Model\Session;
use Magento\Quote\Model\Quote\Address;
use Magento\Quote\Model\Quote;
use Magento\Framework\Exception\LocalizedException;
use Payone\Core\Test\Unit\BaseTestCase;
use Payone\Core\Model\Test\PayoneObjectManager;

class AddresscheckTest extends BaseTestCase
{
    /**
     * @var ClassToTest
     */
    private $classToTest;

    /**
     * @var ObjectManager|PayoneObjectManager
     */
    private $objectManager;

    /**
     * @var Addresscheck|\PHPUnit_Framework_MockObject_MockObject
     */
    private $addresscheck;

    /**
     * @var Database|\PHPUnit_Framework_MockObject_MockObject
     */
    private $databaseHelper;

    /**
     * @var Quote|\PHPUnit_Framework_MockObject_MockObject
     */
    private $quote;

    /**
     * @var Toolkit
     */
    private $toolkitHelper;

    protected function setUp()
    {
        $this->objectManager = $this->getObjectManager();

        $this->addresscheck = $this->getMockBuilder(Addresscheck::class)->disableOriginalConstructor()->getMock();
        $this->databaseHelper = $this->getMockBuilder(Database::class)->disableOriginalConstructor()->getMock();

        $this->quote = $this->getMockBuilder(Quote::class)
            ->disableOriginalConstructor()
            ->setMethods(['isVirtual', 'getSubtotal'])
            ->getMock();
        $this->quote->method('isVirtual')->willReturn(false);
        $this->quote->method('getSubtotal')->willReturn(100);

        #$this->toolkitHelper = $this->getMockBuilder(Toolkit::class)->disableOriginalConstructor()->getMock();

        #$this->toolkitHelper->method('handleSubstituteReplacement')->willReturn('Invalid message');

        $this->toolkitHelper = $this->objectManager->getObject(Toolkit::class);

        $checkoutSession = $this->getMockBuilder(Session::class)
            ->disableOriginalConstructor()
            ->setMethods([
                'getPayoneBillingAddresscheckScore',
                'getPayoneShippingAddresscheckScore',
                'unsPayoneBillingAddresscheckScore',
                'unsPayoneShippingAddresscheckScore'])
            ->getMock();
        $checkoutSession->method('getPayoneShippingAddresscheckScore')->willReturn(null);

        $this->classToTest = $this->objectManager->getObject(ClassToTest::class, [
            'addresscheck' => $this->addresscheck,
            'databaseHelper' => $this->databaseHelper,
            'toolkitHelper' => $this->toolkitHelper,
            'checkoutSession' => $checkoutSession
        ]);
    }

    public function testIsCheckNeededForQuoteMinBasket()

    {
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([['min_order_total', 'address_check', 'payone_protect', null, 10]]);

        $result = $this->classToTest->isCheckNeededForQuote(true, true, 5);
        $this->assertFalse($result);
    }

    public function testIsCheckNeededForQuoteMaxBasket()

    {
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([['max_order_total', 'address_check', 'payone_protect', null, 10]]);

        $result = $this->classToTest->isCheckNeededForQuote(true, true, 15);
        $this->assertFalse($result);
    }

    public function testIsCheckNeededForQuoteVirtual()

    {
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([['check_billing_for_virtual_order', 'address_check', 'payone_protect', null, 0]]);

        $result = $this->classToTest->isCheckNeededForQuote(true, true, 15);
        $this->assertFalse($result);
    }

    public function testIsCheckNeededForQuote()

    {
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([['check_billing_for_virtual_order', 'address_check', 'payone_protect', null, 0]]);

        $result = $this->classToTest->isCheckNeededForQuote(true, false, 15);
        $this->assertTrue($result);
    }

    public function testCorrectAddress()

    {
        $address = $this->getMockBuilder(Address::class)->disableOriginalConstructor()->getMock();
        $this->addresscheck->method('sendRequest')->willReturn(true);

        $result = $this->classToTest->correctAddress($address);
        $this->assertEquals($address, $result);
    }

    public function testHandleAddressManagement()
    {
        $address = $this->getMockBuilder(Address::class)
            ->disableOriginalConstructor()
            ->setMethods(['getPayoneAddresscheckScore', 'setPayoneAddresscheckScore', 'getStreet', 'setStreet', 'getData', 'setData'])
            ->getMock();
        $address->method('getPayoneAddresscheckScore')->willReturn(null);
        $address->method('getStreet')->willReturn(['Teststr. 12', '3rd floor']);

        $this->addresscheck->method('sendRequest')->willReturn(['status' => 'VALID', 'street' => 'Another str. 7', 'firstname' => 'Patrick']);

        $result = $this->classToTest->handleAddressManagement($address, $this->quote, false);
        $this->assertInstanceOf(Address::class, $result);

        $result = $this->classToTest->isAddressCorrected();
        $this->assertTrue($result);
    }

    public function testHandleAddressManagementExceptionError()
    {
        $address = $this->getMockBuilder(Address::class)
            ->disableOriginalConstructor()
            ->setMethods(['getPayoneAddresscheckScore', 'setPayoneAddresscheckScore', 'getStreet', 'setStreet', 'getData', 'setData'])
            ->getMock();
        $address->method('getPayoneAddresscheckScore')->willReturn(null);

        $this->addresscheck->method('sendRequest')->willReturn(['status' => 'ERROR']);
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([
                ['handle_response_error', 'address_check', 'payone_protect', null, 'stop_checkout'],
                ['stop_checkout_message', 'address_check', 'payone_protect', null, null]
            ]);

        $this->expectException(LocalizedException::class);
        $this->classToTest->handleAddressManagement($address, $this->quote, false);
    }

    public function testHandleAddressManagementExceptionInvalid()

    {
        $address = $this->getMockBuilder(Address::class)
            ->disableOriginalConstructor()
            ->setMethods(['getPayoneAddresscheckScore', 'setPayoneAddresscheckScore', 'getStreet', 'setStreet', 'getData', 'setData'])
            ->getMock();
        $address->method('getPayoneAddresscheckScore')->willReturn(null);

        $this->addresscheck->method('sendRequest')->willReturn(['status' => 'INVALID', 'customermessage' => 'Address invalid']);
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([
                ['message_response_invalid', 'address_check', 'payone_protect', null, null]
            ]);

        $this->expectException(LocalizedException::class);
        $this->classToTest->handleAddressManagement($address, $this->quote, false);
    }

    public function testHandleAddressManagementExceptionNoStatus()
    {
        $address = $this->getMockBuilder(Address::class)
            ->disableOriginalConstructor()
            ->setMethods(['getPayoneAddresscheckScore', 'setPayoneAddresscheckScore', 'getStreet', 'setStreet', 'getData', 'setData'])
            ->getMock();
        $address->method('getPayoneAddresscheckScore')->willReturn(null);

        $this->addresscheck->method('sendRequest')->willReturn([]);
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([
                ['message_response_invalid', 'address_check', 'payone_protect', null, null]
            ]);

        $this->expectException(LocalizedException::class);
        $this->classToTest->handleAddressManagement($address, $this->quote, false);
    }

    public function testHandleAddressManagementExceptionInvalidDefault()

    {
        $address = $this->getMockBuilder(Address::class)
            ->disableOriginalConstructor()
            ->setMethods(['getPayoneAddresscheckScore', 'setPayoneAddresscheckScore', 'getStreet', 'setStreet', 'getData', 'setData'])
            ->getMock();
        $address->method('getPayoneAddresscheckScore')->willReturn(null);

        $this->addresscheck->method('sendRequest')->willReturn(['status' => 'INVALID', 'customermessage' => 'Address invalid']);
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([
                ['message_response_invalid', 'address_check', 'payone_protect', null, 'Address invalid: {{payone_customermessage}}']
            ]);

        $this->expectException(LocalizedException::class);
        $this->classToTest->handleAddressManagement($address, $this->quote, false);
    }

    public function testGetScoreR()

    {
        $this->addresscheck->method('sendRequest')->willReturn(['status' => 'INVALID']);
        $address = $this->getMockBuilder(Address::class)->disableOriginalConstructor()->getMock();

        $result = $this->classToTest->getScore($address);
        $expected = 'R';
        $this->assertEquals($expected, $result);
    }

    public function testGetScorePersonstatusNoMapping()
    {
        $status = 'x';
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([['mapping_personstatus', 'address_check', 'payone_protect', null, $this->toolkitHelper->serialize($status)]]);

        $this->addresscheck->method('sendRequest')->willReturn(['personstatus' => 'ABC']);
        $address = $this->getMockBuilder(Address::class)->disableOriginalConstructor()->getMock();

        $result = $this->classToTest->getScore($address);
        $expected = 'G';
        $this->assertEquals($expected, $result);
    }

    public function testGetScorePersonstatus()
    {
        $status = [
            ['personstatus' => 'ABC', 'score' => 'D']
        ];
        $this->databaseHelper->expects($this->any())
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.
}
            ->method('getConfigParam')
            ->willReturnMap([['mapping_personstatus', 'address_check', 'payone_protect', null, $this->toolkitHelper->serialize($status)]]);

        $this->addresscheck->method('sendRequest')->willReturn(['personstatus' => 'ABC']);
        $address = $this->getMockBuilder(Address::class)->disableOriginalConstructor()->getMock();

        $result = $this->classToTest->getScore($address);
        $expected = 'D';
        $this->assertEquals($expected, $result);
    }

    public function testGetScoreStillValid()

    {
        $this->addresscheck->method('sendRequest')->willReturn(true);
        $address = $this->getMockBuilder(Address::class)->disableOriginalConstructor()->getMock();

        $expected = 'X';
        $this->databaseHelper->method('getOldAddressStatus')->willReturn($expected);

        $result = $this->classToTest->getScore($address);
        $this->assertEquals($expected, $result);
    }

    public function testGetResponse()

    {
        $this->addresscheck->method('sendRequest')->willReturn(true);

        $address = $this->getMockBuilder(Address::class)->disableOriginalConstructor()->getMock();

        $result = $this->classToTest->getResponse($address);
        $this->assertTrue($result);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }
}


Pull Request — master (#114)

testIsCheckNeededForQuoteMinBasket() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			/**
4			* PAYONE Magento 2 Connector is free software: you can redistribute it and/or modify
5			* it under the terms of the GNU Lesser General Public License as published by
6			* the Free Software Foundation, either version 3 of the License, or
7			* (at your option) any later version.
8			*
9			* PAYONE Magento 2 Connector is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public License
15			* along with PAYONE Magento 2 Connector. If not, see <http://www.gnu.org/licenses/>.
16			*
17			* PHP version 5
18			*
19			* @category Payone
20			* @package Payone_Magento2_Plugin
21			* @author FATCHIP GmbH <[email protected]>
22			* @copyright 2003 - 2017 Payone GmbH
23			* @license <http://www.gnu.org/licenses/> GNU Lesser General Public License
24			* @link http://www.payone.de
25			*/
26
27			namespace Payone\Core\Test\Unit\Model\Risk;
28
29			use Payone\Core\Model\Risk\Addresscheck as ClassToTest;
30			use Magento\Framework\TestFramework\Unit\Helper\ObjectManager;
31			use Payone\Core\Model\Api\Request\Addresscheck;
32			use Payone\Core\Helper\Database;
33			use Payone\Core\Helper\Toolkit;
34			use Magento\Checkout\Model\Session;
35			use Magento\Quote\Model\Quote\Address;
36			use Magento\Quote\Model\Quote;
37			use Magento\Framework\Exception\LocalizedException;
38			use Payone\Core\Test\Unit\BaseTestCase;
39			use Payone\Core\Model\Test\PayoneObjectManager;
40

PAYONE-GmbH / magento-2

Pull Request — master (#114)

testIsCheckNeededForQuoteMinBasket() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like