ObjectUrlTest::testUrlSetters() - Code Metrics - Inspection of "Moved the object type handling to application laye..." - apparat/object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b7f961...9dee4e )

by Joschi

created 2016-06-06 17:33 UTC

ObjectUrlTest::testUrlSetters() B

↳ Parent: ObjectUrlTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	28
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	1
eloc	21
c	3
b	0
f	0
nc	1
nop	0
dl	0
loc	28
rs	8.8571

<?php

/**
 * apparat-object
 *
 * @category    Apparat
 * @package     Apparat\Object
 * @subpackage  Apparat\Object\Infrastructure
 * @author      Joschi Kuphal <[email protected]> / @jkphl
 * @copyright   Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 * @license     http://opensource.org/licenses/MIT The MIT License (MIT)
 */

/***********************************************************************************
 *  The MIT License (MIT)
 *
 *  Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy of
 *  this software and associated documentation files (the "Software"), to deal in
 *  the Software without restriction, including without limitation the rights to
 *  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 *  the Software, and to permit persons to whom the Software is furnished to do so,
 *  subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in all
 *  copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 *  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 *  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 *  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 *  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ***********************************************************************************/

namespace Apparat\Object\Tests;

use Apparat\Kernel\Ports\Kernel;
use Apparat\Object\Domain\Model\Object\Id;
use Apparat\Object\Domain\Model\Object\Revision;
use Apparat\Object\Domain\Model\Object\Type;
use Apparat\Object\Domain\Model\Path\ObjectUrl;
use Apparat\Object\Domain\Repository\Service;
use Apparat\Object\Ports\Object;

/**
 * Object URL tests
 *
 * @package Apparat\Object
 * @subpackage ApparatTest
 */
class ObjectUrlTest extends AbstractDisabledAutoconnectorTest
{
    /**
     * Example query fragment
     *
     * @var string
     */
    const QUERY_FRAGMENT = '?param=value#fragment';
    /**
     * Repository URL
     *
     * @var string
     */
    const REPOSITORY_URL = '/repo';
    /**
     * Example path
     *
     * @var string
     */
    const PATH = '/2015/10/01/36704-event/36704-1';
    /**
     * Example path (draft mode)
     *
     * @var string
     */
    const DRAFT_PATH = '/2015/10/01/36704-event/.36704';
    /**
     * Example URL
     *
     * @var string
     */
    const URL = self::REPOSITORY_URL.self::PATH.self::QUERY_FRAGMENT;
    /**
     * Example remote repository URL
     *
     * @var string
     */
    const REMOTE_REPOSITORY_URL = 'http://apparat:[email protected]:80';
    /**
     * Example remote URL
     *
     * @var string
     */
    const REMOTE_URL = self::REMOTE_REPOSITORY_URL.self::PATH.self::QUERY_FRAGMENT;

    /**
     * Test an URL
     *
     * @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
     * @expectedExceptionCode 1451515385
     */
    public function testInvalidRemoteUrl()
    {
        new ObjectUrl(self::REMOTE_URL);
    }

    /**
     * Test a remote URL
     */
    public function testRemoteUrl()
    {
        $url = new ObjectUrl(self::REMOTE_URL, true);
        $this->assertInstanceOf(ObjectUrl::class, $url);
        $this->assertEquals(self::REMOTE_URL, strval($url));
        $this->assertEquals('http', $url->getScheme());
        $this->assertEquals('apparat', $url->getUser());
        $this->assertEquals('tools', $url->getPassword());
        $this->assertEquals('apparat.tools', $url->getHost());
        $this->assertEquals(80, $url->getPort());
        $this->assertEquals('', $url->getPath());
        $this->assertEquals(['param' => 'value'], $url->getQueryParams());
        $this->assertEquals('param=value', $url->getQuery());
        $this->assertEquals('fragment', $url->getFragment());
        $this->assertInstanceOf(\DateTimeImmutable::class, $url->getCreationDate());
        $this->assertEquals('2015-10-01', $url->getCreationDate()->format('Y-m-d'));
        $this->assertInstanceOf(Id::class, $url->getId());
        $this->assertEquals(new Id(36704), $url->getId());
        $this->assertInstanceOf(Type::class, $url->getType());
        $this->assertEquals(Kernel::create(Type::class, [Object::EVENT]), $url->getType());
        $this->assertInstanceOf(Revision::class, $url->getRevision());
        $this->assertEquals(new Revision(1), $url->getRevision());
        $this->assertEquals(self::REMOTE_REPOSITORY_URL, Service::normalizeRepositoryUrl($url));
        $this->assertFalse($url->isDraft());
        $this->assertTrue($url->setDraft(true)->isDraft());
    }

    /**
     * Test a remote draft URL
     */
    public function testRemoteDraftUrl()
    {
        $url = new ObjectUrl(self::REMOTE_REPOSITORY_URL.self::DRAFT_PATH, true);
        $this->assertInstanceOf(ObjectUrl::class, $url);
        $this->assertTrue($url->isDraft());
    }

    /**
     * Test a local URL with path prefix
     */
    public function testLeadedLocalUrl()
    {
        $pathPrefix = '/prefix/path';
        $url = new ObjectUrl($pathPrefix.self::PATH);
        $this->assertEquals($pathPrefix, $url->getPath());
        $this->assertEquals(self::PATH, $url->getLocalPath());
    }

    /**
     * Test an invalid URL
     *
     * @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
     * @expectedExceptionCode 1449873819
     */
    public function testInvalidUrl()
    {
        new ObjectUrl('invalid://');
    }

    /**
     * Test an invalid URL path
     *
     * @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
     * @expectedExceptionCode 1449874494
     */
    public function testInvalidUrlPath()
    {
        new ObjectUrl('http://invalid~url*path', true);
    }

    /**
     * Test the scheme setter
     *
     * @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
     * @expectedExceptionCode 1449924914
     */
    public function testUrlSchemeSetter()
    {
        $url = new ObjectUrl(self::URL);
        $this->assertEquals(ObjectUrl::SCHEME_HTTPS, $url->setScheme(ObjectUrl::SCHEME_HTTPS)->getScheme());
        $url->setScheme('invalid');
    }

    /**
     * Test the host setter
     *
     * @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
     * @expectedExceptionCode 1449925567
     */
    public function testUrlHostSetter()
    {
        $url = new ObjectUrl(self::URL);
        $this->assertEquals('apparat.com', $url->setHost('apparat.com')->getHost());
        $url->setHost('_');
    }

    /**
     * Test the port setter
     *
     * @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
     * @expectedExceptionCode 1449925885
     */
    public function testUrlPortSetter()
    {
        $url = new ObjectUrl(self::URL);
        $this->assertEquals(443, $url->setPort(443)->getPort());
        $url->setPort(123456789);
    }

    /**
     * Test the remaining setter methods
     */
    public function testUrlSetters()
    {
        /** @var Type $articleType */
        $articleType = Kernel::create(Type::class, [Object::ARTICLE]);
        $url = new ObjectUrl(self::URL);
        $this->assertEquals('test', $url->setUser('test')->getUser());
        $this->assertEquals(null, $url->setUser(null)->getUser());
        $this->assertEquals('password', $url->setPassword('password')->getPassword());
        $this->assertEquals(null, $url->setPassword(null)->getPassword());
        $this->assertEquals('/path/prefix', $url->setPath('/path/prefix')->getPath());
        $this->assertEquals(['param2' => 'value2'], $url->setQueryParams(['param2' => 'value2'])->getQueryParams());
        $this->assertEquals('param=value', $url->setQuery('param=value')->getQuery());
        $this->assertEquals('fragment2', $url->setFragment('fragment2')->getFragment());

        $this->assertEquals(
            '2016-01-01',
            $url->setCreationDate(new \DateTimeImmutable('@1451606400'))->getCreationDate()->format('Y-m-d')
        );
        $this->assertEquals(123, $url->setId(new Id(123))->getId()->getId());
        $this->assertEquals(
            'article',
            $url->setType($articleType)->getType()->getType()
        );
        $this->assertEquals(
            Revision::CURRENT,
            $url->setRevision(Revision::current())->getRevision()->getRevision()
        );
    }

    /**
     * Test the override functionality when getting the URL path
     */
    public function testUrlPathOverride()
    {
        $url = new TestObjectUrl(self::URL);
        $this->assertEquals(
            'https://user:[email protected]:443/path/prefix/2015/10/01/36704-event/36704-2?param2=value2#fragment2',
            $url->getUrlOverride()
        );
    }

    /**
     * Test absolute URL
     */
    public function testUrlAbsolute()
    {
        $url = new ObjectUrl(self::REMOTE_URL, true);
        $this->assertEquals(true, $url->isAbsolute());
        $this->assertEquals(self::REMOTE_REPOSITORY_URL, $url->getRepositoryUrl());
    }

    /**
     * Test absolute URL
     */
    public function testUrlAbsoluteLocal()
    {
        $url = new ObjectUrl(rtrim(getenv('APPARAT_BASE_URL'), '/').self::REPOSITORY_URL.self::PATH, true);
        $this->assertTrue($url->isAbsoluteLocal());
    }

    /**
     * Test relative URL
     */
    public function testUrlRelative()
    {
        $url = new ObjectUrl(self::PATH.self::QUERY_FRAGMENT);
        $this->assertEquals(false, $url->isAbsolute());
    }

    /**
     * Test remote URL
     */
    public function testUrlRemote()
    {
        $url = new ObjectUrl(self::REMOTE_REPOSITORY_URL.self::REPOSITORY_URL.self::PATH, true);
        $this->assertTrue($url->isRemote());
        $url = new ObjectUrl(rtrim(getenv('APPARAT_BASE_URL'), '/').self::REPOSITORY_URL.self::PATH, true);
        $this->assertFalse($url->isRemote());
    }

    /**
     * Test object URL comparison
     */
    public function testObjectUrlComparison()
    {
        $this->assertFalse(
            (
            new ObjectUrl(
                'http://example.com/2015/10/01/36704-event/36704-1',
                true
            )
            )->matches(new ObjectUrl('https://example.com/2015/10/01/36704-event/36704-1', true))
        );
        $this->assertFalse(
            (
            new ObjectUrl(
                'http://example.com/2015/10/01/36704-event/36704-1',
                true
            )
            )->matches(new ObjectUrl('http://example.com/2016/10/01/36704-event/36704-1', true))
        );
        $this->assertFalse(
            (
            new ObjectUrl(
                'http://example.com/2015/10/01/36704-event/36704-1',
                true
            )
            )->matches(new ObjectUrl('http://example.com/2015/10/01/36705-event/36705-1', true))
        );
        $this->assertFalse(
            (
            new ObjectUrl(
                'http://example.com/2015/10/01/36704-event/36704-1',
                true
            )
            )->matches(new ObjectUrl('http://example.com/2015/10/01/36704-article/36704-1', true))
        );
        $this->assertFalse(
            (
            new ObjectUrl(
                'http://example.com/2015/10/01/36704-event/36704-1',
                true
            )
            )->matches(new ObjectUrl('http://example.com/2015/10/01/36704-event/36704-2', true))
        );
        $this->assertTrue((new ObjectUrl(self::REMOTE_URL, true))->matches(new ObjectUrl(self::REMOTE_URL, true)));
    }
}


1			<?php
2
3			/**
4			* apparat-object
5			*
6			* @category Apparat
7			* @package Apparat\Object
8			* @subpackage Apparat\Object\Infrastructure
9			* @author Joschi Kuphal <[email protected]> / @jkphl
10			* @copyright Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
11			* @license http://opensource.org/licenses/MIT The MIT License (MIT)
12			*/
13
14			/***********************************************************************************
15			* The MIT License (MIT)
16			*
17			* Copyright © 2016 Joschi Kuphal <[email protected]> / @jkphl
18			*
19			* Permission is hereby granted, free of charge, to any person obtaining a copy of
20			* this software and associated documentation files (the "Software"), to deal in
21			* the Software without restriction, including without limitation the rights to
22			* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
23			* the Software, and to permit persons to whom the Software is furnished to do so,
24			* subject to the following conditions:
25			*
26			* The above copyright notice and this permission notice shall be included in all
27			* copies or substantial portions of the Software.
28			*
29			* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30			* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
31			* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
32			* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
33			* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34			* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35			***********************************************************************************/
36
37			namespace Apparat\Object\Tests;
38
39			use Apparat\Kernel\Ports\Kernel;
40			use Apparat\Object\Domain\Model\Object\Id;
41			use Apparat\Object\Domain\Model\Object\Revision;
42			use Apparat\Object\Domain\Model\Object\Type;
43			use Apparat\Object\Domain\Model\Path\ObjectUrl;
44			use Apparat\Object\Domain\Repository\Service;
45			use Apparat\Object\Ports\Object;
46
47			/**
48			* Object URL tests
49			*
50			* @package Apparat\Object
51			* @subpackage ApparatTest
52			*/
53			class ObjectUrlTest extends AbstractDisabledAutoconnectorTest
54			{
55			/**
56			* Example query fragment
57			*
58			* @var string
59			*/
60			const QUERY_FRAGMENT = '?param=value#fragment';
61			/**
62			* Repository URL
63			*
64			* @var string
65			*/
66			const REPOSITORY_URL = '/repo';
67			/**
68			* Example path
69			*
70			* @var string
71			*/
72			const PATH = '/2015/10/01/36704-event/36704-1';
73			/**
74			* Example path (draft mode)
75			*
76			* @var string
77			*/
78			const DRAFT_PATH = '/2015/10/01/36704-event/.36704';
79			/**
80			* Example URL
81			*
82			* @var string
83			*/
84			const URL = self::REPOSITORY_URL.self::PATH.self::QUERY_FRAGMENT;
85			/**
86			* Example remote repository URL
87			*
88			* @var string
89			*/
90			const REMOTE_REPOSITORY_URL = 'http://apparat:[email protected]:80';
91			/**
92			* Example remote URL
93			*
94			* @var string
95			*/
96			const REMOTE_URL = self::REMOTE_REPOSITORY_URL.self::PATH.self::QUERY_FRAGMENT;
97
98			/**
99			* Test an URL
100			*
101			* @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
102			* @expectedExceptionCode 1451515385
103			*/
104			public function testInvalidRemoteUrl()
105			{
106			new ObjectUrl(self::REMOTE_URL);
107			}
108
109			/**
110			* Test a remote URL
111			*/
112			public function testRemoteUrl()
113			{
114			$url = new ObjectUrl(self::REMOTE_URL, true);
115			$this->assertInstanceOf(ObjectUrl::class, $url);
116			$this->assertEquals(self::REMOTE_URL, strval($url));
117			$this->assertEquals('http', $url->getScheme());
118			$this->assertEquals('apparat', $url->getUser());
119			$this->assertEquals('tools', $url->getPassword());
120			$this->assertEquals('apparat.tools', $url->getHost());
121			$this->assertEquals(80, $url->getPort());
122			$this->assertEquals('', $url->getPath());
123			$this->assertEquals(['param' => 'value'], $url->getQueryParams());
124			$this->assertEquals('param=value', $url->getQuery());
125			$this->assertEquals('fragment', $url->getFragment());
126			$this->assertInstanceOf(\DateTimeImmutable::class, $url->getCreationDate());
127			$this->assertEquals('2015-10-01', $url->getCreationDate()->format('Y-m-d'));
128			$this->assertInstanceOf(Id::class, $url->getId());
129			$this->assertEquals(new Id(36704), $url->getId());
130			$this->assertInstanceOf(Type::class, $url->getType());
131			$this->assertEquals(Kernel::create(Type::class, [Object::EVENT]), $url->getType());
132			$this->assertInstanceOf(Revision::class, $url->getRevision());
133			$this->assertEquals(new Revision(1), $url->getRevision());
134			$this->assertEquals(self::REMOTE_REPOSITORY_URL, Service::normalizeRepositoryUrl($url));
135			$this->assertFalse($url->isDraft());
136			$this->assertTrue($url->setDraft(true)->isDraft());
137			}
138
139			/**
140			* Test a remote draft URL
141			*/
142			public function testRemoteDraftUrl()
143			{
144			$url = new ObjectUrl(self::REMOTE_REPOSITORY_URL.self::DRAFT_PATH, true);
145			$this->assertInstanceOf(ObjectUrl::class, $url);
146			$this->assertTrue($url->isDraft());
147			}
148
149			/**
150			* Test a local URL with path prefix
151			*/
152			public function testLeadedLocalUrl()
153			{
154			$pathPrefix = '/prefix/path';
155			$url = new ObjectUrl($pathPrefix.self::PATH);
156			$this->assertEquals($pathPrefix, $url->getPath());
157			$this->assertEquals(self::PATH, $url->getLocalPath());
158			}
159
160			/**
161			* Test an invalid URL
162			*
163			* @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
164			* @expectedExceptionCode 1449873819
165			*/
166			public function testInvalidUrl()
167			{
168			new ObjectUrl('invalid://');
169			}
170
171			/**
172			* Test an invalid URL path
173			*
174			* @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
175			* @expectedExceptionCode 1449874494
176			*/
177			public function testInvalidUrlPath()
178			{
179			new ObjectUrl('http://invalid~url*path', true);
180			}
181
182			/**
183			* Test the scheme setter
184			*
185			* @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
186			* @expectedExceptionCode 1449924914
187			*/
188			public function testUrlSchemeSetter()
189			{
190			$url = new ObjectUrl(self::URL);
191			$this->assertEquals(ObjectUrl::SCHEME_HTTPS, $url->setScheme(ObjectUrl::SCHEME_HTTPS)->getScheme());
192			$url->setScheme('invalid');
193			}
194
195			/**
196			* Test the host setter
197			*
198			* @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
199			* @expectedExceptionCode 1449925567
200			*/
201			public function testUrlHostSetter()
202			{
203			$url = new ObjectUrl(self::URL);
204			$this->assertEquals('apparat.com', $url->setHost('apparat.com')->getHost());
205			$url->setHost('_');
206			}
207
208			/**
209			* Test the port setter
210			*
211			* @expectedException \Apparat\Object\Domain\Model\Path\InvalidArgumentException
212			* @expectedExceptionCode 1449925885
213			*/
214			public function testUrlPortSetter()
215			{
216			$url = new ObjectUrl(self::URL);
217			$this->assertEquals(443, $url->setPort(443)->getPort());
218			$url->setPort(123456789);
219			}
220
221			/**
222			* Test the remaining setter methods
223			*/
224			public function testUrlSetters()
225			{
226			/** @var Type $articleType */
227			$articleType = Kernel::create(Type::class, [Object::ARTICLE]);
228			$url = new ObjectUrl(self::URL);
229			$this->assertEquals('test', $url->setUser('test')->getUser());
230			$this->assertEquals(null, $url->setUser(null)->getUser());
231			$this->assertEquals('password', $url->setPassword('password')->getPassword());
232			$this->assertEquals(null, $url->setPassword(null)->getPassword());
233			$this->assertEquals('/path/prefix', $url->setPath('/path/prefix')->getPath());
234			$this->assertEquals(['param2' => 'value2'], $url->setQueryParams(['param2' => 'value2'])->getQueryParams());
235			$this->assertEquals('param=value', $url->setQuery('param=value')->getQuery());
236			$this->assertEquals('fragment2', $url->setFragment('fragment2')->getFragment());
237
238			$this->assertEquals(
239			'2016-01-01',
240			$url->setCreationDate(new \DateTimeImmutable('@1451606400'))->getCreationDate()->format('Y-m-d')
241			);
242			$this->assertEquals(123, $url->setId(new Id(123))->getId()->getId());
243			$this->assertEquals(
244			'article',
245			$url->setType($articleType)->getType()->getType()
246			);
247			$this->assertEquals(
248			Revision::CURRENT,
249			$url->setRevision(Revision::current())->getRevision()->getRevision()
250			);
251			}
252
253			/**
254			* Test the override functionality when getting the URL path
255			*/
256			public function testUrlPathOverride()
257			{
258			$url = new TestObjectUrl(self::URL);
259			$this->assertEquals(
260			'https://user:[email protected]:443/path/prefix/2015/10/01/36704-event/36704-2?param2=value2#fragment2',
261			$url->getUrlOverride()
262			);
263			}
264
265			/**
266			* Test absolute URL
267			*/
268			public function testUrlAbsolute()
269			{
270			$url = new ObjectUrl(self::REMOTE_URL, true);
271			$this->assertEquals(true, $url->isAbsolute());
272			$this->assertEquals(self::REMOTE_REPOSITORY_URL, $url->getRepositoryUrl());
273			}
274
275			/**
276			* Test absolute URL
277			*/
278			public function testUrlAbsoluteLocal()
279			{
280			$url = new ObjectUrl(rtrim(getenv('APPARAT_BASE_URL'), '/').self::REPOSITORY_URL.self::PATH, true);
281			$this->assertTrue($url->isAbsoluteLocal());
282			}
283
284			/**
285			* Test relative URL
286			*/
287			public function testUrlRelative()
288			{
289			$url = new ObjectUrl(self::PATH.self::QUERY_FRAGMENT);
290			$this->assertEquals(false, $url->isAbsolute());
291			}
292
293			/**
294			* Test remote URL
295			*/
296			public function testUrlRemote()
297			{
298			$url = new ObjectUrl(self::REMOTE_REPOSITORY_URL.self::REPOSITORY_URL.self::PATH, true);
299			$this->assertTrue($url->isRemote());
300			$url = new ObjectUrl(rtrim(getenv('APPARAT_BASE_URL'), '/').self::REPOSITORY_URL.self::PATH, true);
301			$this->assertFalse($url->isRemote());
302			}
303
304			/**
305			* Test object URL comparison
306			*/
307			public function testObjectUrlComparison()
308			{
309			$this->assertFalse(
310			(
311			new ObjectUrl(
312			'http://example.com/2015/10/01/36704-event/36704-1',
313			true
314			)
315			)->matches(new ObjectUrl('https://example.com/2015/10/01/36704-event/36704-1', true))
316			);
317			$this->assertFalse(
318			(
319			new ObjectUrl(
320			'http://example.com/2015/10/01/36704-event/36704-1',
321			true
322			)
323			)->matches(new ObjectUrl('http://example.com/2016/10/01/36704-event/36704-1', true))
324			);
325			$this->assertFalse(
326			(
327			new ObjectUrl(
328			'http://example.com/2015/10/01/36704-event/36704-1',
329			true
330			)
331			)->matches(new ObjectUrl('http://example.com/2015/10/01/36705-event/36705-1', true))
332			);
333			$this->assertFalse(
334			(
335			new ObjectUrl(
336			'http://example.com/2015/10/01/36704-event/36704-1',
337			true
338			)
339			)->matches(new ObjectUrl('http://example.com/2015/10/01/36704-article/36704-1', true))
340			);
341			$this->assertFalse(
342			(
343			new ObjectUrl(
344			'http://example.com/2015/10/01/36704-event/36704-1',
345			true
346			)
347			)->matches(new ObjectUrl('http://example.com/2015/10/01/36704-event/36704-2', true))
348			);
349			$this->assertTrue((new ObjectUrl(self::REMOTE_URL, true))->matches(new ObjectUrl(self::REMOTE_URL, true)));
350			}
351			}
352

apparat / object

Push — master ( b7f961...9dee4e )

ObjectUrlTest::testUrlSetters() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like