EmbeddedDocumentSerializerTest - Code Metrics - doctrine/couchdb-odm - Measure and Improve Code Quality continuously with Scrutinizer

EmbeddedDocumentSerializerTest A
last analyzed 2019-03-12 00:12 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	309
Duplicated Lines	27.18 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

Metric	Value
wmc	10
lcom	1
cbo	8
dl	84
loc	309
rs	10
c	0
b	0
f	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	37	1
A	testCreateEmbeddedDocument()	15	15	1
A	testCreateEmbeddedNoTargetDocument()	0	23	1
A	testCreateNoMetadata()	16	16	1
A	testCreateThorwsWhenNoTargetNoMetadata()	0	14	1
A	testCreateMetadataConflict()	0	11	1
A	testSerialize()	25	25	1
A	testSerializeMismatchingTargetDocument()	28	28	1
A	testSerializeNoTargetDocument()	0	45	1
B	testIsChanged()	0	79	1

How to fix Duplicated Code

<?php


namespace Doctrine\Tests\ODM\CouchDB\Mapping;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ODM\CouchDB\Mapping\EmbeddedDocumentSerializer;
use Doctrine\ODM\CouchDB\Mapping\ClassMetadataFactory;
use Doctrine\ODM\CouchDB\Mapping\MetadataResolver\DoctrineResolver;
/*
    public function __constrct(DocumentManager $dm)
    public function serializeEmbeddedDocument($embeddedValue, $embeddedFieldMapping)
    public function createEmbeddedDocument($data, $embeddedFieldMapping)
    public function compare($jsonValue, $embeddedDocument)
*/

class EmbeddedDocumentSerializerTest extends \Doctrine\Tests\ODM\CouchDB\CouchDBFunctionalTestCase
{
    private $serializer;
    public function setUp()
    {
        $dm = $this->createDocumentManager();
        $this->metadataFactory = new ClassMetadataFactory($dm);
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $resolver = new DoctrineResolver();
        $this->serializer = new EmbeddedDocumentSerializer($this->metadataFactory, $resolver);

        $this->arrayDataFixture = array(
class MyClass { }

$x = new MyClass();
$x->foo = true;
            'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Embedded',
            'name' => 'embedded-1',
            'embeds' => array(
                'one' => array(
                    'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Nested',
                    'nestedName' => 'a111'
                    ),
                'two' => array(
                    'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Nested',
                    'nestedName' => 'a222'
                    )
                ),
            );
        $this->embedOneFixture = array(
class MyClass { }

$x = new MyClass();
$x->foo = true;
                'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Embedded',
                'name' => 'embeddedAnyOne',

            );
        $this->embedAnyFixture = array(
class MyClass { }

$x = new MyClass();
$x->foo = true;
            'any_1' => array(
                'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Embedded',
                'name' => 'embedAny_1'
                ),
            'any_2' => array(
                'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Nested',
                'nestedName' => 'embedAny_2'
                )
            );
    }

    public function testCreateEmbeddedDocument()

    {
        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $instance = $this->serializer->createEmbeddedDocument(
            $this->arrayDataFixture,
            $embedderMetadata->fieldMappings['embedded']);

        $this->assertNotNull($instance);
        $this->assertEquals('embedded-1', $instance->name);
        $this->assertTrue($instance->embeds->containsKey('one'));
        $this->assertTrue($instance->embeds->containsKey('two'));
        $this->assertCount(2, $instance->embeds);
    }

    public function testCreateEmbeddedNoTargetDocument()
    {
        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $instance = $this->serializer->createEmbeddedDocument(
            $this->embedOneFixture,
            $embedderMetadata->fieldMappings['embedAnyOne']);
        $this->assertInstanceOf('Doctrine\Tests\ODM\CouchDB\Mapping\Embedded', $instance);
        $this->assertEquals('embeddedAnyOne', $instance->name);

        $instance = $this->serializer->createEmbeddedDocument(
            $this->embedAnyFixture,
            $embedderMetadata->fieldMappings['embedAny']);
        $this->assertInstanceOf('Doctrine\Common\Collections\ArrayCollection',$instance);
        $this->assertCount(2, $instance);
        $this->assertTrue($instance->containsKey('any_1'));
        $this->assertTrue($instance->containsKey('any_2'));
        $this->assertInstanceOf('Doctrine\Tests\ODM\CouchDB\Mapping\Embedded', $instance['any_1']);
        $this->assertInstanceOf('Doctrine\Tests\ODM\CouchDB\Mapping\Nested', $instance['any_2']);
        $this->assertEquals('embedAny_1', $instance['any_1']->name);
        $this->assertEquals('embedAny_2', $instance['any_2']->nestedName);
    }

    /**
     * If there is no doctrine_metadata inside of an embedded array, classmetadata should help
     */
    public function testCreateNoMetadata()

    {
        unset($this->arrayDataFixture['doctrine_metadata']);

        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $instance = $this->serializer->createEmbeddedDocument(
            $this->arrayDataFixture,
            $embedderMetadata->fieldMappings['embedded']);
        $this->assertNotNull($instance);
        $this->assertEquals('embedded-1', $instance->name);
        $this->assertTrue($instance->embeds->containsKey('one'));
        $this->assertTrue($instance->embeds->containsKey('two'));
        $this->assertCount(2, $instance->embeds);
    }

    public function testCreateThorwsWhenNoTargetNoMetadata()
    {
        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $this->arrayDataFixture['embedAny'] = $this->embedAnyFixture;
        unset($this->arrayDataFixture['embedAny']['any_2']['doctrine_metadata']);

        $this->setExpectedException('InvalidArgumentException');
        $instance = $this->serializer->createEmbeddedDocument(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->arrayDataFixture,
            $embedderMetadata->fieldMappings['embedAny']);

    }

    public function testCreateMetadataConflict()
    {
        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $this->arrayDataFixture['embeds']['two']['type'] = 'Doctrine.Tests.ODM.CouchDB.Mapping.Embedded';
        $this->setExpectedException('InvalidArgumentException');
        $instance = $this->serializer->createEmbeddedDocument(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->arrayDataFixture,
            $embedderMetadata->fieldMappings['embedAny']);
    }

    public function testSerialize()

    {
        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $embedder = new Embedder;
        $embedder->id = 'embedder-1';

        $embedded = new Embedded;
        $embedded->name = 'embedded-1';

        $nested1 = new Nested;
        $nested1->nestedName = 'a111';
        $embedded->embeds['one'] = $nested1;
        $nested2 = new Nested;
        $nested2->nestedName = 'a222';
        $embedded->embeds['two'] = $nested2;

        $embedder->embedded = $embedded;
        $arrayData = $this->serializer->serializeEmbeddedDocument(
            $embedded,
            $embedderMetadata->fieldMappings['embedded']);

        $this->assertEquals($this->arrayDataFixture, $arrayData);
    }

    public function testSerializeMismatchingTargetDocument()

    {
        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $embedder = new Embedder;
        $embedder->id = 'embedder-1';

        $embedded = new Embedded;
        $embedded->name = 'embedded-1';

        $nested1 = new Nested;
        $nested1->nestedName = 'a111';
        $embedded->embeds['one'] = $nested1;
        $nested2 = new Embedded;
        $nested2->name = 'a222';
        $embedded->embeds['two'] = $nested2;

        $embedder->embedded = $embedded;

        $this->setExpectedException('InvalidArgumentException');
        $arrayData = $this->serializer->serializeEmbeddedDocument(
            $embedded,
            $embedderMetadata->fieldMappings['embedded']);

        $this->assertEquals($this->arrayDataFixture, $arrayData);

    }

    public function testSerializeNoTargetDocument()
    {
        $embedder = new Embedder;
        $embeddedMany_1 = new Embedded;
        $embeddedMany_1->name = 'embeddedMany_1';
        $embeddedMany_2 = new Nested;
        $embeddedMany_2->nestedName = 'embeddedMany_2';

        $embedder->embedAny = array($embeddedMany_1, $embeddedMany_2);

        $embedOne = new Nested;
        $embedOne->nestedName = 'embedOne';
        $embedder->embedAnyOne = $embedOne;

        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $arrayData = $this->serializer->serializeEmbeddedDocument(
            $embedder->embedAny,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $embedderMetadata->fieldMappings['embedAny']);

        $this->assertEquals(
            array(
                array(
                    'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Embedded',
                    'name' => 'embeddedMany_1',
                    'embeds' => array(),
                    ),
                array(
                    'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Nested',
                    'nestedName' => 'embeddedMany_2'
                    )
                ),
            $arrayData);

        $arrayData = $this->serializer->serializeEmbeddedDocument(
            $embedder->embedAnyOne,
            $embedderMetadata->fieldMappings['embedAnyOne']);
        $this->assertEquals(
            array(
                'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Nested',
                'nestedName' => 'embedOne'
                ),
            $arrayData);
    }

    public function testIsChanged()
    {
        $embedderMetadata =
            $this->metadataFactory->getMetadataFor('Doctrine\Tests\ODM\CouchDB\Mapping\Embedder');

        $fieldMapping = $embedderMetadata->fieldMappings['embedded'];
        $instance = $this->serializer->createEmbeddedDocument(
            $this->arrayDataFixture,
            $fieldMapping);

        $this->assertFalse($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $name = $instance->name;
        $instance->name = 'changed';
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $instance->name = $name;
        $this->assertFalse($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);


        $nestedName = $instance->embeds['one']->nestedName;
        $instance->embeds['one']->nestedName = 'changed';
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $instance->embeds['one']->nestedName = $nestedName;
        $this->assertFalse($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        // testing same data representation but different class
        $newNested = new Nested2;
        $newNested->nestedName = $nestedName;
        $instance->embeds['one'] = $newNested;
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $newNested = new Nested;
        $newNested->nestedName = $nestedName;
        $instance->embeds['one'] = $newNested;
        $this->assertFalse($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        // testing that to null a property is a change
        $instance->embeds['one']->nestedName = null;
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $instance->embeds['one']->nestedName = $nestedName;
        $this->assertFalse($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        // adding a new value is a change
        $instance->embeds['three'] = new Nested;
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        unset($instance->embeds['three']);
        $this->assertFalse($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        // removing one is a change
        unset($instance->embeds['two']);
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        // same number of embeds, but different key
        $instance->embeds['1'] = new Nested;
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);


        // -----------------------------------------------------------------------------
        //  reset things
        // -----------------------------------------------------------------------------
        $instance = $this->serializer->createEmbeddedDocument(
            $this->arrayDataFixture,
            $embedderMetadata->fieldMappings['embedded']);
        $this->assertFalse($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);


        // adding an EmbedOne type of embedded document
        // also tesing the no targetDocument case
        $instance->embedOne = new Nested;
        $this->assertTrue($this->serializer->isChanged($instance, $this->arrayDataFixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $fixture = $this->arrayDataFixture;
        $fixture['embedOne'] = array('doctrine_metadata'=>array('type'=>'Doctrine.Tests.ODM.CouchDB.Mapping.Nested'));
        $this->assertFalse($this->serializer->isChanged($instance, $fixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $instance->embedOne->nestedName = 'so this is nested';
        $this->assertTrue($this->serializer->isChanged($instance, $fixture, $fieldMapping));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
}




/**
 * @Document
 */
class Embedder {
    /**
     * @Id(strategy="ASSIGNED")
     */
    public $id;

    /**
     * @EmbedOne(targetDocument="Doctrine\Tests\ODM\CouchDB\Mapping\Embedded")
     */
    public $embedded;

    /**
     * @EmbedOne
     */
    public $embedAnyOne;

    /**
     * @EmbedMany
     */
    public $embedAny = array();
}

/**
 * @EmbeddedDocument
 */
class Embedded {
    /**
     * @Field
     */
    public $name;

    /**
     * @EmbedMany(targetDocument="Doctrine\Tests\ODM\CouchDB\Mapping\Nested")
     */
    public $embeds = array();

    /**
     * @EmbedOne
     */
    public $embedOne;
}

/**
 * @EmbeddedDocument
 */
class Nested {
    /**
     * @Field
     */
    public $nestedName;
}

/**
 * @EmbeddedDocument
 */
class Nested2 extends Nested {
    /**
     * @Field
     */
    public $nestedName;
}


1			<?php
2
3
4			namespace Doctrine\Tests\ODM\CouchDB\Mapping;
5
6			use Doctrine\Common\Collections\ArrayCollection;
7			use Doctrine\ODM\CouchDB\Mapping\EmbeddedDocumentSerializer;
8			use Doctrine\ODM\CouchDB\Mapping\ClassMetadataFactory;
9			use Doctrine\ODM\CouchDB\Mapping\MetadataResolver\DoctrineResolver;
10			/*
11			public function __constrct(DocumentManager $dm)
12			public function serializeEmbeddedDocument($embeddedValue, $embeddedFieldMapping)
13			public function createEmbeddedDocument($data, $embeddedFieldMapping)
14			public function compare($jsonValue, $embeddedDocument)
15			*/
16
17			class EmbeddedDocumentSerializerTest extends \Doctrine\Tests\ODM\CouchDB\CouchDBFunctionalTestCase
18			{
19			private $serializer;
20			public function setUp()
21			{
22			$dm = $this->createDocumentManager();
23			$this->metadataFactory = new ClassMetadataFactory($dm);
			0 ignored issues – show Bug introduced 2016-02-16 21:18 UTC by Report Bug Copy Issue Report The property `metadataFactory` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
24			$resolver = new DoctrineResolver();
25			$this->serializer = new EmbeddedDocumentSerializer($this->metadataFactory, $resolver);
26
27			$this->arrayDataFixture = array(
			0 ignored issues – show Bug introduced 2016-02-16 21:18 UTC by Report Bug Copy Issue Report The property `arrayDataFixture` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
28			'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Embedded',
29			'name' => 'embedded-1',
30			'embeds' => array(
31			'one' => array(
32			'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Nested',
33			'nestedName' => 'a111'
34			),
35			'two' => array(
36			'type' => 'Doctrine.Tests.ODM.CouchDB.Mapping.Nested',
37			'nestedName' => 'a222'
38			)

doctrine / couchdb-odm

EmbeddedDocumentSerializerTest A last analyzed 2019-03-12 00:12 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

10 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like

EmbeddedDocumentSerializerTest A
last analyzed 2019-03-12 00:12 UTC