MetadataFilterTest::testFilterWithString() - Code Metrics - Inspection of "Merge branch 'fix/#5715-fix-metadata-filtering-in-..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 07a9b1...fe8259 )

by Marco

created 2017-06-21 04:23 UTC

MetadataFilterTest::testFilterWithString() B

↳ Parent: MetadataFilterTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	32
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	23
nc	1
nop	0

<?php

namespace Doctrine\Tests\ORM\Tools\Console;

use Doctrine\ORM\Tools\Console\MetadataFilter;
use Doctrine\ORM\Tools\DisconnectedClassMetadataFactory;

/**
 * Tests for {@see \Doctrine\ORM\Tools\Console\MetadataFilter}
 *
 * @covers \Doctrine\ORM\Tools\Console\MetadataFilter
 */
class MetadataFilterTest extends \Doctrine\Tests\OrmTestCase
{
    /**
     * @var DisconnectedClassMetadataFactory
     */
    private $cmf;

    protected function setUp() : void
    {
        parent::setUp();

        $driver = $this->createAnnotationDriver();
        $em     = $this->_getTestEntityManager();

        $em->getConfiguration()->setMetadataDriverImpl($driver);

        $this->cmf = new DisconnectedClassMetadataFactory();
        $this->cmf->setEntityManager($em);
    }

    public function testFilterWithEmptyArray() : void
    {
        $originalMetadatas = [
            $metadataAaa = $this->cmf->getMetadataFor(MetadataFilterTestEntityAaa::class),
            $metadataBbb = $this->cmf->getMetadataFor(MetadataFilterTestEntityBbb::class),
        ];

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, []);

        $this->assertContains($metadataAaa, $metadatas);
        $this->assertContains($metadataBbb, $metadatas);
        $this->assertCount(count($originalMetadatas), $metadatas);
    }

    public function testFilterWithString() : void
    {
        $originalMetadatas = [
            $metadataAaa = $this->cmf->getMetadataFor(MetadataFilterTestEntityAaa::class),
            $metadataBbb = $this->cmf->getMetadataFor(MetadataFilterTestEntityBbb::class),
            $metadataCcc = $this->cmf->getMetadataFor(MetadataFilterTestEntityCcc::class),
        ];

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityAaa');

        $this->assertContains($metadataAaa, $metadatas);
        $this->assertNotContains($metadataBbb, $metadatas);
        $this->assertNotContains($metadataCcc, $metadatas);
        $this->assertCount(1, $metadatas);

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityBbb');

        $this->assertNotContains($metadataAaa, $metadatas);
        $this->assertContains($metadataBbb, $metadatas);
        $this->assertNotContains($metadataCcc, $metadatas);
        $this->assertCount(1, $metadatas);

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityCcc');

        $this->assertNotContains($metadataAaa, $metadatas);
        $this->assertNotContains($metadataBbb, $metadatas);
        $this->assertContains($metadataCcc, $metadatas);
        $this->assertCount(1, $metadatas);
    }

    public function testFilterWithString2() : void
    {
        $originalMetadatas = [
            $metadataFoo    = $this->cmf->getMetadataFor(MetadataFilterTestEntityFoo::class),
            $metadataFooBar = $this->cmf->getMetadataFor(MetadataFilterTestEntityFooBar::class),
            $metadataBar    = $this->cmf->getMetadataFor(MetadataFilterTestEntityBar::class),
        ];

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityFoo');

        $this->assertContains($metadataFoo, $metadatas);
        $this->assertContains($metadataFooBar, $metadatas);
        $this->assertNotContains($metadataBar, $metadatas);
        $this->assertCount(2, $metadatas);
    }

    public function testFilterWithArray() : void
    {
        $originalMetadatas = [
            $metadataAaa = $this->cmf->getMetadataFor(MetadataFilterTestEntityAaa::class),
            $metadataBbb = $this->cmf->getMetadataFor(MetadataFilterTestEntityBbb::class),
            $metadataCcc = $this->cmf->getMetadataFor(MetadataFilterTestEntityCcc::class),
        ];

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, [
            'MetadataFilterTestEntityAaa',
            'MetadataFilterTestEntityCcc',
        ]);

        $this->assertContains($metadataAaa, $metadatas);
        $this->assertNotContains($metadataBbb, $metadatas);
        $this->assertContains($metadataCcc, $metadatas);
        $this->assertCount(2, $metadatas);
    }

    public function testFilterWithRegex() : void
    {
        $originalMetadatas = [
            $metadataFoo    = $this->cmf->getMetadataFor(MetadataFilterTestEntityFoo::class),
            $metadataFooBar = $this->cmf->getMetadataFor(MetadataFilterTestEntityFooBar::class),
            $metadataBar    = $this->cmf->getMetadataFor(MetadataFilterTestEntityBar::class),
        ];

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, 'Foo$');

        $this->assertContains($metadataFoo, $metadatas);
        $this->assertNotContains($metadataFooBar, $metadatas);
        $this->assertNotContains($metadataBar, $metadatas);
        $this->assertCount(1, $metadatas);

        $metadatas = $originalMetadatas;
        $metadatas = MetadataFilter::filter($metadatas, 'Bar$');

        $this->assertNotContains($metadataFoo, $metadatas);
        $this->assertContains($metadataFooBar, $metadatas);
        $this->assertContains($metadataBar, $metadatas);
        $this->assertCount(2, $metadatas);
    }
}

/** @Entity */
class MetadataFilterTestEntityAaa
{
    /** @Id @Column */
    protected $id;
}

/** @Entity */
class MetadataFilterTestEntityBbb
{
    /** @Id @Column */
    protected $id;
}

/** @Entity */
class MetadataFilterTestEntityCcc
{
    /** @Id @Column */
    protected $id;
}

/** @Entity */
class MetadataFilterTestEntityFoo
{
    /** @Id @Column */
    protected $id;
}

/** @Entity */
class MetadataFilterTestEntityBar
{
    /** @Id @Column */
    protected $id;
}

/** @Entity */
class MetadataFilterTestEntityFooBar
{
    /** @Id @Column */
    protected $id;
}


1		<?php
2
3		namespace Doctrine\Tests\ORM\Tools\Console;
4
5		use Doctrine\ORM\Tools\Console\MetadataFilter;
6		use Doctrine\ORM\Tools\DisconnectedClassMetadataFactory;
7
8		/**
9		* Tests for {@see \Doctrine\ORM\Tools\Console\MetadataFilter}
10		*
11		* @covers \Doctrine\ORM\Tools\Console\MetadataFilter
12		*/
13		class MetadataFilterTest extends \Doctrine\Tests\OrmTestCase
14		{
15		/**
16		* @var DisconnectedClassMetadataFactory
17		*/
18		private $cmf;
19
20		protected function setUp() : void
21		{
22		parent::setUp();
23
24		$driver = $this->createAnnotationDriver();
25		$em = $this->_getTestEntityManager();
26
27		$em->getConfiguration()->setMetadataDriverImpl($driver);
28
29		$this->cmf = new DisconnectedClassMetadataFactory();
30		$this->cmf->setEntityManager($em);
31		}
32
33		public function testFilterWithEmptyArray() : void
34		{
35		$originalMetadatas = [
36		$metadataAaa = $this->cmf->getMetadataFor(MetadataFilterTestEntityAaa::class),
37		$metadataBbb = $this->cmf->getMetadataFor(MetadataFilterTestEntityBbb::class),
38		];
39
40		$metadatas = $originalMetadatas;
41		$metadatas = MetadataFilter::filter($metadatas, []);
42
43		$this->assertContains($metadataAaa, $metadatas);
44		$this->assertContains($metadataBbb, $metadatas);
45		$this->assertCount(count($originalMetadatas), $metadatas);
46		}
47
48		public function testFilterWithString() : void
49		{
50		$originalMetadatas = [
51		$metadataAaa = $this->cmf->getMetadataFor(MetadataFilterTestEntityAaa::class),
52		$metadataBbb = $this->cmf->getMetadataFor(MetadataFilterTestEntityBbb::class),
53		$metadataCcc = $this->cmf->getMetadataFor(MetadataFilterTestEntityCcc::class),
54		];
55
56		$metadatas = $originalMetadatas;
57		$metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityAaa');
58
59		$this->assertContains($metadataAaa, $metadatas);
60		$this->assertNotContains($metadataBbb, $metadatas);
61		$this->assertNotContains($metadataCcc, $metadatas);
62		$this->assertCount(1, $metadatas);
63
64		$metadatas = $originalMetadatas;
65		$metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityBbb');
66
67		$this->assertNotContains($metadataAaa, $metadatas);
68		$this->assertContains($metadataBbb, $metadatas);
69		$this->assertNotContains($metadataCcc, $metadatas);
70		$this->assertCount(1, $metadatas);
71
72		$metadatas = $originalMetadatas;
73		$metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityCcc');
74
75		$this->assertNotContains($metadataAaa, $metadatas);
76		$this->assertNotContains($metadataBbb, $metadatas);
77		$this->assertContains($metadataCcc, $metadatas);
78		$this->assertCount(1, $metadatas);
79		}
80
81	View Code Duplication	public function testFilterWithString2() : void
82		{
83		$originalMetadatas = [
84		$metadataFoo = $this->cmf->getMetadataFor(MetadataFilterTestEntityFoo::class),
85		$metadataFooBar = $this->cmf->getMetadataFor(MetadataFilterTestEntityFooBar::class),
86		$metadataBar = $this->cmf->getMetadataFor(MetadataFilterTestEntityBar::class),
87		];
88
89		$metadatas = $originalMetadatas;
90		$metadatas = MetadataFilter::filter($metadatas, 'MetadataFilterTestEntityFoo');
91
92		$this->assertContains($metadataFoo, $metadatas);
93		$this->assertContains($metadataFooBar, $metadatas);
94		$this->assertNotContains($metadataBar, $metadatas);
95		$this->assertCount(2, $metadatas);
96		}
97
98	View Code Duplication	public function testFilterWithArray() : void
99		{
100		$originalMetadatas = [
101		$metadataAaa = $this->cmf->getMetadataFor(MetadataFilterTestEntityAaa::class),
102		$metadataBbb = $this->cmf->getMetadataFor(MetadataFilterTestEntityBbb::class),
103		$metadataCcc = $this->cmf->getMetadataFor(MetadataFilterTestEntityCcc::class),
104		];
105
106		$metadatas = $originalMetadatas;
107		$metadatas = MetadataFilter::filter($metadatas, [
108		'MetadataFilterTestEntityAaa',
109		'MetadataFilterTestEntityCcc',
110		]);
111
112		$this->assertContains($metadataAaa, $metadatas);
113		$this->assertNotContains($metadataBbb, $metadatas);
114		$this->assertContains($metadataCcc, $metadatas);
115		$this->assertCount(2, $metadatas);
116		}
117
118		public function testFilterWithRegex() : void
119		{
120		$originalMetadatas = [
121		$metadataFoo = $this->cmf->getMetadataFor(MetadataFilterTestEntityFoo::class),
122		$metadataFooBar = $this->cmf->getMetadataFor(MetadataFilterTestEntityFooBar::class),
123		$metadataBar = $this->cmf->getMetadataFor(MetadataFilterTestEntityBar::class),
124		];
125
126		$metadatas = $originalMetadatas;
127		$metadatas = MetadataFilter::filter($metadatas, 'Foo$');
128
129		$this->assertContains($metadataFoo, $metadatas);
130		$this->assertNotContains($metadataFooBar, $metadatas);
131		$this->assertNotContains($metadataBar, $metadatas);
132		$this->assertCount(1, $metadatas);
133
134		$metadatas = $originalMetadatas;
135		$metadatas = MetadataFilter::filter($metadatas, 'Bar$');
136
137		$this->assertNotContains($metadataFoo, $metadatas);
138		$this->assertContains($metadataFooBar, $metadatas);
139		$this->assertContains($metadataBar, $metadatas);
140		$this->assertCount(2, $metadatas);
141		}
142		}
143
144		/** @Entity */
145		class MetadataFilterTestEntityAaa
146		{
147		/** @Id @Column */
148		protected $id;
149		}
150
151		/** @Entity */
152		class MetadataFilterTestEntityBbb
153		{
154		/** @Id @Column */
155		protected $id;
156		}
157
158		/** @Entity */
159		class MetadataFilterTestEntityCcc
160		{
161		/** @Id @Column */
162		protected $id;
163		}
164
165		/** @Entity */
166		class MetadataFilterTestEntityFoo
167		{
168		/** @Id @Column */
169		protected $id;
170		}
171
172		/** @Entity */
173		class MetadataFilterTestEntityBar
174		{
175		/** @Id @Column */
176		protected $id;
177		}
178
179		/** @Entity */
180		class MetadataFilterTestEntityFooBar
181		{
182		/** @Id @Column */
183		protected $id;
184		}
185

doctrine / orm

Push — master ( 07a9b1...fe8259 )

MetadataFilterTest::testFilterWithString() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like