silverstripe / multi-domain

tests/MultiDomainDomainTest.php

Indentation +164 added lines, -164 removed lines

@@ -8,168 +8,168 @@
 
 class MultiDomainDomainTest extends SapphireTest
 {
-    /**
-     * Set up some test domain data for testing
-     *
-     * {@inheritDoc}
-     */
-    public function setUp()
-    {
-        parent::setUp();
-        Config::nest();
-
-        Config::inst()->remove(MultiDomain::class, 'domains');
-        Config::inst()->update(MultiDomain::class, 'domains', array(
-            'primary' => array(
-                'hostname' => 'example.com'
-            ),
-            'store' => array(
-                'hostname' => 'example-store.com',
-                'resolves_to' => 'shop/store',
-                'allow' => array(
-                    'admin/*',
-                    'Security/*',
-                    'my-custom-webhook/'
-                )
-            ),
-            'configurable' => array(
-                'hostname' => 'MY_CONSTANT_HOSTNAME'
-            ),
-            'forceful' => array(
-                'hostname' => 'forced.com',
-                'force' => array(
-                    'buy-now/*'
-                )
-            )
-        ));
-    }
-
-    /**
-     * Test that a hostname defined in a constant will override the default configuration, otherwise the default
-     * configuration for the domain is returned
-     */
-    public function testGetHostname()
-    {
-        $configurableDomain = MultiDomain::get_domain('configurable');
-        define('MY_CONSTANT_HOSTNAME', 'I am a constant');
-        $this->assertSame('I am a constant', $configurableDomain->getHostname());
-
-        $storeDomain = MultiDomain::get_domain('store');
-        $this->assertSame('example-store.com', $storeDomain->getHostname());
-    }
-
-    /**
-     * Test that the domain's "resolves to" property is returned for the URL if it is defined, otherwise null
-     */
-    public function testGetUrl()
-    {
-        $primaryDomain = MultiDomain::get_domain('primary');
-        $this->assertNull($primaryDomain->getURL());
-
-        $storeDomain = MultiDomain::get_domain('store');
-        $this->assertSame('shop/store', $storeDomain->getURL());
-    }
-
-    /**
-     * Test that a domain can be identified as the primary domain or otherwise
-     */
-    public function testIsPrimary()
-    {
-        $this->assertTrue(MultiDomain::get_primary_domain()->isPrimary());
-        $this->assertFalse(MultiDomain::get_domain('store')->isPrimary());
-    }
-
-    /**
-     * When the request URI matches one of the allowed rules for a domain, the isActive method should return false
-     */
-    public function testIsActiveReturnsFalseWhenRequestUriIsAllowedPath()
-    {
-        $domain = MultiDomain::get_domain('store');
-        $domain->setRequestUri('/Security/login');
-        $this->assertFalse($domain->isActive());
-    }
-
-    /**
-     * When a subdomain is "allowed" and is requested, subdomains should be allowed through "isActive" as well
-     * as the primary domain
-     */
-    public function testSubdomainsAllowedInIsActiveWhenConfigured()
-    {
-        Config::inst()->update(MultiDomain::class, 'allow_subdomains', true);
-
-        $domain = MultiDomain::get_domain('store')
-            ->setRequestUri('/some/page')
-            ->setHttpHost('api.example-store.com');
-
-        $this->assertTrue($domain->isActive());
-    }
-
-    /**
-     * The default behaviour would be that if the current host from the request matchese that of the domain model
-     * then isActive should be true
-     */
-    public function testReturnActiveIfCurrentHostMatchesDomainsHostname()
-    {
-        $domain = MultiDomain::get_domain('primary')
-            ->setRequestUri('/another/page')
-            ->setHttpHost('example.com');
-
-        $this->assertTrue($domain->isActive());
-    }
-
-    /**
-     * getNativeUrl should not be used on the primary domain
-     *
-     * @expectedException Exception
-     * @expectedExceptionMessage Cannot convert a native URL on the primary domain
-     */
-    public function testGetNativeUrlThrowsExceptionOnPrimaryDomain()
-    {
-        MultiDomain::get_primary_domain()->getNativeUrl('foo');
-    }
-
-    /**
-     * Test that a URL segment can be added to the domain's URL and returned as a "native URL"
-     */
-    public function testGetNativeUrl()
-    {
-        $domain = MultiDomain::get_domain('store');
-        $this->assertSame('shop/store/foo/bar', $domain->getNativeUrl('foo/bar'));
-    }
-
-    /**
-     * "Allowed" and "forced" URLs should just be returned from getNativeUrl as is
-     */
-    public function testGetNativeUrlReturnsInputWhenUrlIsAllowedOrForced()
-    {
-        $domain = MultiDomain::get_domain('store');
-        $this->assertSame('my-custom-webhook/', $domain->getNativeUrl('my-custom-webhook/'));
-
-        $domain = MultiDomain::get_domain('forceful');
-        $this->assertSame('buy-now/whatever', $domain->getNativeUrl('buy-now/whatever'));
-    }
-
-    /**
-     * The primary domain and "allowed" route matches should be returned as it
-     */
-    public function testGetVanityUrlReturnsInputWhenUrlIsAllowedOrIsPrimaryDomain()
-    {
-        $this->assertSame('/pages/info', MultiDomain::get_primary_domain()->getVanityUrl('/pages/info'));
-        $this->assertSame('/Security/login', MultiDomain::get_domain('store')->getVanityUrl('/Security/login'));
-    }
-
-    /**
-     * Non-primary domains and un-allowed route matches should be returned without their URL for vanity
-     */
-    public function testGetVanityUrl()
-    {
-        $this->assertSame('partners/', MultiDomain::get_domain('store')->getVanityUrl('shop/store/partners/'));
-        $this->assertSame('foo/bar', MultiDomain::get_domain('store')->getVanityUrl('shop/store/foo/bar'));
-    }
-
-    public function tearDown()
-    {
-        Config::unnest();
-        parent::tearDown();
-    }
+	/**
+	 * Set up some test domain data for testing
+	 *
+	 * {@inheritDoc}
+	 */
+	public function setUp()
+	{
+		parent::setUp();
+		Config::nest();
+
+		Config::inst()->remove(MultiDomain::class, 'domains');
+		Config::inst()->update(MultiDomain::class, 'domains', array(
+			'primary' => array(
+				'hostname' => 'example.com'
+			),
+			'store' => array(
+				'hostname' => 'example-store.com',
+				'resolves_to' => 'shop/store',
+				'allow' => array(
+					'admin/*',
+					'Security/*',
+					'my-custom-webhook/'
+				)
+			),
+			'configurable' => array(
+				'hostname' => 'MY_CONSTANT_HOSTNAME'
+			),
+			'forceful' => array(
+				'hostname' => 'forced.com',
+				'force' => array(
+					'buy-now/*'
+				)
+			)
+		));
+	}
+
+	/**
+	 * Test that a hostname defined in a constant will override the default configuration, otherwise the default
+	 * configuration for the domain is returned
+	 */
+	public function testGetHostname()
+	{
+		$configurableDomain = MultiDomain::get_domain('configurable');
+		define('MY_CONSTANT_HOSTNAME', 'I am a constant');
+		$this->assertSame('I am a constant', $configurableDomain->getHostname());
+
+		$storeDomain = MultiDomain::get_domain('store');
+		$this->assertSame('example-store.com', $storeDomain->getHostname());
+	}
+
+	/**
+	 * Test that the domain's "resolves to" property is returned for the URL if it is defined, otherwise null
+	 */
+	public function testGetUrl()
+	{
+		$primaryDomain = MultiDomain::get_domain('primary');
+		$this->assertNull($primaryDomain->getURL());
+
+		$storeDomain = MultiDomain::get_domain('store');
+		$this->assertSame('shop/store', $storeDomain->getURL());
+	}
+
+	/**
+	 * Test that a domain can be identified as the primary domain or otherwise
+	 */
+	public function testIsPrimary()
+	{
+		$this->assertTrue(MultiDomain::get_primary_domain()->isPrimary());
+		$this->assertFalse(MultiDomain::get_domain('store')->isPrimary());
+	}
+
+	/**
+	 * When the request URI matches one of the allowed rules for a domain, the isActive method should return false
+	 */
+	public function testIsActiveReturnsFalseWhenRequestUriIsAllowedPath()
+	{
+		$domain = MultiDomain::get_domain('store');
+		$domain->setRequestUri('/Security/login');
+		$this->assertFalse($domain->isActive());
+	}
+
+	/**
+	 * When a subdomain is "allowed" and is requested, subdomains should be allowed through "isActive" as well
+	 * as the primary domain
+	 */
+	public function testSubdomainsAllowedInIsActiveWhenConfigured()
+	{
+		Config::inst()->update(MultiDomain::class, 'allow_subdomains', true);
+
+		$domain = MultiDomain::get_domain('store')
+			->setRequestUri('/some/page')
+			->setHttpHost('api.example-store.com');
+
+		$this->assertTrue($domain->isActive());
+	}
+
+	/**
+	 * The default behaviour would be that if the current host from the request matchese that of the domain model
+	 * then isActive should be true
+	 */
+	public function testReturnActiveIfCurrentHostMatchesDomainsHostname()
+	{
+		$domain = MultiDomain::get_domain('primary')
+			->setRequestUri('/another/page')
+			->setHttpHost('example.com');
+
+		$this->assertTrue($domain->isActive());
+	}
+
+	/**
+	 * getNativeUrl should not be used on the primary domain
+	 *
+	 * @expectedException Exception
+	 * @expectedExceptionMessage Cannot convert a native URL on the primary domain
+	 */
+	public function testGetNativeUrlThrowsExceptionOnPrimaryDomain()
+	{
+		MultiDomain::get_primary_domain()->getNativeUrl('foo');
+	}
+
+	/**
+	 * Test that a URL segment can be added to the domain's URL and returned as a "native URL"
+	 */
+	public function testGetNativeUrl()
+	{
+		$domain = MultiDomain::get_domain('store');
+		$this->assertSame('shop/store/foo/bar', $domain->getNativeUrl('foo/bar'));
+	}
+
+	/**
+	 * "Allowed" and "forced" URLs should just be returned from getNativeUrl as is
+	 */
+	public function testGetNativeUrlReturnsInputWhenUrlIsAllowedOrForced()
+	{
+		$domain = MultiDomain::get_domain('store');
+		$this->assertSame('my-custom-webhook/', $domain->getNativeUrl('my-custom-webhook/'));
+
+		$domain = MultiDomain::get_domain('forceful');
+		$this->assertSame('buy-now/whatever', $domain->getNativeUrl('buy-now/whatever'));
+	}
+
+	/**
+	 * The primary domain and "allowed" route matches should be returned as it
+	 */
+	public function testGetVanityUrlReturnsInputWhenUrlIsAllowedOrIsPrimaryDomain()
+	{
+		$this->assertSame('/pages/info', MultiDomain::get_primary_domain()->getVanityUrl('/pages/info'));
+		$this->assertSame('/Security/login', MultiDomain::get_domain('store')->getVanityUrl('/Security/login'));
+	}
+
+	/**
+	 * Non-primary domains and un-allowed route matches should be returned without their URL for vanity
+	 */
+	public function testGetVanityUrl()
+	{
+		$this->assertSame('partners/', MultiDomain::get_domain('store')->getVanityUrl('shop/store/partners/'));
+		$this->assertSame('foo/bar', MultiDomain::get_domain('store')->getVanityUrl('shop/store/foo/bar'));
+	}
+
+	public function tearDown()
+	{
+		Config::unnest();
+		parent::tearDown();
+	}
 }

tests/MultiDomainTest.php

Indentation +83 added lines, -83 removed lines

@@ -9,96 +9,96 @@
 
 class MultiDomainTest extends SapphireTest
 {
-    /**
-     * Set up some test domain configuration
-     *
-     * {@inheritDoc}
-     */
-    public function setUp()
-    {
-        parent::setUp();
-        Config::nest();
+	/**
+	 * Set up some test domain configuration
+	 *
+	 * {@inheritDoc}
+	 */
+	public function setUp()
+	{
+		parent::setUp();
+		Config::nest();
 
-        Config::inst()->remove(MultiDomain::class, 'domains');
-        Config::inst()->update(MultiDomain::class, 'domains', array(
-            'primary' => array(
-                'hostname' => 'foo.bar',
-                'resolves_to' => 'bar.baz'
-            ),
-            'secondary' => array(
-                'hostname' => 'localhost',
-                'resolves_to' => 'local.dev'
-            )
-        ));
-    }
+		Config::inst()->remove(MultiDomain::class, 'domains');
+		Config::inst()->update(MultiDomain::class, 'domains', array(
+			'primary' => array(
+				'hostname' => 'foo.bar',
+				'resolves_to' => 'bar.baz'
+			),
+			'secondary' => array(
+				'hostname' => 'localhost',
+				'resolves_to' => 'local.dev'
+			)
+		));
+	}
 
-    /**
-     * Test that a MultiDomainDomain can be returned from the configured domains
-     */
-    public function testGetDomain()
-    {
-        $this->assertNull(MultiDomain::get_domain('does-not-exist'));
-        $this->assertInstanceOf(MultiDomainDomain::class, MultiDomain::get_domain('primary'));
-    }
+	/**
+	 * Test that a MultiDomainDomain can be returned from the configured domains
+	 */
+	public function testGetDomain()
+	{
+		$this->assertNull(MultiDomain::get_domain('does-not-exist'));
+		$this->assertInstanceOf(MultiDomainDomain::class, MultiDomain::get_domain('primary'));
+	}
 
-    /**
-     * Test that all domains can be returned, with or without the primary domain
-     *
-     * @dataProvider getAllDomainsProvider
-     * @param bool $withPrimary
-     */
-    public function testGetAllDomains($withPrimary)
-    {
-        $result = MultiDomain::get_all_domains($withPrimary);
-        $this->assertInternalType('array', $result);
-        $this->assertNotEmpty($result);
+	/**
+	 * Test that all domains can be returned, with or without the primary domain
+	 *
+	 * @dataProvider getAllDomainsProvider
+	 * @param bool $withPrimary
+	 */
+	public function testGetAllDomains($withPrimary)
+	{
+		$result = MultiDomain::get_all_domains($withPrimary);
+		$this->assertInternalType('array', $result);
+		$this->assertNotEmpty($result);
 
-        $expectedCount = $withPrimary ? 2 : 1;
-        $this->assertCount($expectedCount, $result);
-    }
+		$expectedCount = $withPrimary ? 2 : 1;
+		$this->assertCount($expectedCount, $result);
+	}
 
-    /**
-     * @return array[]
-     */
-    public function getAllDomainsProvider()
-    {
-        return array(
-            array(true),
-            array(false)
-        );
-    }
+	/**
+	 * @return array[]
+	 */
+	public function getAllDomainsProvider()
+	{
+		return array(
+			array(true),
+			array(false)
+		);
+	}
 
-    /**
-     * Test that the primary domain can be returned
-     */
-    public function testGetPrimaryDomain()
-    {
-        $result = MultiDomain::get_primary_domain();
-        $this->assertInstanceOf(MultiDomainDomain::class, $result);
-        $this->assertTrue($result->isPrimary());
-    }
+	/**
+	 * Test that the primary domain can be returned
+	 */
+	public function testGetPrimaryDomain()
+	{
+		$result = MultiDomain::get_primary_domain();
+		$this->assertInstanceOf(MultiDomainDomain::class, $result);
+		$this->assertTrue($result->isPrimary());
+	}
 
-    /**
-     * Test that the correct domain can be returned by a provided URL
-     */
-    public function testDomainForUrl()
-    {
-        $result = MultiDomain::domain_for_url('foo.bar/my-page');
-        $this->assertInstanceOf(MultiDomainDomain::class, $result);
-        $this->assertSame('primary', $result->getKey());
-    }
+	/**
+	 * Test that the correct domain can be returned by a provided URL
+	 */
+	public function testDomainForUrl()
+	{
+		$result = MultiDomain::domain_for_url('foo.bar/my-page');
+		$this->assertInstanceOf(MultiDomainDomain::class, $result);
+		$this->assertSame('primary', $result->getKey());
+	}
 
-    /**
-     * Test that if a URL doesn't match any domain then the primary domain is returned
-     */
-    public function testDomainForUrlDefaultsToPrimaryDomain()
-    {
-        $this->assertTrue(MultiDomain::domain_for_url('does-not-exist.com')->isPrimary());
-    }
+	/**
+	 * Test that if a URL doesn't match any domain then the primary domain is returned
+	 */
+	public function testDomainForUrlDefaultsToPrimaryDomain()
+	{
+		$this->assertTrue(MultiDomain::domain_for_url('does-not-exist.com')->isPrimary());
+	}
 
-    public function tearDown()
-    {
-        Config::unnest();
-        parent::tearDown();
-    }
+	public function tearDown()
+	{
+		Config::unnest();
+		parent::tearDown();
+	}
 }