silverstripe / multi-domain

code/MultiDomainRequestFilter.php

Spacing +4 added lines, -4 removed lines

@@ -18,17 +18,17 @@
 	 */
 	public function preRequest(SS_HTTPRequest $request, Session $session, DataModel $model) {				
 
-		if(Director::is_cli()) {
+		if (Director::is_cli()) {
 			return;
 		}
 		
 		// Not the best place for validation, but _config.php is too early.
-		if(!MultiDomain::get_primary_domain()) {
+		if (!MultiDomain::get_primary_domain()) {
 			throw new Exception('MultiDomain must define a "'.MultiDomain::KEY_PRIMARY.'" domain in the config, under "domains"');
 		}
 					
-		foreach(MultiDomain::get_all_domains() as $domain) {			
-			if(!$domain->isActive()) continue;
+		foreach (MultiDomain::get_all_domains() as $domain) {			
+			if (!$domain->isActive()) continue;
 			
 			$url = $this->createNativeURLForDomain($domain);
 			$parts = explode('?', $url);					

Braces +3 added lines, -1 removed lines

@@ -28,7 +28,9 @@
 		}
 					
 		foreach(MultiDomain::get_all_domains() as $domain) {			
-			if(!$domain->isActive()) continue;
+			if(!$domain->isActive()) {
+				continue;
+			}
 			
 			$url = $this->createNativeURLForDomain($domain);
 			$parts = explode('?', $url);					

code/MultiDomain.php

Braces +3 added lines, -1 removed lines

@@ -46,7 +46,9 @@
 		$domains = array ();
 		
 		foreach(self::config()->domains as $key => $config) {
-			if(!$includePrimary && $key === self::KEY_PRIMARY) continue;
+			if(!$includePrimary && $key === self::KEY_PRIMARY) {
+				continue;
+			}
 			$domains[] = MultiDomainDomain::create($key, $config);
 		}
 

Spacing +6 added lines, -6 removed lines

@@ -27,8 +27,8 @@ 
 	public static function domain_for_url($url) {
 		$url = trim($url, '/');
 
-		foreach(self::get_all_domains() as $domain) {
-			if($domain->hasURL($url)) {
+		foreach (self::get_all_domains() as $domain) {
+			if ($domain->hasURL($url)) {
 				return $domain;
 			}
 		}
@@ -43,10 +43,10 @@ 
 	 * @return array
 	 */
 	public static function get_all_domains($includePrimary = false) {
-		$domains = array ();
+		$domains = array();
 
-		foreach(self::config()->domains as $key => $config) {
-			if(!$includePrimary && $key === self::KEY_PRIMARY) continue;
+		foreach (self::config()->domains as $key => $config) {
+			if (!$includePrimary && $key === self::KEY_PRIMARY) continue;
 			$domains[] = MultiDomainDomain::create($key, $config);
 		}
 
@@ -67,7 +67,7 @@ 
 	 * @return MultiDomainDomain
 	 */
 	public static function get_domain($domain) {
-		if(isset(self::config()->domains[$domain])) {
+		if (isset(self::config()->domains[$domain])) {
 			return MultiDomainDomain::create(
 				$domain,
 				self::config()->domains[$domain]

code/MultiDomainDomain.php

Indentation +67 added lines, -67 removed lines

@@ -40,19 +40,19 @@ 
 	 */
 	protected $forcedPaths;
 
-    /**
-     * The request URI
-     *
-     * @var string
-     */
-    protected $requestUri;
-
-    /**
-     * The request HTTP HOST
-     *
-     * @var string
-     */
-    protected $httpHost;
+	/**
+	 * The request URI
+	 *
+	 * @var string
+	 */
+	protected $requestUri;
+
+	/**
+	 * The request HTTP HOST
+	 *
+	 * @var string
+	 */
+	protected $httpHost;
 
 	/**
 	 * Constructor. Takes a key for the domain and its array of settings from the config
@@ -151,7 +151,7 @@ 
 			return $url;
 		}
 
-        $domainUrl = str_replace('/', '\/', $this->getURL());
+		$domainUrl = str_replace('/', '\/', $this->getURL());
 		return preg_replace('/^\/?' . $domainUrl . '\//', '', $url);
 	}
 
@@ -170,59 +170,59 @@ 
 		return false;
 	}
 
-    /**
-     * Returns the key/identifier for this domain
-     *
-     * @return string
-     */
-    public function getKey()
-    {
-        return $this->key;
-    }
-
-    /**
-     * Set the request URI
-     *
-     * @param  string $requestUri
-     * @return $this
-     */
-    public function setRequestUri($requestUri)
-    {
-        $this->requestUri = (string) $requestUri;
-        return $this;
-    }
-
-    /**
-     * Return the current request URI, defaulting to retrieving it from the $_SERVER superglobal
-     *
-     * @return string
-     */
-    public function getRequestUri()
-    {
-        return $this->requestUri ?: $_SERVER['REQUEST_URI'];
-    }
-
-    /**
-     * Set the HTTP host in the request
-     *
-     * @param  string $httpHost
-     * @return $this
-     */
-    public function setHttpHost($httpHost)
-    {
-        $this->httpHost = (string) $httpHost;
-        return $this;
-    }
-
-    /**
-     * Return the current HTTP host, defaulting to retrieving it from the $_SERVER superglobal
-     *
-     * @return string
-     */
-    public function getHttpHost()
-    {
-        return $this->httpHost ?: $_SERVER['HTTP_HOST'];
-    }
+	/**
+	 * Returns the key/identifier for this domain
+	 *
+	 * @return string
+	 */
+	public function getKey()
+	{
+		return $this->key;
+	}
+
+	/**
+	 * Set the request URI
+	 *
+	 * @param  string $requestUri
+	 * @return $this
+	 */
+	public function setRequestUri($requestUri)
+	{
+		$this->requestUri = (string) $requestUri;
+		return $this;
+	}
+
+	/**
+	 * Return the current request URI, defaulting to retrieving it from the $_SERVER superglobal
+	 *
+	 * @return string
+	 */
+	public function getRequestUri()
+	{
+		return $this->requestUri ?: $_SERVER['REQUEST_URI'];
+	}
+
+	/**
+	 * Set the HTTP host in the request
+	 *
+	 * @param  string $httpHost
+	 * @return $this
+	 */
+	public function setHttpHost($httpHost)
+	{
+		$this->httpHost = (string) $httpHost;
+		return $this;
+	}
+
+	/**
+	 * Return the current HTTP host, defaulting to retrieving it from the $_SERVER superglobal
+	 *
+	 * @return string
+	 */
+	public function getHttpHost()
+	{
+		return $this->httpHost ?: $_SERVER['HTTP_HOST'];
+	}
 
 	/**
 	 * Checks a given list of wildcard patterns to see if a path is allowed

Spacing +17 added lines, -18 removed lines

@@ -64,10 +64,10 @@ 
 		$this->hostname = $config['hostname'];
 		$this->url = isset($config['resolves_to']) ? $config['resolves_to'] : null;
 
-		$globalAllowed = (array) Config::inst()->get('MultiDomain','allow');
-		$globalForced = (array) Config::inst()->get('MultiDomain','force');
-		$myAllowed = isset($config['allow']) ? $config['allow'] : array ();
-		$myForced = isset($config['force']) ? $config['force'] : array ();
+		$globalAllowed = (array) Config::inst()->get('MultiDomain', 'allow');
+		$globalForced = (array) Config::inst()->get('MultiDomain', 'force');
+		$myAllowed = isset($config['allow']) ? $config['allow'] : array();
+		$myForced = isset($config['force']) ? $config['force'] : array();
 		$this->allowedPaths = array_merge($globalAllowed, $myAllowed);
 		$this->forcedPaths = array_merge($globalForced, $myForced);
 
@@ -95,7 +95,7 @@ 
 	 * @return boolean
 	 */
 	public function isActive() {
-		if($this->isAllowedPath($this->getRequestUri())) {
+		if ($this->isAllowedPath($this->getRequestUri())) {
 			return false;
 		}
 
@@ -108,8 +108,7 @@ 
 		$hostname = $this->getHostname();
 
 		return $allow_subdomains ?
-					(bool) preg_match('/(\.|^)'.$hostname.'$/', $currentHost) :
-					($currentHost == $hostname);
+					(bool) preg_match('/(\.|^)'.$hostname.'$/', $currentHost) : ($currentHost == $hostname);
 	}
 
 	/**
@@ -128,11 +127,11 @@ 
 	 * @return string
 	 */
 	public function getNativeURL($url) {
-		if($this->isPrimary()) {
+		if ($this->isPrimary()) {
 			throw new Exception("Cannot convert a native URL on the primary domain");
 		}
 
-		if($this->isAllowedPath($url) || $this->isForcedPath($url)) {
+		if ($this->isAllowedPath($url) || $this->isForcedPath($url)) {
 			return $url;
 		}
 
@@ -147,12 +146,12 @@ 
 	 * @return string
 	 */
 	public function getVanityURL($url) {
-		if($this->isPrimary() || $this->isAllowedPath($url)) {
+		if ($this->isPrimary() || $this->isAllowedPath($url)) {
 			return $url;
 		}
 
         $domainUrl = str_replace('/', '\/', $this->getURL());
-		return preg_replace('/^\/?' . $domainUrl . '\//', '', $url);
+		return preg_replace('/^\/?'.$domainUrl.'\//', '', $url);
 	}
 
 	/**
@@ -161,9 +160,9 @@ 
 	 * @return boolean
 	 */
 	public function hasURL($url) {
-		if($this->isForcedPath($url)) return true;
-		$domainBaseURL = trim($this->getURL(),'/');
-		if(preg_match('/^'.$domainBaseURL.'/', $url)) {
+		if ($this->isForcedPath($url)) return true;
+		$domainBaseURL = trim($this->getURL(), '/');
+		if (preg_match('/^'.$domainBaseURL.'/', $url)) {
 			return true;
 		}
 
@@ -249,13 +248,13 @@ 
 	 * @return boolean
 	 */
 	protected static function match_url($url, $patterns) {
-		if(!is_array($patterns)) return false;
+		if (!is_array($patterns)) return false;
 
 		$url = ltrim($url, '/');
-		if(substr($url, -1) !== '/') $url .= '/';
+		if (substr($url, -1) !== '/') $url .= '/';
 
-		foreach($patterns as $pattern) {
-			if(fnmatch($pattern, $url)) return true;
+		foreach ($patterns as $pattern) {
+			if (fnmatch($pattern, $url)) return true;
 		}
 
 		return false;

Braces +12 added lines, -4 removed lines

@@ -161,7 +161,9 @@ 
 	 * @return boolean
 	 */
 	public function hasURL($url) {
-		if($this->isForcedPath($url)) return true;
+		if($this->isForcedPath($url)) {
+			return true;
+		}
 		$domainBaseURL = trim($this->getURL(),'/');
 		if(preg_match('/^'.$domainBaseURL.'/', $url)) {
 			return true;
@@ -249,13 +251,19 @@ 
 	 * @return boolean
 	 */
 	protected static function match_url($url, $patterns) {
-		if(!is_array($patterns)) return false;
+		if(!is_array($patterns)) {
+			return false;
+		}
 
 		$url = ltrim($url, '/');
-		if(substr($url, -1) !== '/') $url .= '/';
+		if(substr($url, -1) !== '/') {
+			$url .= '/';
+		}
 
 		foreach($patterns as $pattern) {
-			if(fnmatch($pattern, $url)) return true;
+			if(fnmatch($pattern, $url)) {
+				return true;
+			}
 		}
 
 		return false;

tests/MultiDomainDomainTest.php

Indentation +164 added lines, -164 removed lines

@@ -2,168 +2,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', 'domains');
-        Config::inst()->update('MultiDomain', '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', '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', 'domains');
+		Config::inst()->update('MultiDomain', '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', '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

@@ -2,96 +2,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', 'domains');
-        Config::inst()->update('MultiDomain', 'domains', array(
-            'primary' => array(
-                'hostname' => 'foo.bar',
-                'resolves_to' => 'bar.baz'
-            ),
-            'secondary' => array(
-                'hostname' => 'localhost',
-                'resolves_to' => 'local.dev'
-            )
-        ));
-    }
+		Config::inst()->remove('MultiDomain', 'domains');
+		Config::inst()->update('MultiDomain', '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();
+	}
 }