HoneypotFormExtensionTest::testFinishWithEmptyFormFactory() - Code Metrics - Inspection of "[TEST] Fixed CS" - core23/AntiSpamBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 26bccb...f3fc54 )

by Christian

created 2019-03-31 15:34 UTC

testFinishWithEmptyFormFactory() A

↳ Parent: HoneypotFormExtensionTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	30
rs	9.44
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

/*
 * (c) Christian Gripp <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Core23\AntiSpamBundle\Tests\Form\Extension;

use Core23\AntiSpamBundle\Form\EventListener\AntiSpamHoneypotListener;
use Core23\AntiSpamBundle\Form\Extension\HoneypotFormExtension;
use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use RuntimeException;
use Symfony\Component\Form\Extension\Core\Type\FormType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Form\FormConfigInterface;
use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Form\FormTypeExtensionInterface;
use Symfony\Component\Form\FormView;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Translation\TranslatorInterface;

class HoneypotFormExtensionTest extends TestCase
{
    private $translator;

    protected function setUp()
    {
        $this->translator   = $this->prophesize(TranslatorInterface::class);
    }

    public function testItIsInstantiable(): void
    {
        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );

        $this->assertInstanceOf(FormTypeExtensionInterface::class, $extension);
    }

    public function testBuildForm(): void
    {
        $factory = $this->prophesize(FormFactoryInterface::class);

        $builder = $this->prophesize(FormBuilderInterface::class);
        $builder->getFormFactory()
            ->willReturn($factory)
        ;
        $builder->setAttribute('antispam_honeypot_factory', $factory->reveal())
            ->willReturn($builder)
            ->shouldBeCalled()
        ;
        $builder->addEventSubscriber(Argument::type(AntiSpamHoneypotListener::class))
            ->willReturn($builder)
            ->shouldBeCalled()
        ;

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->buildForm($builder->reveal(), [
            'antispam_honeypot'       => true,
            'antispam_honeypot_class' => 'spamclass',
            'antispam_honeypot_field' => 'hidden-field',
        ]);
    }

    public function testBuildFormWithDisabledAntispam(): void
    {
        $builder = $this->prophesize(FormBuilderInterface::class);

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->buildForm($builder->reveal(), [
            'antispam_honeypot'       => false,
            'antispam_honeypot_class' => 'spamclass',
            'antispam_honeypot_field' => 'hidden-field',
        ]);

        $this->assertTrue(true);
    }

    public function testFinishView(): void
    {
        $parenView = $this->prophesize(FormView::class);

        $view = $this->prophesize(FormView::class);

        $parentForm = $this->prophesize(FormInterface::class);
        $parentForm->createView($view)
            ->willReturn($parenView)
        ;

        $formFactory = $this->prophesize(FormFactoryInterface::class);
        $formFactory
            ->createNamed('hidden-field', TextType::class, null, [
                'mapped'   => false,
                'label'    => false,
                'required' => false,
                'attr'     => [
                    'class' => 'spamclass',
                ],
            ])
            ->willReturn($parentForm)
        ;

        $config = $this->prophesize(FormConfigInterface::class);
        $config->getAttribute('antispam_honeypot_factory')
            ->willReturn($formFactory)
        ;

        $form = $this->prophesize(FormInterface::class);
        $form->has('hidden-field')
            ->willReturn(false)
        ;
        $form->getConfig()
            ->willReturn($config)
        ;

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->finishView($view->reveal(), $form->reveal(), [
            'compound'                => true,
            'antispam_honeypot'       => true,
            'antispam_honeypot_class' => 'spamclass',
            'antispam_honeypot_field' => 'hidden-field',
        ]);

        $this->assertSame($parenView->reveal(), $view->children['hidden-field']);
    }

    public function testFinishWithEmptyClass(): void
    {
        $parenView = $this->prophesize(FormView::class);

        $view = $this->prophesize(FormView::class);

        $parentForm = $this->prophesize(FormInterface::class);
        $parentForm->createView($view)
            ->willReturn($parenView)
        ;

        $formFactory = $this->prophesize(FormFactoryInterface::class);
        $formFactory
            ->createNamed('hidden-field', TextType::class, null, [
                'mapped'   => false,
                'label'    => false,
                'required' => false,
                'attr'     => [
                    'style' => 'display:none',
                ],
            ])
            ->willReturn($parentForm)
        ;

        $config = $this->prophesize(FormConfigInterface::class);
        $config->getAttribute('antispam_honeypot_factory')
            ->willReturn($formFactory)
        ;

        $form = $this->prophesize(FormInterface::class);
        $form->has('hidden-field')
            ->willReturn(false)
        ;
        $form->getConfig()
            ->willReturn($config)
        ;

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->finishView($view->reveal(), $form->reveal(), [
            'compound'                => true,
            'antispam_honeypot'       => true,
            'antispam_honeypot_field' => 'hidden-field',
        ]);

        $this->assertSame($parenView->reveal(), $view->children['hidden-field']);
    }

    public function testFinishWithExistingField(): void
    {
        $this->expectException(RuntimeException::class);
        $this->expectExceptionMessage('Honeypot field "hidden-field" is already used.');

        $view = $this->prophesize(FormView::class);

        $form = $this->prophesize(FormInterface::class);
        $form->has('hidden-field')
            ->willReturn(true)
        ;

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->finishView($view->reveal(), $form->reveal(), [
            'compound'                => true,
            'antispam_honeypot'       => true,
            'antispam_honeypot_field' => 'hidden-field',
        ]);
    }

    public function testFinishWithEmptyFormFactory(): void
    {
        $this->expectException(RuntimeException::class);
        $this->expectExceptionMessage('Invalid form factory to create a honeyput.');

        $view = $this->prophesize(FormView::class);

        $config = $this->prophesize(FormConfigInterface::class);
        $config->getAttribute('antispam_honeypot_factory')
            ->willReturn(null)
        ;

        $form = $this->prophesize(FormInterface::class);
        $form->has('hidden-field')
            ->willReturn(false)
        ;
        $form->getConfig()
            ->willReturn($config)
        ;

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->finishView($view->reveal(), $form->reveal(), [
            'compound'                => true,
            'antispam_honeypot'       => true,
            'antispam_honeypot_field' => 'hidden-field',
        ]);
    }

    public function testFinishViewForChildForm(): void
    {
        $view         = $this->prophesize(FormView::class);
        $view->parent = $this->prophesize(FormView::class)->reveal();
        $form         = $this->prophesize(FormInterface::class);

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->finishView($view->reveal(), $form->reveal(), [
            'compound'                => true,
            'antispam_honeypot'       => true,
            'antispam_honeypot_class' => 'spamclass',
            'antispam_honeypot_field' => 'hidden-field',
        ]);

        $this->assertTrue(true);
    }

    public function testFinishViewWithDisbaledAntispam(): void
    {
        $view = $this->prophesize(FormView::class);
        $form = $this->prophesize(FormInterface::class);

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            []
        );
        $extension->finishView($view->reveal(), $form->reveal(), [
            'compound'                => true,
            'antispam_honeypot'       => false,
            'antispam_honeypot_class' => 'spamclass',
            'antispam_honeypot_field' => 'hidden-field',
        ]);

        $this->assertTrue(true);
    }

    public function testConfigureOptions(): void
    {
        $resolver = new OptionsResolver();

        $extension = new HoneypotFormExtension(
            $this->translator->reveal(),
            [
                'global' => true,
                'class'  => 'my-class',
                'field'  => 'a-field',
            ]
        );
        $extension->configureOptions($resolver);

        $result = $resolver->resolve();

        $this->assertTrue($result['antispam_honeypot']);
        $this->assertSame('my-class', $result['antispam_honeypot_class']);
        $this->assertSame('a-field', $result['antispam_honeypot_field']);
    }

    public function testExtendedTypes(): void
    {
        $this->assertSame([FormType::class], HoneypotFormExtension::getExtendedTypes());
    }
}


1			<?php
2
3			/*
4			* (c) Christian Gripp <[email protected]>
5			*
6			* For the full copyright and license information, please view the LICENSE
7			* file that was distributed with this source code.
8			*/
9
10			namespace Core23\AntiSpamBundle\Tests\Form\Extension;
11
12			use Core23\AntiSpamBundle\Form\EventListener\AntiSpamHoneypotListener;
13			use Core23\AntiSpamBundle\Form\Extension\HoneypotFormExtension;
14			use PHPUnit\Framework\TestCase;
15			use Prophecy\Argument;
16			use RuntimeException;
17			use Symfony\Component\Form\Extension\Core\Type\FormType;
18			use Symfony\Component\Form\Extension\Core\Type\TextType;
19			use Symfony\Component\Form\FormBuilderInterface;
20			use Symfony\Component\Form\FormConfigInterface;
21			use Symfony\Component\Form\FormFactoryInterface;
22			use Symfony\Component\Form\FormInterface;
23			use Symfony\Component\Form\FormTypeExtensionInterface;
24			use Symfony\Component\Form\FormView;
25			use Symfony\Component\OptionsResolver\OptionsResolver;
26			use Symfony\Component\Translation\TranslatorInterface;
27
28			class HoneypotFormExtensionTest extends TestCase
29			{
30			private $translator;
31
32			protected function setUp()
33			{
34			$this->translator = $this->prophesize(TranslatorInterface::class);
35			}
36
37			public function testItIsInstantiable(): void
38			{
39			$extension = new HoneypotFormExtension(
40			$this->translator->reveal(),
41			[]
42			);
43
44			$this->assertInstanceOf(FormTypeExtensionInterface::class, $extension);
45			}
46
47			public function testBuildForm(): void
48			{
49			$factory = $this->prophesize(FormFactoryInterface::class);
50
51			$builder = $this->prophesize(FormBuilderInterface::class);
52			$builder->getFormFactory()
53			->willReturn($factory)
54			;
55			$builder->setAttribute('antispam_honeypot_factory', $factory->reveal())
56			->willReturn($builder)
57			->shouldBeCalled()
58			;
59			$builder->addEventSubscriber(Argument::type(AntiSpamHoneypotListener::class))
60			->willReturn($builder)
61			->shouldBeCalled()
62			;
63
64			$extension = new HoneypotFormExtension(
65			$this->translator->reveal(),
66			[]
67			);
68			$extension->buildForm($builder->reveal(), [
69			'antispam_honeypot' => true,
70			'antispam_honeypot_class' => 'spamclass',
71			'antispam_honeypot_field' => 'hidden-field',
72			]);
73			}
74
75			public function testBuildFormWithDisabledAntispam(): void
76			{
77			$builder = $this->prophesize(FormBuilderInterface::class);
78
79			$extension = new HoneypotFormExtension(
80			$this->translator->reveal(),
81			[]
82			);
83			$extension->buildForm($builder->reveal(), [
84			'antispam_honeypot' => false,
85			'antispam_honeypot_class' => 'spamclass',
86			'antispam_honeypot_field' => 'hidden-field',
87			]);
88
89			$this->assertTrue(true);
90			}
91
92			public function testFinishView(): void
93			{
94			$parenView = $this->prophesize(FormView::class);
95
96			$view = $this->prophesize(FormView::class);
97
98			$parentForm = $this->prophesize(FormInterface::class);
99			$parentForm->createView($view)
100			->willReturn($parenView)
101			;
102
103			$formFactory = $this->prophesize(FormFactoryInterface::class);
104			$formFactory
105			->createNamed('hidden-field', TextType::class, null, [
106			'mapped' => false,
107			'label' => false,
108			'required' => false,
109			'attr' => [
110			'class' => 'spamclass',
111			],
112			])
113			->willReturn($parentForm)
114			;
115
116			$config = $this->prophesize(FormConfigInterface::class);
117			$config->getAttribute('antispam_honeypot_factory')
118			->willReturn($formFactory)
119			;
120
121			$form = $this->prophesize(FormInterface::class);
122			$form->has('hidden-field')
123			->willReturn(false)
124			;
125			$form->getConfig()
126			->willReturn($config)
127			;
128
129			$extension = new HoneypotFormExtension(
130			$this->translator->reveal(),
131			[]
132			);
133			$extension->finishView($view->reveal(), $form->reveal(), [
134			'compound' => true,
135			'antispam_honeypot' => true,
136			'antispam_honeypot_class' => 'spamclass',
137			'antispam_honeypot_field' => 'hidden-field',
138			]);
139
140			$this->assertSame($parenView->reveal(), $view->children['hidden-field']);
141			}
142
143			public function testFinishWithEmptyClass(): void
144			{
145			$parenView = $this->prophesize(FormView::class);
146
147			$view = $this->prophesize(FormView::class);
148
149			$parentForm = $this->prophesize(FormInterface::class);
150			$parentForm->createView($view)
151			->willReturn($parenView)
152			;
153
154			$formFactory = $this->prophesize(FormFactoryInterface::class);
155			$formFactory
156			->createNamed('hidden-field', TextType::class, null, [
157			'mapped' => false,
158			'label' => false,
159			'required' => false,
160			'attr' => [
161			'style' => 'display:none',
162			],
163			])
164			->willReturn($parentForm)
165			;
166
167			$config = $this->prophesize(FormConfigInterface::class);
168			$config->getAttribute('antispam_honeypot_factory')
169			->willReturn($formFactory)
170			;
171
172			$form = $this->prophesize(FormInterface::class);
173			$form->has('hidden-field')
174			->willReturn(false)
175			;
176			$form->getConfig()
177			->willReturn($config)
178			;
179
180			$extension = new HoneypotFormExtension(
181			$this->translator->reveal(),
182			[]
183			);
184			$extension->finishView($view->reveal(), $form->reveal(), [
185			'compound' => true,
186			'antispam_honeypot' => true,
187			'antispam_honeypot_field' => 'hidden-field',
188			]);
189
190			$this->assertSame($parenView->reveal(), $view->children['hidden-field']);
191			}
192
193			public function testFinishWithExistingField(): void
194			{
195			$this->expectException(RuntimeException::class);
196			$this->expectExceptionMessage('Honeypot field "hidden-field" is already used.');
197
198			$view = $this->prophesize(FormView::class);
199
200			$form = $this->prophesize(FormInterface::class);
201			$form->has('hidden-field')
202			->willReturn(true)
203			;
204
205			$extension = new HoneypotFormExtension(
206			$this->translator->reveal(),
207			[]
208			);
209			$extension->finishView($view->reveal(), $form->reveal(), [
210			'compound' => true,
211			'antispam_honeypot' => true,
212			'antispam_honeypot_field' => 'hidden-field',
213			]);
214			}
215
216			public function testFinishWithEmptyFormFactory(): void
217			{
218			$this->expectException(RuntimeException::class);
219			$this->expectExceptionMessage('Invalid form factory to create a honeyput.');
220
221			$view = $this->prophesize(FormView::class);
222
223			$config = $this->prophesize(FormConfigInterface::class);
224			$config->getAttribute('antispam_honeypot_factory')
225			->willReturn(null)
226			;
227
228			$form = $this->prophesize(FormInterface::class);
229			$form->has('hidden-field')
230			->willReturn(false)
231			;
232			$form->getConfig()
233			->willReturn($config)
234			;
235
236			$extension = new HoneypotFormExtension(
237			$this->translator->reveal(),
238			[]
239			);
240			$extension->finishView($view->reveal(), $form->reveal(), [
241			'compound' => true,
242			'antispam_honeypot' => true,
243			'antispam_honeypot_field' => 'hidden-field',
244			]);
245			}
246
247			public function testFinishViewForChildForm(): void
248			{
249			$view = $this->prophesize(FormView::class);
250			$view->parent = $this->prophesize(FormView::class)->reveal();
251			$form = $this->prophesize(FormInterface::class);
252
253			$extension = new HoneypotFormExtension(
254			$this->translator->reveal(),
255			[]
256			);
257			$extension->finishView($view->reveal(), $form->reveal(), [
258			'compound' => true,
259			'antispam_honeypot' => true,
260			'antispam_honeypot_class' => 'spamclass',
261			'antispam_honeypot_field' => 'hidden-field',
262			]);
263
264			$this->assertTrue(true);
265			}
266
267			public function testFinishViewWithDisbaledAntispam(): void
268			{
269			$view = $this->prophesize(FormView::class);
270			$form = $this->prophesize(FormInterface::class);
271
272			$extension = new HoneypotFormExtension(
273			$this->translator->reveal(),
274			[]
275			);
276			$extension->finishView($view->reveal(), $form->reveal(), [
277			'compound' => true,
278			'antispam_honeypot' => false,
279			'antispam_honeypot_class' => 'spamclass',
280			'antispam_honeypot_field' => 'hidden-field',
281			]);
282
283			$this->assertTrue(true);
284			}
285
286			public function testConfigureOptions(): void
287			{
288			$resolver = new OptionsResolver();
289
290			$extension = new HoneypotFormExtension(
291			$this->translator->reveal(),
292			[
293			'global' => true,
294			'class' => 'my-class',
295			'field' => 'a-field',
296			]
297			);
298			$extension->configureOptions($resolver);
299
300			$result = $resolver->resolve();
301
302			$this->assertTrue($result['antispam_honeypot']);
303			$this->assertSame('my-class', $result['antispam_honeypot_class']);
304			$this->assertSame('a-field', $result['antispam_honeypot_field']);
305			}
306
307			public function testExtendedTypes(): void
308			{
309			$this->assertSame([FormType::class], HoneypotFormExtension::getExtendedTypes());
310			}
311			}
312

core23 / AntiSpamBundle

GitHub Access Token became invalid

Push — master ( 26bccb...f3fc54 )

testFinishWithEmptyFormFactory() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like