StripeGatewayFactoryTest::testConfigurationForCheckoutSession() - Code Metrics - Inspection of "Merge pull request #30 from dragosprotung/fix/canc..." - FLUX-SE/PayumStripe - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 92d3db...cfe08d )

by Francis

created 2022-10-24 15:07 UTC

testConfigurationForCheckoutSession() A

↳ Parent: StripeGatewayFactoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	18
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	26
rs	9.6666

<?php

declare(strict_types=1);

namespace Tests\FluxSE\PayumStripe;

use FluxSE\PayumStripe\AbstractStripeGatewayFactory;
use FluxSE\PayumStripe\Action as GlobalAction;
use FluxSE\PayumStripe\Action\StripeCheckoutSession;
use FluxSE\PayumStripe\Action\StripeJs;
use FluxSE\PayumStripe\Action\StripeJs\Api\RenderStripeJsAction;
use FluxSE\PayumStripe\Api\KeysAwareInterface;
use FluxSE\PayumStripe\Api\StripeCheckoutSessionApiInterface;
use FluxSE\PayumStripe\StripeCheckoutSessionGatewayFactory;
use FluxSE\PayumStripe\StripeJsGatewayFactory;
use Payum\Core\Bridge\Spl\ArrayObject;
use Payum\Core\Exception\LogicException;
use Payum\Core\GatewayFactoryInterface;
use PHPUnit\Framework\TestCase;
use Stripe\PaymentIntent;

use function strpos;

final class StripeGatewayFactoryTest extends TestCase
{
    /**
     * @dataProvider gatewayList
     */
    public function testShouldBeInstanceOf(string $gatewayClass): void
    {
        /** @var AbstractStripeGatewayFactory $factory */
        $factory = new $gatewayClass();

        $this->assertInstanceOf(GatewayFactoryInterface::class, $factory);
        $this->assertInstanceOf(AbstractStripeGatewayFactory::class, $factory);
        $this->assertInstanceOf($gatewayClass, $factory);
    }

    /**
     * @dataProvider gatewayList
     */
    public function testShouldAllowCreateGatewayConfig(string $gatewayClass): void
    {
        /** @var AbstractStripeGatewayFactory $factory */
        $factory = new $gatewayClass();

        $config = $factory->createConfig();

        $this->assertIsArray($config);
        $this->assertNotEmpty($config);
    }

    /**
     * @dataProvider gatewayList
     */
    public function testShouldAddDefaultConfigPassedInConstructorWhileCreatingGatewayConfig(string $gatewayClass): void
    {
        $defaults = [
            'foo' => 'fooVal',
            'bar' => 'barVal',
        ];

        /** @var AbstractStripeGatewayFactory $factory */
        $factory = new $gatewayClass($defaults);

        $config = $factory->createConfig();

        $this->assertIsArray($config);

        $this->assertArrayHasKey('foo', $config);
        $this->assertEquals('fooVal', $config['foo']);

        $this->assertArrayHasKey('bar', $config);
        $this->assertEquals('barVal', $config['bar']);
    }

    /**
     * @dataProvider gatewayList
     */
    public function testShouldConfigContainDefaultOptions(string $gatewayClass): void
    {
        /** @var AbstractStripeGatewayFactory $factory */
        $factory = new $gatewayClass();

        $config = $factory->createConfig();

        $this->assertIsArray($config);

        $this->assertArrayHasKey('payum.default_options', $config);
        $this->assertArrayHasKey('publishable_key', $config['payum.default_options']);
        $this->assertEquals('', $config['payum.default_options']['publishable_key']);
        $this->assertArrayHasKey('secret_key', $config['payum.default_options']);
        $this->assertEquals('', $config['payum.default_options']['secret_key']);
        $this->assertArrayHasKey('webhook_secret_keys', $config['payum.default_options']);
        $this->assertEquals([], $config['payum.default_options']['webhook_secret_keys']);
        if (StripeCheckoutSessionGatewayFactory::class === $gatewayClass) {
            $this->assertArrayHasKey('payment_method_types', $config['payum.default_options']);
            $this->assertEquals(
                StripeCheckoutSessionApiInterface::DEFAULT_PAYMENT_METHOD_TYPES,
                $config['payum.default_options']['payment_method_types']
            );
        }
    }

    /**
     * @dataProvider gatewayList
     */
    public function testShouldThrowIfRequiredOptionsNotPassed(string $gatewayClass): void
    {
        /** @var AbstractStripeGatewayFactory $factory */
        $factory = new $gatewayClass();

        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('The publishable_key, secret_key, webhook_secret_keys fields are required.');

        $factory->create();
    }

    /**
     * @dataProvider gatewayList
     */
    public function testShouldConfigurePaths(string $gatewayClass): void
    {
        /** @var AbstractStripeGatewayFactory $factory */
        $factory = new $gatewayClass();

        $config = $factory->createConfig();

        $this->assertIsArray($config);
        $this->assertNotEmpty($config);

        $this->assertIsArray($config['payum.paths']);
        $this->assertNotEmpty($config['payum.paths']);

        $this->assertArrayHasKey('PayumCore', $config['payum.paths']);
        $this->assertStringEndsWith('Resources/views', $config['payum.paths']['PayumCore']);
        $this->assertFileExists($config['payum.paths']['PayumCore']);

        $this->assertArrayHasKey('FluxSEPayumStripe', $config['payum.paths']);
        $this->assertStringEndsWith('Resources/views', $config['payum.paths']['FluxSEPayumStripe']);
        $this->assertFileExists($config['payum.paths']['FluxSEPayumStripe']);
    }

    /**
     * @dataProvider gatewayList
     */
    public function testShouldAcceptDefaultOptions(string $gatewayClass): void
    {
        $defaults = [
            'publishable_key' => '123456',
            'secret_key' => '123456',
            'webhook_secret_keys' => [
                '123456',
            ],
            'payment_method_types' => ['card'],
        ];

        /** @var AbstractStripeGatewayFactory $factory */
        $factory = new $gatewayClass($defaults);

        $config = $factory->createConfig();

        $this->assertEquals($defaults['publishable_key'], $config['publishable_key']);
        $this->assertEquals($defaults['secret_key'], $config['secret_key']);
        $this->assertEquals($defaults['webhook_secret_keys'], $config['webhook_secret_keys']);
        $this->assertEquals($defaults['payment_method_types'], $config['payment_method_types']);

        // Allow to update the credentials
        $newCredentials = new ArrayObject([
            'payum.required_options' => $config['payum.required_options'],
            'publishable_key' => '654321',
            'secret_key' => '654321',
            'webhook_secret_keys' => [
                '654321',
            ],
            'payment_method_types' => ['card'],
        ]);
        $api = $config['payum.api']($newCredentials);
        $this->assertInstanceOf(KeysAwareInterface::class, $api);
    }

    public function gatewayList(): array
    {
        return [
            [StripeCheckoutSessionGatewayFactory::class],
            [StripeJsGatewayFactory::class],
        ];
    }

    public function testConfigurationForCheckoutSession(): void
    {
        $factory = new StripeCheckoutSessionGatewayFactory();

        $config = $factory->createConfig();

        $this->assertIsArray($config);

        $this->assertArrayHasKey('payum.factory_name', $config);
        $this->assertEquals('stripe_checkout_session', $config['payum.factory_name']);

        $this->assertArrayHasKey('payum.factory_title', $config);
        $this->assertEquals('Stripe Checkout Session', $config['payum.factory_title']);

        $actualActions = $this->configuredPayumActions($config);

        $this->assertArrayHasKey('payum.action.capture', $actualActions);
        $this->assertEquals(new StripeCheckoutSession\CaptureAction(), $actualActions['payum.action.capture']);
        $this->assertArrayHasKey('payum.action.authorize', $actualActions);
        $this->assertEquals(new StripeCheckoutSession\AuthorizeAction(), $actualActions['payum.action.authorize']);
        $this->assertArrayHasKey('payum.action.convert_payment', $actualActions);
        $this->assertEquals(new StripeCheckoutSession\ConvertPaymentAction(), $actualActions['payum.action.convert_payment']);
        $this->assertArrayHasKey('payum.action.redirect_to_checkout', $actualActions);
        $this->assertEquals(new StripeCheckoutSession\Api\RedirectToCheckoutAction(), $actualActions['payum.action.redirect_to_checkout']);
        $this->assertArrayHasKey('payum.action.cancel.payment_intent.automatic', $actualActions);
        $this->assertEquals(new StripeCheckoutSession\CancelAction(), $actualActions['payum.action.cancel.payment_intent.automatic']);
    }

    public function testConfigurationForStripeJs(): void
    {
        $factory = new StripeJsGatewayFactory();

        $config = $factory->createConfig();

        $this->assertIsArray($config);

        $this->assertArrayHasKey('payum.factory_name', $config);
        $this->assertEquals('stripe_js', $config['payum.factory_name']);

        $this->assertArrayHasKey('payum.factory_title', $config);
        $this->assertEquals('Stripe JS', $config['payum.factory_title']);

        $actualActions = $this->configuredPayumActions($config);

        $this->assertArrayHasKey('payum.action.cancel.payment_intent.manual', $actualActions);
        $this->assertEquals(new GlobalAction\CancelAction(), $actualActions['payum.action.cancel.payment_intent.manual']);
        $this->assertArrayHasKey('payum.action.capture', $actualActions);
        $this->assertEquals(new StripeJs\CaptureAction(), $actualActions['payum.action.capture']);
        $this->assertArrayHasKey('payum.action.authorize', $actualActions);
        $this->assertEquals(new StripeJs\AuthorizeAction(), $actualActions['payum.action.authorize']);
        $this->assertArrayHasKey('payum.action.convert_payment', $actualActions);
        $this->assertEquals(new StripeJs\ConvertPaymentAction(), $actualActions['payum.action.convert_payment']);
        $this->assertArrayHasKey('payum.action.render_stripe_js.payment_intent', $actualActions);
        $this->assertEquals($config['payum.template.render_stripe_js.payment_intent'], $config['payum.template.render_stripe_js.payment_intent']);
        /** @var RenderStripeJsAction $payAction */
        $payAction = $config['payum.action.render_stripe_js.payment_intent'](ArrayObject::ensureArrayObject($config));
        $this->assertInstanceOf(RenderStripeJsAction::class, $payAction);
        $this->assertEquals(PaymentIntent::class, $payAction->getApiResourceClass());
        $this->assertEquals($config['payum.template.render_stripe_js.payment_intent'], $payAction->getTemplateName());
    }

    private function configuredPayumActions(array $config): array
    {
        $actions = [];
        foreach ($config as $key => $value) {
            if (strpos($key, 'payum.action.') === 0) {
                $actions[$key] = $value;
            }
        }

        return $actions;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Tests\FluxSE\PayumStripe;
6
7			use FluxSE\PayumStripe\AbstractStripeGatewayFactory;
8			use FluxSE\PayumStripe\Action as GlobalAction;
9			use FluxSE\PayumStripe\Action\StripeCheckoutSession;
10			use FluxSE\PayumStripe\Action\StripeJs;
11			use FluxSE\PayumStripe\Action\StripeJs\Api\RenderStripeJsAction;
12			use FluxSE\PayumStripe\Api\KeysAwareInterface;
13			use FluxSE\PayumStripe\Api\StripeCheckoutSessionApiInterface;
14			use FluxSE\PayumStripe\StripeCheckoutSessionGatewayFactory;
15			use FluxSE\PayumStripe\StripeJsGatewayFactory;
16			use Payum\Core\Bridge\Spl\ArrayObject;
17			use Payum\Core\Exception\LogicException;
18			use Payum\Core\GatewayFactoryInterface;
19			use PHPUnit\Framework\TestCase;
20			use Stripe\PaymentIntent;
21
22			use function strpos;
23
24			final class StripeGatewayFactoryTest extends TestCase
25			{
26			/**
27			* @dataProvider gatewayList
28			*/
29			public function testShouldBeInstanceOf(string $gatewayClass): void
30			{
31			/** @var AbstractStripeGatewayFactory $factory */
32			$factory = new $gatewayClass();
33
34			$this->assertInstanceOf(GatewayFactoryInterface::class, $factory);
35			$this->assertInstanceOf(AbstractStripeGatewayFactory::class, $factory);
36			$this->assertInstanceOf($gatewayClass, $factory);
37			}
38
39			/**
40			* @dataProvider gatewayList
41			*/
42			public function testShouldAllowCreateGatewayConfig(string $gatewayClass): void
43			{
44			/** @var AbstractStripeGatewayFactory $factory */
45			$factory = new $gatewayClass();
46
47			$config = $factory->createConfig();
48
49			$this->assertIsArray($config);
50			$this->assertNotEmpty($config);
51			}
52
53			/**
54			* @dataProvider gatewayList
55			*/
56			public function testShouldAddDefaultConfigPassedInConstructorWhileCreatingGatewayConfig(string $gatewayClass): void
57			{
58			$defaults = [
59			'foo' => 'fooVal',
60			'bar' => 'barVal',
61			];
62
63			/** @var AbstractStripeGatewayFactory $factory */
64			$factory = new $gatewayClass($defaults);
65
66			$config = $factory->createConfig();
67
68			$this->assertIsArray($config);
69
70			$this->assertArrayHasKey('foo', $config);
71			$this->assertEquals('fooVal', $config['foo']);
72
73			$this->assertArrayHasKey('bar', $config);
74			$this->assertEquals('barVal', $config['bar']);
75			}
76
77			/**
78			* @dataProvider gatewayList
79			*/
80			public function testShouldConfigContainDefaultOptions(string $gatewayClass): void
81			{
82			/** @var AbstractStripeGatewayFactory $factory */
83			$factory = new $gatewayClass();
84
85			$config = $factory->createConfig();
86
87			$this->assertIsArray($config);
88
89			$this->assertArrayHasKey('payum.default_options', $config);
90			$this->assertArrayHasKey('publishable_key', $config['payum.default_options']);
91			$this->assertEquals('', $config['payum.default_options']['publishable_key']);
92			$this->assertArrayHasKey('secret_key', $config['payum.default_options']);
93			$this->assertEquals('', $config['payum.default_options']['secret_key']);
94			$this->assertArrayHasKey('webhook_secret_keys', $config['payum.default_options']);
95			$this->assertEquals([], $config['payum.default_options']['webhook_secret_keys']);
96			if (StripeCheckoutSessionGatewayFactory::class === $gatewayClass) {
97			$this->assertArrayHasKey('payment_method_types', $config['payum.default_options']);
98			$this->assertEquals(
99			StripeCheckoutSessionApiInterface::DEFAULT_PAYMENT_METHOD_TYPES,
100			$config['payum.default_options']['payment_method_types']
101			);
102			}
103			}
104
105			/**
106			* @dataProvider gatewayList
107			*/
108			public function testShouldThrowIfRequiredOptionsNotPassed(string $gatewayClass): void
109			{
110			/** @var AbstractStripeGatewayFactory $factory */
111			$factory = new $gatewayClass();
112
113			$this->expectException(LogicException::class);
114			$this->expectExceptionMessage('The publishable_key, secret_key, webhook_secret_keys fields are required.');
115
116			$factory->create();
117			}
118
119			/**
120			* @dataProvider gatewayList
121			*/
122			public function testShouldConfigurePaths(string $gatewayClass): void
123			{
124			/** @var AbstractStripeGatewayFactory $factory */
125			$factory = new $gatewayClass();
126
127			$config = $factory->createConfig();
128
129			$this->assertIsArray($config);
130			$this->assertNotEmpty($config);
131
132			$this->assertIsArray($config['payum.paths']);
133			$this->assertNotEmpty($config['payum.paths']);
134
135			$this->assertArrayHasKey('PayumCore', $config['payum.paths']);
136			$this->assertStringEndsWith('Resources/views', $config['payum.paths']['PayumCore']);
137			$this->assertFileExists($config['payum.paths']['PayumCore']);
138
139			$this->assertArrayHasKey('FluxSEPayumStripe', $config['payum.paths']);
140			$this->assertStringEndsWith('Resources/views', $config['payum.paths']['FluxSEPayumStripe']);
141			$this->assertFileExists($config['payum.paths']['FluxSEPayumStripe']);
142			}
143
144			/**
145			* @dataProvider gatewayList
146			*/
147			public function testShouldAcceptDefaultOptions(string $gatewayClass): void
148			{
149			$defaults = [
150			'publishable_key' => '123456',
151			'secret_key' => '123456',
152			'webhook_secret_keys' => [
153			'123456',
154			],
155			'payment_method_types' => ['card'],
156			];
157
158			/** @var AbstractStripeGatewayFactory $factory */
159			$factory = new $gatewayClass($defaults);
160
161			$config = $factory->createConfig();
162
163			$this->assertEquals($defaults['publishable_key'], $config['publishable_key']);
164			$this->assertEquals($defaults['secret_key'], $config['secret_key']);
165			$this->assertEquals($defaults['webhook_secret_keys'], $config['webhook_secret_keys']);
166			$this->assertEquals($defaults['payment_method_types'], $config['payment_method_types']);
167
168			// Allow to update the credentials
169			$newCredentials = new ArrayObject([
170			'payum.required_options' => $config['payum.required_options'],
171			'publishable_key' => '654321',
172			'secret_key' => '654321',
173			'webhook_secret_keys' => [
174			'654321',
175			],
176			'payment_method_types' => ['card'],
177			]);
178			$api = $config['payum.api']($newCredentials);
179			$this->assertInstanceOf(KeysAwareInterface::class, $api);
180			}
181
182			public function gatewayList(): array
183			{
184			return [
185			[StripeCheckoutSessionGatewayFactory::class],
186			[StripeJsGatewayFactory::class],
187			];
188			}
189
190			public function testConfigurationForCheckoutSession(): void
191			{
192			$factory = new StripeCheckoutSessionGatewayFactory();
193
194			$config = $factory->createConfig();
195
196			$this->assertIsArray($config);
197
198			$this->assertArrayHasKey('payum.factory_name', $config);
199			$this->assertEquals('stripe_checkout_session', $config['payum.factory_name']);
200
201			$this->assertArrayHasKey('payum.factory_title', $config);
202			$this->assertEquals('Stripe Checkout Session', $config['payum.factory_title']);
203
204			$actualActions = $this->configuredPayumActions($config);
205
206			$this->assertArrayHasKey('payum.action.capture', $actualActions);
207			$this->assertEquals(new StripeCheckoutSession\CaptureAction(), $actualActions['payum.action.capture']);
208			$this->assertArrayHasKey('payum.action.authorize', $actualActions);
209			$this->assertEquals(new StripeCheckoutSession\AuthorizeAction(), $actualActions['payum.action.authorize']);
210			$this->assertArrayHasKey('payum.action.convert_payment', $actualActions);
211			$this->assertEquals(new StripeCheckoutSession\ConvertPaymentAction(), $actualActions['payum.action.convert_payment']);
212			$this->assertArrayHasKey('payum.action.redirect_to_checkout', $actualActions);
213			$this->assertEquals(new StripeCheckoutSession\Api\RedirectToCheckoutAction(), $actualActions['payum.action.redirect_to_checkout']);
214			$this->assertArrayHasKey('payum.action.cancel.payment_intent.automatic', $actualActions);
215			$this->assertEquals(new StripeCheckoutSession\CancelAction(), $actualActions['payum.action.cancel.payment_intent.automatic']);
216			}
217
218			public function testConfigurationForStripeJs(): void
219			{
220			$factory = new StripeJsGatewayFactory();
221
222			$config = $factory->createConfig();
223
224			$this->assertIsArray($config);
225
226			$this->assertArrayHasKey('payum.factory_name', $config);
227			$this->assertEquals('stripe_js', $config['payum.factory_name']);
228
229			$this->assertArrayHasKey('payum.factory_title', $config);
230			$this->assertEquals('Stripe JS', $config['payum.factory_title']);
231
232			$actualActions = $this->configuredPayumActions($config);
233
234			$this->assertArrayHasKey('payum.action.cancel.payment_intent.manual', $actualActions);
235			$this->assertEquals(new GlobalAction\CancelAction(), $actualActions['payum.action.cancel.payment_intent.manual']);
236			$this->assertArrayHasKey('payum.action.capture', $actualActions);
237			$this->assertEquals(new StripeJs\CaptureAction(), $actualActions['payum.action.capture']);
238			$this->assertArrayHasKey('payum.action.authorize', $actualActions);
239			$this->assertEquals(new StripeJs\AuthorizeAction(), $actualActions['payum.action.authorize']);
240			$this->assertArrayHasKey('payum.action.convert_payment', $actualActions);
241			$this->assertEquals(new StripeJs\ConvertPaymentAction(), $actualActions['payum.action.convert_payment']);
242			$this->assertArrayHasKey('payum.action.render_stripe_js.payment_intent', $actualActions);
243			$this->assertEquals($config['payum.template.render_stripe_js.payment_intent'], $config['payum.template.render_stripe_js.payment_intent']);
244			/** @var RenderStripeJsAction $payAction */
245			$payAction = $config['payum.action.render_stripe_js.payment_intent'](ArrayObject::ensureArrayObject($config));
246			$this->assertInstanceOf(RenderStripeJsAction::class, $payAction);
247			$this->assertEquals(PaymentIntent::class, $payAction->getApiResourceClass());
248			$this->assertEquals($config['payum.template.render_stripe_js.payment_intent'], $payAction->getTemplateName());
249			}
250
251			private function configuredPayumActions(array $config): array
252			{
253			$actions = [];
254			foreach ($config as $key => $value) {
255			if (strpos($key, 'payum.action.') === 0) {
256			$actions[$key] = $value;
257			}
258			}
259
260			return $actions;
261			}
262			}
263

FLUX-SE / PayumStripe

Push — master ( 92d3db...cfe08d )

testConfigurationForCheckoutSession() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like