EncapsulationTestAwareTrait::setStub() - Code Metrics - Inspection of "Merge branch 'v0.9' into v0.10" - ongr-io/ElasticsearchBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — legacy ( c3f933 )

by Simonas

created 2016-05-26 08:10 UTC

EncapsulationTestAwareTrait::setStub() A

↳ Parent: EncapsulationTestAwareTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\ElasticsearchBundle\Test;

/**
 * A helper for testing setters/getters.
 *
 * Trait EncapsulationTestAwareTrait
 */
trait EncapsulationTestAwareTrait
{
    /**
     * @var string[] List of fields that should not be checked for tests.
     */
    private $ignoredFields = [];

    /**
     * @var mixed Stub object to test.
     */
    private $stub = null;

    /**
     * @return mixed
     */
    public function getStub()
    {
        return $this->stub;
    }

    /**
     * @param mixed $stub
     */
    public function setStub($stub)
    {
        $this->stub = $stub;
    }

    /**
     * Returns list of fields to test. Works as data provider.
     *
     * @return array
     */
    abstract public function getFieldsData();

    /**
     * Returns entity class name.
     *
     * @return string
     */
    abstract public function getClassName();

    /**
     * Returns list of fields that should not be checked for tests.
     *
     * @return array
     */
    protected function getIgnoredFields()
    {
        return $this->ignoredFields;
    }

    /**
     * Set list of fields that should not be checked for tests.
     *
     * @param string[] $fields
     */
    protected function setIgnoredFields(array $fields)
    {
        $this->ignoredFields = $fields;
    }

    /**
     * Set list of fields that should not be checked for tests.
     *
     * @param string $field
     */
    protected function addIgnoredField($field)
    {
        $this->ignoredFields[] = $field;
    }

    /**
     * Tests field setter and getter.
     *
     * @param string        $field
     * @param null|string   $type
     * @param null|string   $addMethod
     * @param null|string   $removeMethod
     * @param null|string[] $additionalSetter
     *
     * @dataProvider getFieldsData()
     */
    public function testSetterGetter(
        $field,
        $type = null,
        $addMethod = null,
        $removeMethod = null,
        $additionalSetter = null
    ) {
        /** @var \PHPUnit_Framework_TestCase|EncapsulationTestAwareTrait $this */

        $objectClass = $this->getClassName();

        $setter = 'set' . ucfirst($field);
        $getter = 'get' . ucfirst($field);

        if ($type === 'boolean') {
            $getter = 'is' . ucfirst($field);
        }

        $stub = $this->getStub();

        if ($stub === null) {
            $stub = $this->getMockForAbstractClass($objectClass);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        $this->validate($stub, $getter, $setter, $addMethod, $removeMethod, $additionalSetter);

        $expectedObject = $this->getExpectedVariable($type);

        if ($type && class_exists($type)) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $hash = spl_object_hash($expectedObject);

            if ($addMethod) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $stub->$addMethod($expectedObject);

                foreach ($stub->$getter() as $collectionObject) {
                    $this->assertEquals($hash, spl_object_hash($collectionObject));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                }
            }

            if ($removeMethod) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $stub->$removeMethod($expectedObject);
                $this->assertEquals(0, count($stub->$getter()));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            }

            $stub->$setter($expectedObject);
            $this->assertEquals($hash, spl_object_hash($stub->$getter()));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        } else {
            $stub->$setter($expectedObject);
            $this->assertEquals($expectedObject, $stub->$getter());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

            if ($addMethod) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $stub->$addMethod($this->getExpectedVariable(null));
                $this->assertEquals(2, count($stub->$getter()));
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            }
        }

        if ($additionalSetter) {
            $stub = $this->getMockForAbstractClass($objectClass);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            $setter = key($additionalSetter);
            $stub->$setter($additionalSetter[$setter][0]);
            $this->assertEquals($additionalSetter[$setter][1], $stub->$getter());
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }
    }

    /**
     * Tests if all entity fields are registered.
     */
    public function testAllEntityFieldsRegistered()
    {
        /** @var \PHPUnit_Framework_TestCase|EncapsulationTestAwareTrait $this */

        $reflect = new \ReflectionClass($this->getClassName());
        $properties = $reflect->getProperties();

        $fields = [];

        /** @var \ReflectionProperty $property */
        foreach ($properties as $property) {
            $fields[] = $property->getName();
        }

        $parentClass = $reflect->getParentClass();
        if ($parentClass) {
            $parentClassProperties = $parentClass->getProperties();
            /** @var \ReflectionProperty $property */
            foreach ($parentClassProperties as $property) {
                $this->addIgnoredField($property->getName());
            }
        }

        $traits = $reflect->getTraits();
        if ($traits) {

            foreach ($traits as $trait) {
                $traitProperties = $trait->getProperties();
                /** @var \ReflectionProperty $property */
                foreach ($traitProperties as $property) {
                    $this->addIgnoredField($property->getName());
                }
            }
        }

        $registeredFields = [];

        foreach ($this->getFieldsData() as $data) {
            $registeredFields[] = $data[0];
        }

        $diff = array_diff($fields, $registeredFields, $this->getIgnoredFields());

        if (count($diff) !== 0) {
            $this->fail(
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                sprintf(
                    'All entity fields must be registered in test. Please check field(s) "%s".',
                    implode('", "', $diff)
                )
            );
        }
    }

    /**
     * Return expected variable for compare.
     *
     * @param null|string $type
     *
     * @return object
     */
    protected function getExpectedVariable($type)
    {
        /** @var \PHPUnit_Framework_TestCase|EncapsulationTestAwareTrait $this */

        if ($type === null || $type == 'boolean') {
            return rand(0, 9999);
        } elseif ($type == 'string') {
            return 'string' . rand(0, 9999);
        } elseif ($type == 'array') {
            return [rand(0, 9999)];
        } elseif ($type == '\DateTime') {
            return new \DateTime();
        } elseif (class_exists($type) || interface_exists($type)) {
            return $this->getMockForAbstractClass($type);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        return null;
    }

    /**
     * Validate class before test.
     *
     * @param \PHPUnit_Framework_MockObject_MockObject $stub
     * @param null|string                              $getter
     * @param null|string                              $setter
     * @param null|string                              $addMethod
     * @param null|string                              $removeMethod
     * @param null|string[]                            $additionalSetter
     */
    protected function validate($stub, $getter, $setter, $addMethod, $removeMethod, $additionalSetter)
    {
        /** @var \PHPUnit_Framework_TestCase|EncapsulationTestAwareTrait $this */

        $this->assertTrue(method_exists($stub, $setter), "Method ${setter}() not found!");
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        $this->assertTrue(method_exists($stub, $getter), "Method ${getter}() not found!");
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        if ($addMethod) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $this->assertTrue(method_exists($stub, $addMethod), "Method ${addMethod}() not found!");
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        if ($removeMethod) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $this->assertTrue(method_exists($stub, $removeMethod), "Method ${removeMethod}() not found!");
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }

        if ($additionalSetter) {
            $setter = key($additionalSetter);
            $this->assertTrue(method_exists($stub, $setter), "Method ${setter}() not found!");
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        }
    }
}


1			<?php
2
3			/*
4			* This file is part of the ONGR package.
5			*
6			* (c) NFQ Technologies UAB <[email protected]>
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 ONGR\ElasticsearchBundle\Test;
13
14			/**
15			* A helper for testing setters/getters.
16			*
17			* Trait EncapsulationTestAwareTrait
18			*/
19			trait EncapsulationTestAwareTrait
20			{
21			/**
22			* @var string[] List of fields that should not be checked for tests.
23			*/
24			private $ignoredFields = [];
25
26			/**
27			* @var mixed Stub object to test.
28			*/
29			private $stub = null;
30
31			/**
32			* @return mixed
33			*/
34			public function getStub()
35			{
36			return $this->stub;
37			}
38
39			/**
40			* @param mixed $stub

ongr-io / ElasticsearchBundle

Push — legacy ( c3f933 )

EncapsulationTestAwareTrait::setStub() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like