Sensorario\Resources\Test\Resources\ResourceTest

Complexity

Total Complexity

38

Size/Duplication

Total Lines	896
Duplicated Lines	28.79 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes	2
Bugs	0	Features	0

38 Methods

Rating	Name	Duplication	Size	Complexity
A	testPropertyExists()	0	8	1
A	testHasProperties()	0	12	1
A	propertiesProvider()	0	7	1
A	testAllowAccessToProperties()	0	11	1
A	testAllowAccessToPropertiesThroughDefaultValue()	0	9	1
A	testThroughExceptionWhenNoValuesProvided()	0	5	1
A	testPropertyCouldBeAScalar()	0	6	1
A	testPropertyCouldBeTheRightnObject()	0	6	1
B	testPropertiesAccessor()	0	30	1
A	testWhenCondition()	0	7	1
A	testExceptionIsThrownWhenNotYetImplementedMethodIsCalled()	0	17	1
B	testNotAllowedFieldThroghRuntimeException()	24	24	1
A	testMissingMandatoryFieldThroghRuntimeException()	0	21	1
B	testMandatoryFieldsAreAuthomaticallyAllowed()	0	28	1
B	testExceptionMessageInCaseOfEmptyPropertyName()	0	28	1
A	testFactoryMethods()	0	4	1
B	testCanHaveDefaultValues()	0	27	1
A	testResourcesComposition()	0	16	1
A	testMandatoryValuesWhenPropertyAssumeAValue()	0	6	1
A	testAnExceptionIsThrownIfAPropertyIsAnObjectButClassInNotDefinedInRuleMethod()	0	6	1
B	testDefaultValuesTwo()	0	32	1
B	testDefaultValues()	0	30	1
A	testResourceShouldBeCreatedViaContainer()	0	22	1
B	testDependentMandatoryProperties()	36	36	1
A	testMandatoryConstraintsAreAutomaticallyAllowed()	17	17	1
B	testAllowedValues()	28	28	1
A	testRewriteRulesWithCondition()	0	52	1
B	testAcceptRangeOfValues()	28	28	1
B	testAllResourcesInheritGlobalAllowingConfiguration()	0	40	1
B	testHasMandatoryPropertiesWhenAnotherOneHasAParticularValue()	35	35	1
B	testEmailValidationFails()	0	26	1
A	testIntegersCanBeDefinedWithNumberRule()	0	22	1
B	testEmailValidation()	0	31	1
B	testRulesKnowsIfRuleIsDefinedOrNot()	31	31	1
A	rules()	0	7	1
B	testProvideRule()	33	33	1
A	testUndefinedObject()	0	6	1
B	testDenyCustomValidatorDifferentFromEmail()	26	26	1

<?php

/**
 * This file is part of sensorario/resources repository
 *
 * (c) Simone Gentili <sensorario@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sensorario\Resources\Test\Resources;

use DateInterval;
use DateTime;
use PHPUnit\Framework\TestCase;
use Resources\Bar;
use Resources\BirthDay;
use Resources\UndefinedObject;
use Resources\ComposedResource;
use Resources\Foo;
use Resources\MandatoryDependency;
use Resources\ResourceWithoutRules;
use Resources\SomeApiRequest;
use Resources\UserCreationEvent;
use Sensorario\Resources\Configurator;
use Sensorario\Resources\Container;
use Sensorario\Resources\Resource;
use Sensorario\Resources\Validators\ResourcesValidator;

final class ResourceTest extends TestCase
{
    /**
     * @expectedException              \Sensorario\Resources\Exceptions\UndefinedMethodException
     * @expectedExceptionMessageRegExp #Method `.*::.*()` is not yet implemented#
     */
    public function testExceptionIsThrownWhenNotYetImplementedMethodIsCalled()
    {
        $configurator = new Configurator(
            'empty_resource',
            new Container([
                'resources' => [
                    'empty_resource' => [
                        'constraints' => [],
                    ],
                ],
            ])
        );

        $resource = Resource::box([], $configurator);

        $resource->notYetImplementedMethod();
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\NotAllowedKeyException
     * @expectedExceptionMessageRegExp #Key `.*::.*` is not allowed#
     */
    public function testNotAllowedFieldThroghRuntimeException()

This method seems to be duplicated in your project.

    {
        $configurator = new Configurator(
            'empty_resource',
            new Container([
                'resources' => [
                    'empty_resource' => [
                        'constraints' => [
                            'allowedValues' => [
                                'name',
                                'surname',
                            ],
                        ],
                    ],
                ],
            ])
        );

        $resource = Resource::box([

$resource is not used, you could remove the assignment.

            'name' => 'Simone',
            'surname' => 'Gentili',
            'not allowed' => 'foo',
        ], $configurator);
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\PropertyException
     * @expectedExceptionMessageRegExp #Property `.*::.*` is mandatory but not set#
     */
    public function testMissingMandatoryFieldThroghRuntimeException()
    {
        $configurator = new Configurator(
            'empty_resource',
            new Container([
                'resources' => [
                    'empty_resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'name',
                            ],
                        ],
                    ],
                ],
            ])
        );

        $resource = Resource::box([

$resource is not used, you could remove the assignment.

            'surname' => 'Gentili',
        ], $configurator);
    }

    public function testMandatoryFieldsAreAuthomaticallyAllowed()
    {
        $configurator = new Configurator(
            'empty_resource',
            new Container([
                'resources' => [
                    'empty_resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'name',
                                'surname',
                            ],
                        ],
                    ],
                ],
            ])
        );

        $resource = Resource::box([
            'name'    => 'Simone',
            'surname' => 'Gentili',
        ], $configurator);

        $this->assertEquals(
            'Simone',
            $resource->name()
        );
    }

    /**
     * @expectedException        Sensorario\Resources\Exceptions\PropertyNameEmptyException
     * @expectedExceptionMessage Oops! Property name requested is empty string!!
     */
    public function testExceptionMessageInCaseOfEmptyPropertyName()
    {
        $configurator = new Configurator(
            'empty_resource',
            new Container([
                'resources' => [
                    'empty_resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'name',
                                'surname',
                            ],
                        ],
                    ],
                ],
            ])
        );

        $resource = Resource::box([
            'name'    => 'Simone',
            'surname' => 'Gentili',
        ], $configurator);

        $this->assertEquals(
            'Simone',
            $resource->get('')
        );
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\FactoryMethodException
     * @expectedExceptionMessageRegExp #Invalid factory method#
     */
    public function testFactoryMethods()
    {
        Resource::invalidFactoryName();
    }

    public function testCanHaveDefaultValues()
    {
        $configurator = new Configurator(
            'empty_resource',
            new Container([
                'resources' => [
                    'empty_resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'name',
                            ],
                            'defaults' => [
                                'name' => 'Firefox',
                            ],
                        ],
                    ],
                ],
            ])
        );

        $resource = Resource::box([], $configurator);

        $this->assertEquals(
            'Firefox',
            $resource->name()
        );
    }

    public function testPropertyExists()
    {
        $foo = Bar::box();

        $this->assertFalse(
            $foo->hasProperty('nonExistentProperty')
        );
    }

    /** @dataProvider propertiesProvider */
    public function testHasProperties($result, $properties)
    {
        $foo = UserCreationEvent::box([
            'type' => 'human',
            'username' => 'Sensorario',
        ]);

        $this->assertSame(
            $result,
            $foo->hasProperties($properties)
        );
    }

    public function propertiesProvider()
    {
        return [
            [false, ['buppa']],
            [true, ['type', 'username']],
        ];
    }

    public function testAllowAccessToProperties()
    {
        $foo = Bar::box([
            'name' => 'Firefox'
        ]);

        $this->assertEquals(
            'Firefox',
            $foo->get('name')
        );
    }

    public function testAllowAccessToPropertiesThroughDefaultValue()
    {
        $foo = Bar::box();

        $this->assertEquals(
            'Firefox',
            $foo->get('name')
        );
    }

    /**
     * @expectedException Sensorario\Resources\Exceptions\NoValuesException
     */
    public function testThroughExceptionWhenNoValuesProvided()
    {
        $foo = Bar::box();
        $foo->get('foo');
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\AttributeTypeException
     * @expectedExceptionMessageRegExp #Attribute `.*` must be of type `array`#
     */
    public function testPropertyCouldBeAScalar()
    {
        SomeApiRequest::box([
            'fields' => 'not a scalar',
        ]);
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\NotObjectTypeFoundException
     * @expectedExceptionMessageRegExp #Attribute `.*` must be an object of type DateTime#
     */
    public function testPropertyCouldBeTheRightnObject()
    {
        BirthDay::box([
            'date' => new DateInterval('P1D'),
        ]);
    }

    public function testPropertiesAccessor()
    {
        $aSpecificRule = [ 'custom-validator' => 'email' ];

$aSpecificRule is not used, you could remove the assignment.

        $configurator = new Configurator(
            'email-resource',
            new Container([
                'resources' => [
                    'email-resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'name',
                            ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'name' => 'Simone',
        ];

        $resource = Resource::box($properties, $configurator);

        $this->assertEquals(
            $properties,
            $resource->properties()
        );
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\PropertyNotSetException
     * @expectedExceptionMessageRegExp #Property `.*::.*` is mandatory but not set#
     */
    public function testWhenCondition()
    {
        MandatoryDependency::box([
            'foo' => 'bar',
            'mandatory_mello' => 'bar',
        ]);
    }

    public function testResourcesComposition()
    {
        $composition = ComposedResource::box([
            'credentials' => Foo::box([
                'name' => 'Sam'
            ]),
        ]);

        $this->assertEquals([
            'credentials' => [
                'name' => 'Sam',
            ]
        ],
        $composition->properties()
    );
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\PropertyException
     * @expectedExceptionMessageRegExp #When property `.*` has value `.*` also `.*` is mandatory#
     */
    public function testMandatoryValuesWhenPropertyAssumeAValue()
    {
        UserCreationEvent::box([
            'type' => 'guest',
        ]);
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\PropertyWithoutRuleException
     * @expectedExceptionMessageRegExp #When property `.*` is an object class, must be defined in Resources::rules()#
     */
    public function testAnExceptionIsThrownIfAPropertyIsAnObjectButClassInNotDefinedInRuleMethod()
    {
        ResourceWithoutRules::box([
            'datetime' => new DateTime(),
        ]);
    }

    public function testDefaultValuesTwo()
    {
        $resource = new Resource(
            [],
            new ResourcesValidator()
        );

        $this->assertEquals(
            [],
            $resource->allowed()
        );

        $resource->applyConfiguration(
            new Configurator(
                'bar',
                new Container([
                    'resources' => [
                        'bar' => [
                            'constraints' => [
                                'allowed' => [ 'allowed_property_name' ],
                            ]
                        ],
                    ],
                ])
            )
        );

        $this->assertEquals(
            [ 'allowed_property_name' ],
            $resource->allowed('bar')

The call to Resource::allowed() has too many arguments starting with 'bar'.

        );
    }

    public function testDefaultValues()
    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'resources' => [
                    'foo' => [
                        'constraints' => [
                            'mandatory' => [
                                'ciambella',
                            ],
                            'defaults' => [
                                'ciambella' => '42',
                            ],
                        ]
                    ],
                ],
            ])
        );

        $resource = Resource::box(
            [],
            $configurator
        );

        $this->assertEquals(
            '42',
            $resource->get('ciambella')
        );
    }

    public function testResourceShouldBeCreatedViaContainer()
    {
        $container = new Container([
            'resources' => [
                'foo' => [
                    'constraints' => [
                        'allowed' => [ 'allowed_property_name' ],
                    ]
                ],
                'unused_resource' => [
                    'constraints' => [
                        'allowed' => [ 'bar' ],
                    ]
                ],
            ],
        ]);

        $this->assertEquals(
            [ 'allowed_property_name' ],
            $container->allowed('foo')
        );
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\PropertyNotSetException
     * @expectedExceptionMessageRegExp #Property `.*::.*` is mandatory but not set#
     */
    public function testDependentMandatoryProperties()

This method seems to be duplicated in your project.

    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'resources' => [
                    'foo' => [
                        'constraints' => [
                            'allowed' => [
                                'bar',
                            ],
                            'mandatory' => [
                                'mandatory_property_name',
                                'foo' => [
                                    'when' => [
                                        'property' => 'bar',
                                        'condition' => 'is_present',
                                    ]
                                ],
                            ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'mandatory_property_name' => '42',
            'bar' => 'beer',
        ];

        Resource::box(
            $properties,
            $configurator
        );
    }

    public function testMandatoryConstraintsAreAutomaticallyAllowed()

This method seems to be duplicated in your project.

    {
        $container = new Container([
            'resources' => [
                'foo' => [
                    'constraints' => [
                        'mandatory' => [ 'mandatory_property' ],
                    ]
                ],
            ],
        ]);

        $this->assertEquals(
            [ 'mandatory_property' ],
            $container->allowed('foo')
        );
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\UnexpectedValueException
     * @expectedExceptionMessageRegExp #Value `.*` is not allowed for key `.*`. Allowed values are:#
     */
    public function testAllowedValues()

This method seems to be duplicated in your project.

    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'resources' => [
                    'foo' => [
                        'constraints' => [
                            'allowed' => [ 'user_type' ],
                            'allowedValues' => [
                                'user_type' => [
                                    4, 
                                    7,
                                ],
                            ],
                        ],
                    ],
                ],
            ])
        );

        $properties = [ 'user_type' => 3 ];

        Resource::box(
            $properties,
            $configurator
        );
    }

    public function testRewriteRulesWithCondition()
    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'resources' => [
                    'foo' => [
                        'rewrite' => [
                            'width' => [
                                'set' => [
                                    'equals_to' => 'height',
                                ],
                                'when' => [
                                    'greater_than' => 'height',
                                ],
                            ],
                        ],
                        'constraints' => [
                            'allowed' => [
                                'width',
                                'height',
                            ],
                        ],
                    ], 
                ],
            ])
        );
        $properties = [
            'width'  => 3000,
            'height' => 400,
        ];

        $box = Resource::box(
            $properties,
            $configurator
        );

        $overwritternProperties = [
            'width'  => 400,
            'height' => 400,
        ];

        $overWrittenBox = Resource::box(
            $overwritternProperties,
            $configurator
        );

        $this->assertEquals(
            $overWrittenBox,
            $box
        );
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\OutOfRangeException
     * @expectedExceptionMessageRegExp #Value `.*` is out of range: `.*`.#
     */
    public function testAcceptRangeOfValues()

This method seems to be duplicated in your project.

    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'resources' => [
                    'foo' => [
                        'constraints' => [
                            'allowedRanges' => [
                                'age' => [
                                    'more_than' => 3,
                                    'less_than' => 42,
                                ],
                            ],
                            'allowed' => [
                                'age'
                            ],
                        ],
                    ],
                ],
            ])
        );

        Resource::box(
            [ 'age' => 2 ],
            $configurator
        );
    }

    public function testAllResourcesInheritGlobalAllowingConfiguration()
    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'globals' => [
                    'allowed' => [
                        'width',
                        'height',
                    ],
                ],
                'resources' => [
                    'foo' => [
                        'constraints' => [
                            'allowed' => [
                                'foo_size',
                            ],
                        ],
                    ], 
                    'bar' => [
                        'constraints' => [
                            'allowed' => [
                                'bar_size',
                            ],
                        ],
                    ], 
                ],
            ])
        );

        $resource = Resource::box(
            [],
            $configurator
        );

        $this->assertEquals(
            ['foo_size', 'width', 'height'],
            $resource->allowed()
        );
    }

    /**
     * @expectedException Sensorario\Resources\Exceptions\PropertyException
     */
    public function testHasMandatoryPropertiesWhenAnotherOneHasAParticularValue()

This method seems to be duplicated in your project.

    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'resources' => [
                    'foo' => [
                        'constraints' => [
                            'allowed' => [
                                'bar',
                            ],
                            'mandatory' => [
                                'mandatory_property_name',
                                'foo' => [
                                    'when' => [
                                        'property' => 'bar',
                                        'has_value' => '42',
                                    ]
                                ],
                            ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'bar' => '42',
        ];

        Resource::box(
            $properties,
            $configurator
        );
    }

    /**
     * @expectedException Sensorario\Resources\Exceptions\EmailException
     */
    public function testEmailValidationFails()
    {
        $configurator = new Configurator(
            'email-resource',
            new Container([
                'resources' => [
                    'email-resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'first-email',
                            ],
                            'rules' => [
                                'first-email' => [ 'custom-validator' => 'email' ],
                            ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'first-email' => 'invalid email',
        ];

        Resource::box($properties, $configurator);
    }

    /**
     * @expectedException              Sensorario\Resources\Exceptions\WrongPropertyValueException
     * @expectedExceptionMessageRegExp #Property .* must be an integer!#
     */
    public function testIntegersCanBeDefinedWithNumberRule()
    {
        $configurator = new Configurator(
            'type-with-number',
            new Container([
                'resources' => [
                    'type-with-number' => [
                        'constraints' => [
                            'mandatory' => [ 'a-magic-number' ],
                            'rules' => [ 'a-magic-number' => [ 'scalar' => 'integer' ] ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'a-magic-number' => '42',
        ];

        $resource = Resource::box($properties, $configurator);

$resource is not used, you could remove the assignment.

    }

    public function testEmailValidation()
    {
        $configurator = new Configurator(
            'email-resource',
            new Container([
                'resources' => [
                    'email-resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'first-email',
                            ],
                            'rules' => [
                                'first-email' => [ 'custom-validator' => 'email' ],
                            ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'first-email' => 'sensorario@gmail.com',
        ];

        $resource = Resource::box($properties, $configurator);

        $this->assertEquals(
            'sensorario@gmail.com',
            $resource->get('first-email')
        );
    }

    /** @dataProvider rules */
    public function testRulesKnowsIfRuleIsDefinedOrNot($expectation, $ruleName)

This method seems to be duplicated in your project.

    {
        $configurator = new Configurator(
            'email-resource',
            new Container([
                'resources' => [
                    'email-resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'first-email',
                            ],
                            'rules' => [
                                'first-email' => [ 'custom-validator' => 'email' ],
                            ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'first-email' => 'sensorario@gmail.com',
        ];

        $resource = Resource::box($properties, $configurator);

        $this->assertEquals(
            $expectation,
            $resource->isRuleDefinedFor($ruleName)
        );
    }

    public function rules()
    {
        return [
            [true, 'first-email'],
            [false, 'non-existent-field-name'],
        ];
    }

    public function testProvideRule()

This method seems to be duplicated in your project.

    {
        $aSpecificRule = [ 'custom-validator' => 'email' ];

        $configurator = new Configurator(
            'email-resource',
            new Container([
                'resources' => [
                    'email-resource' => [
                        'constraints' => [
                            'mandatory' => [
                                'first-email',
                            ],
                            'rules' => [
                                'first-email' => $aSpecificRule,
                            ],
                        ]
                    ],
                ],
            ])
        );

        $properties = [
            'first-email' => 'sensorario@gmail.com',
        ];

        $resource = Resource::box($properties, $configurator);

        $this->assertEquals(
            $aSpecificRule,
            $resource->getRule('first-email')->asArray()
        );
    }

    /**
     * @expectedException Sensorario\Resources\Exceptions\PropertyWithoutRuleException
     * @expectedExceptionMessage Property date is an object but is not defined in rules
     */
    public function testUndefinedObject()
    {
        UndefinedObject::box([
            'date' => new \stdClass(),
        ]);
    }

    /**
     * @expectedException \Sensorario\Resources\Exceptions\InvalidCustomValidatorException
     * @expectedExceptionMessage Oops! `custom-validator` custom validator is not available. Only email is.
     */
    public function testDenyCustomValidatorDifferentFromEmail()

This method seems to be duplicated in your project.

    {
        $configurator = new Configurator(
            'foo',
            new Container([
                'resources' => [
                    'foo' => [
                        'constraints' => [
                            'allowed' => [
                                'property_name',
                            ],
                            'rules' => [
                                'property_name' => [
                                    'custom-validator' => 'foo',
                                ]
                            ]
                        ],
                    ],
                ]
            ])
        );

        Resource::box([
            'property_name' => '42',
        ], $configurator);
    }

}