UserContext::createAddress() - Code Metrics - Inspection of "Merge pull request #4002 from Zales0123/cart-with-..." - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 749f69...94328c )

by Kamil

created 2016-02-03 11:52 UTC

UserContext::createAddress() A

↳ Parent: UserContext

Complexity

Conditions	1
Paths	1

Size

Total Lines	18
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	18
rs	9.4285
cc	1
eloc	15
nc	1
nop	6

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sylius\Behat\Context\Setup;

use Behat\Behat\Context\Context;
use Sylius\Component\Addressing\Model\AddressInterface;
use Sylius\Component\Core\Model\CustomerInterface;
use Sylius\Component\Core\Test\Services\SharedStorageInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;
use Sylius\Component\Resource\Repository\RepositoryInterface;
use Symfony\Component\Intl\Intl;
use Symfony\Component\Security\Core\User\UserInterface;

/**
 * @author Arkadiusz Krakowiak <[email protected]>
 */
class UserContext implements Context
{
    /**
     * @var RepositoryInterface
     */
    private $userRepository;

    /**
     * @var SharedStorageInterface
     */
    private $sharedStorage;

    /**
     * @var FactoryInterface
     */
    private $userFactory;

    /**
     * @var FactoryInterface
     */
    private $customerFactory;

    /**
     * @var FactoryInterface
     */
    private $addressFactory;

    /**
     * @param RepositoryInterface $userRepository
     * @param SharedStorageInterface $sharedStorage
     * @param FactoryInterface $userFactory
     * @param FactoryInterface $customerFactory
     * @param FactoryInterface $addressFactory
     */
    public function __construct(
        RepositoryInterface $userRepository,
        SharedStorageInterface $sharedStorage,
        FactoryInterface $userFactory,
        FactoryInterface $customerFactory,
        FactoryInterface $addressFactory
    ) {
        $this->userRepository = $userRepository;
        $this->sharedStorage = $sharedStorage;
        $this->userFactory = $userFactory;
        $this->customerFactory = $customerFactory;
        $this->addressFactory = $addressFactory;
    }

    /**
     * @Given there is user :email identified by :password
     */
    public function thereIsUserIdentifiedBy($email, $password)
    {
        $customer = $this->createCustomer();
        $user = $this->createUser($customer, $email, $password);

        $this->sharedStorage->setCurrentResource('user', $user);
        $this->userRepository->add($user);
    }

    /**
     * @Given there is user :email identified by :password, with :country as shipping country
     */
    public function thereIsUserWithShippingCountry($email, $password, $country)
    {
        $customer = $this->createCustomer();
        $user = $this->createUser($customer, $email, $password);

        $customer->setShippingAddress($this->createAddress($customer->getFirstName(), $customer->getLastName(), $country));

        $this->sharedStorage->setCurrentResource('user', $user);
        $this->userRepository->add($user);
    }

    /**
     * @param string $firstName
     * @param string $lastName
     *
     * @return CustomerInterface
     */
    private function createCustomer($firstName = 'John', $lastName = 'Doe')
    {
        $customer = $this->customerFactory->createNew();
        $customer->setFirstName($firstName);
        $customer->setLastName($lastName);

        return $customer;
    }

    /**
     * @param CustomerInterface $customer
     * @param string $email
     * @param string $password
     *
     * @return UserInterface
     */
    private function createUser(
        CustomerInterface $customer,
        $email = '[email protected]',
        $password = 'testPassword'
    ) {
        $user = $this->userFactory->createNew();

        $user->setCustomer($customer);
        $user->setUsername($email);
        $user->setEmail($email);
        $user->setPlainPassword($password);

        return $user;
    }

    /**
     * @param string $firstName
     * @param string $lastName
     * @param string $country
     * @param string $street
     * @param string $city
     * @param string $postcode
     *
     * @return AddressInterface
     */
    private function createAddress(
        $firstName,
        $lastName,
        $country = 'United States',
        $street = 'Jones St. 114',
        $city = 'Paradise City',
        $postcode = '99999'
    ) {
        $address = $this->addressFactory->createNew();
        $address->setFirstName($firstName);
        $address->setLastName($lastName);
        $address->setStreet($street);
        $address->setCity($city);
        $address->setPostcode($postcode);
        $address->setCountryCode($this->getCountryCodeByEnglishCountryName($country));

        return $address;
    }

    /**
     * @param string $name
     *
     * @return string
     *
     * @throws \InvalidArgumentException If name is not found in country code registry.
     */
    private function getCountryCodeByEnglishCountryName($name)
    {
        $names = Intl::getRegionBundle()->getCountryNames('en');
        $countryCode = array_search(trim($name), $names);

        if (null === $countryCode) {
            throw new \InvalidArgumentException(sprintf(
                'Country "%s" not found! Available names: %s.', $name, implode(', ', $names)
            ));
        }

        return $countryCode;
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Sylius\Behat\Context\Setup;
13
14			use Behat\Behat\Context\Context;
15			use Sylius\Component\Addressing\Model\AddressInterface;
16			use Sylius\Component\Core\Model\CustomerInterface;
17			use Sylius\Component\Core\Test\Services\SharedStorageInterface;
18			use Sylius\Component\Resource\Factory\FactoryInterface;
19			use Sylius\Component\Resource\Repository\RepositoryInterface;
20			use Symfony\Component\Intl\Intl;
21			use Symfony\Component\Security\Core\User\UserInterface;
22
23			/**
24			* @author Arkadiusz Krakowiak <[email protected]>
25			*/
26			class UserContext implements Context
27			{
28			/**
29			* @var RepositoryInterface
30			*/
31			private $userRepository;
32
33			/**
34			* @var SharedStorageInterface
35			*/
36			private $sharedStorage;
37
38			/**
39			* @var FactoryInterface
40			*/
41			private $userFactory;
42
43			/**
44			* @var FactoryInterface
45			*/
46			private $customerFactory;
47
48			/**
49			* @var FactoryInterface
50			*/
51			private $addressFactory;
52
53			/**
54			* @param RepositoryInterface $userRepository
55			* @param SharedStorageInterface $sharedStorage
56			* @param FactoryInterface $userFactory
57			* @param FactoryInterface $customerFactory
58			* @param FactoryInterface $addressFactory
59			*/
60			public function __construct(
61			RepositoryInterface $userRepository,
62			SharedStorageInterface $sharedStorage,
63			FactoryInterface $userFactory,
64			FactoryInterface $customerFactory,
65			FactoryInterface $addressFactory
66			) {
67			$this->userRepository = $userRepository;
68			$this->sharedStorage = $sharedStorage;
69			$this->userFactory = $userFactory;
70			$this->customerFactory = $customerFactory;
71			$this->addressFactory = $addressFactory;
72			}
73
74			/**
75			* @Given there is user :email identified by :password
76			*/
77			public function thereIsUserIdentifiedBy($email, $password)
78			{
79			$customer = $this->createCustomer();
80			$user = $this->createUser($customer, $email, $password);
81
82			$this->sharedStorage->setCurrentResource('user', $user);
83			$this->userRepository->add($user);
84			}
85
86			/**
87			* @Given there is user :email identified by :password, with :country as shipping country
88			*/
89			public function thereIsUserWithShippingCountry($email, $password, $country)
90			{
91			$customer = $this->createCustomer();
92			$user = $this->createUser($customer, $email, $password);
93
94			$customer->setShippingAddress($this->createAddress($customer->getFirstName(), $customer->getLastName(), $country));
95
96			$this->sharedStorage->setCurrentResource('user', $user);
97			$this->userRepository->add($user);
98			}
99
100			/**
101			* @param string $firstName
102			* @param string $lastName
103			*
104			* @return CustomerInterface
105			*/
106			private function createCustomer($firstName = 'John', $lastName = 'Doe')
107			{
108			$customer = $this->customerFactory->createNew();
109			$customer->setFirstName($firstName);
110			$customer->setLastName($lastName);
111
112			return $customer;
113			}
114
115			/**
116			* @param CustomerInterface $customer
117			* @param string $email
118			* @param string $password
119			*
120			* @return UserInterface
121			*/
122			private function createUser(
123			CustomerInterface $customer,
124			$email = '[email protected]',
125			$password = 'testPassword'
126			) {
127			$user = $this->userFactory->createNew();
128
129			$user->setCustomer($customer);
130			$user->setUsername($email);
131			$user->setEmail($email);
132			$user->setPlainPassword($password);
133
134			return $user;
135			}
136
137			/**
138			* @param string $firstName
139			* @param string $lastName
140			* @param string $country
141			* @param string $street
142			* @param string $city
143			* @param string $postcode
144			*
145			* @return AddressInterface
146			*/
147			private function createAddress(
148			$firstName,
149			$lastName,
150			$country = 'United States',
151			$street = 'Jones St. 114',
152			$city = 'Paradise City',
153			$postcode = '99999'
154			) {
155			$address = $this->addressFactory->createNew();
156			$address->setFirstName($firstName);
157			$address->setLastName($lastName);
158			$address->setStreet($street);
159			$address->setCity($city);
160			$address->setPostcode($postcode);
161			$address->setCountryCode($this->getCountryCodeByEnglishCountryName($country));
162
163			return $address;
164			}
165
166			/**
167			* @param string $name
168			*
169			* @return string
170			*
171			* @throws \InvalidArgumentException If name is not found in country code registry.
172			*/
173			private function getCountryCodeByEnglishCountryName($name)
174			{
175			$names = Intl::getRegionBundle()->getCountryNames('en');
176			$countryCode = array_search(trim($name), $names);
177
178			if (null === $countryCode) {
179			throw new \InvalidArgumentException(sprintf(
180			'Country "%s" not found! Available names: %s.', $name, implode(', ', $names)
181			));
182			}
183
184			return $countryCode;
185			}
186			}
187

pamil / Sylius

Push — master ( 749f69...94328c )

UserContext::createAddress() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like