Merge pull request #496 from bshaffer/developv1.6

Tag v1.6

8 files changed, 214 insertions, 61 deletions

diff --git a/test/OAuth2/OpenID/Controller/AuthorizeControllerTest.php b/test/OAuth2/OpenID/Controller/AuthorizeControllerTest.php
index 4b217c5..a0c9b57 100644
--- a/test/OAuth2/OpenID/Controller/AuthorizeControllerTest.php
+++ b/test/OAuth2/OpenID/Controller/AuthorizeControllerTest.php
@@ -4,7 +4,7 @@ namespace OAuth2\OpenID\Controller;
 
 use OAuth2\OpenID\Controller\AuthorizeController;
 use OAuth2\OpenID\ResponseType\IdToken;
-use OAuth2\OpenID\ResponseType\TokenIdToken;
+use OAuth2\OpenID\ResponseType\IdTokenToken;
 use OAuth2\ResponseType\AccessToken;
 use OAuth2\Storage\Bootstrap;
 use OAuth2\Server;
@@ -42,6 +42,22 @@ class AuthorizeControllerTest extends \PHPUnit_Framework_TestCase
         $this->assertArrayNotHasKey('token_type', $query);
 
         // Test valid token id_token request
+        $request->query['response_type'] = 'id_token token';
+        $server->handleAuthorizeRequest($request, $response, true);
+
+        $parts = parse_url($response->getHttpHeader('Location'));
+        parse_str($parts['fragment'], $query);
+
+        $this->assertEquals('n-0S6_WzA2Mj', $server->getAuthorizeController()->getNonce());
+        $this->assertEquals($query['state'], 'af0ifjsldkj');
+
+        $this->assertArrayHasKey('access_token', $query);
+        $this->assertArrayHasKey('expires_in', $query);
+        $this->assertArrayHasKey('token_type', $query);
+        $this->assertArrayHasKey('state', $query);
+        $this->assertArrayHasKey('id_token', $query);
+
+        // assert that with multiple-valued response types, order does not matter
         $request->query['response_type'] = 'token id_token';
         $server->handleAuthorizeRequest($request, $response, true);
 
@@ -56,6 +72,22 @@ class AuthorizeControllerTest extends \PHPUnit_Framework_TestCase
         $this->assertArrayHasKey('token_type', $query);
         $this->assertArrayHasKey('state', $query);
         $this->assertArrayHasKey('id_token', $query);
+
+        // assert that with multiple-valued response types with extra spaces do not matter
+        $request->query['response_type'] = ' token  id_token ';
+        $server->handleAuthorizeRequest($request, $response, true);
+
+        $parts = parse_url($response->getHttpHeader('Location'));
+        parse_str($parts['fragment'], $query);
+
+        $this->assertEquals('n-0S6_WzA2Mj', $server->getAuthorizeController()->getNonce());
+        $this->assertEquals($query['state'], 'af0ifjsldkj');
+
+        $this->assertArrayHasKey('access_token', $query);
+        $this->assertArrayHasKey('expires_in', $query);
+        $this->assertArrayHasKey('token_type', $query);
+        $this->assertArrayHasKey('state', $query);
+        $this->assertArrayHasKey('id_token', $query);
     }
 
     public function testMissingNonce()
@@ -73,16 +105,14 @@ class AuthorizeControllerTest extends \PHPUnit_Framework_TestCase
 
         // Test missing nonce for 'id_token' response type
         $server->handleAuthorizeRequest($request, $response, true);
-
         $params = $response->getParameters();
 
         $this->assertEquals($params['error'], 'invalid_nonce');
         $this->assertEquals($params['error_description'], 'This application requires you specify a nonce parameter');
 
-        // Test missing nonce for 'id_token' response type
-        $request->query['response_type'] = 'token id_token';
+        // Test missing nonce for 'id_token token' response type
+        $request->query['response_type'] = 'id_token token';
         $server->handleAuthorizeRequest($request, $response, true);
-
         $params = $response->getParameters();
 
         $this->assertEquals($params['error'], 'invalid_nonce');
@@ -143,10 +173,10 @@ class AuthorizeControllerTest extends \PHPUnit_Framework_TestCase
     private function getTestServer($config = array())
     {
         $config += array(
-                    'use_openid_connect' => true,
-                    'issuer'             => 'anzev',
-                    'allow_implicit'     => true
-                );
+            'use_openid_connect' => true,
+            'issuer'             => 'phpunit',
+            'allow_implicit'     => true
+        );
 
         $storage = Bootstrap::getInstance()->getMemoryStorage();
         $server  = new Server($storage, $config);
diff --git a/test/OAuth2/OpenID/ResponseType/TokenIdTokenTest.php b/test/OAuth2/OpenID/ResponseType/IdTokenTokenTest.php
index f687cff..bc564d3 100644
--- a/test/OAuth2/OpenID/ResponseType/TokenIdTokenTest.php
+++ b/test/OAuth2/OpenID/ResponseType/IdTokenTokenTest.php
@@ -9,15 +9,16 @@ use OAuth2\Storage\Bootstrap;
 use OAuth2\GrantType\ClientCredentials;
 use OAuth2\ResponseType\AccessToken;
 
-class TokenIdTokenTest extends \PHPUnit_Framework_TestCase
+class IdTokenTokenTest extends \PHPUnit_Framework_TestCase
 {
 
     public function testHandleAuthorizeRequest()
     {
         // add the test parameters in memory
         $server = $this->getTestServer(array('allow_implicit' => true));
+
         $request = new Request(array(
-            'response_type' => 'token id_token',
+            'response_type' => 'id_token token',
             'redirect_uri'  => 'http://adobe.com',
             'client_id'     => 'Test Client ID',
             'scope'         => 'openid',
@@ -40,12 +41,9 @@ class TokenIdTokenTest extends \PHPUnit_Framework_TestCase
         $this->assertNotNull($params);
         $this->assertArrayHasKey('id_token', $params);
         $this->assertArrayHasKey('access_token', $params);
-        $this->validateIdToken($params['id_token']);
-    }
 
-    private function validateIdToken($id_token)
-    {
-        $parts = explode('.', $id_token);
+        // validate ID Token
+        $parts = explode('.', $params['id_token']);
         foreach ($parts as &$part) {
             // Each part is a base64url encoded json string.
             $part = str_replace(array('-', '_'), array('+', '/'), $part);
@@ -80,10 +78,10 @@ class TokenIdTokenTest extends \PHPUnit_Framework_TestCase
 
         $memoryStorage = Bootstrap::getInstance()->getMemoryStorage();
         $responseTypes = array(
-            'token' => new AccessToken($memoryStorage, $memoryStorage),
-            'id_token' => new IdToken($memoryStorage, $memoryStorage, $config),
+            'token'     => $token   = new AccessToken($memoryStorage, $memoryStorage),
+            'id_token'  => $idToken = new IdToken($memoryStorage, $memoryStorage, $config),
+            'id_token token' => new IdTokenToken($token, $idToken),
         );
-        $responseTypes['token id_token'] = new TokenIdToken($responseTypes['token'], $responseTypes['id_token']);
 
         $server = new Server($memoryStorage, $config, array(), $responseTypes);
         $server->addGrantType(new ClientCredentials($memoryStorage));
diff --git a/test/OAuth2/RequestTest.php b/test/OAuth2/RequestTest.php
index a7bcc4e..10db321 100644
--- a/test/OAuth2/RequestTest.php
+++ b/test/OAuth2/RequestTest.php
@@ -75,6 +75,16 @@ class RequestTest extends \PHPUnit_Framework_TestCase
         $this->assertEquals('Basic secret', $request->headers('Authorization'));
     }
 
+    public function testRequestReturnsPostParamIfNoQueryParamAvailable()
+    {
+        $request = new Request(
+            array(),
+            array('client_id' => 'correct')
+        );
+
+        $this->assertEquals('correct', $request->query('client_id', $request->request('client_id')));
+    }
+
     private function getTestServer($config = array())
     {
         $storage = Bootstrap::getInstance()->getMemoryStorage();
diff --git a/test/OAuth2/ResponseType/CryptoTokenTest.php b/test/OAuth2/ResponseType/JwtAccessTokenTest.php
index d1ab89e..b326ec4 100644
--- a/test/OAuth2/ResponseType/CryptoTokenTest.php
+++ b/test/OAuth2/ResponseType/JwtAccessTokenTest.php
@@ -6,14 +6,39 @@ use OAuth2\Server;
 use OAuth2\Response;
 use OAuth2\Request\TestRequest;
 use OAuth2\Storage\Bootstrap;
-use OAuth2\Storage\CryptoToken as CryptoTokenStorage;
+use OAuth2\Storage\JwtAccessToken as JwtAccessTokenStorage;
 use OAuth2\GrantType\ClientCredentials;
 use OAuth2\GrantType\UserCredentials;
 use OAuth2\GrantType\RefreshToken;
+use OAuth2\Encryption\Jwt;
 
-class CryptoTokenTest extends \PHPUnit_Framework_TestCase
+class JwtAccessTokenTest extends \PHPUnit_Framework_TestCase
 {
-    public function testGrantCryptoToken()
+    public function testCreateAccessToken()
+    {
+        $server = $this->getTestServer();
+        $jwtResponseType = $server->getResponseType('token');
+
+        $accessToken = $jwtResponseType->createAccessToken('Test Client ID', 123, 'test', false);
+        $jwt = new Jwt;
+        $decodedAccessToken = $jwt->decode($accessToken['access_token'], null, false);
+
+        $this->assertArrayHasKey('id', $decodedAccessToken);
+        $this->assertArrayHasKey('iss', $decodedAccessToken);
+        $this->assertArrayHasKey('aud', $decodedAccessToken);
+        $this->assertArrayHasKey('exp', $decodedAccessToken);
+        $this->assertArrayHasKey('iat', $decodedAccessToken);
+        $this->assertArrayHasKey('token_type', $decodedAccessToken);
+        $this->assertArrayHasKey('scope', $decodedAccessToken);
+
+        $this->assertEquals('https://api.example.com', $decodedAccessToken['iss']);
+        $this->assertEquals('Test Client ID', $decodedAccessToken['aud']);
+        $this->assertEquals(123, $decodedAccessToken['sub']);
+        $delta = $decodedAccessToken['exp'] - $decodedAccessToken['iat'];
+        $this->assertEquals(3600, $delta);
+    }
+
+    public function testGrantJwtAccessToken()
     {
         // add the test parameters in memory
         $server = $this->getTestServer();
@@ -28,7 +53,7 @@ class CryptoTokenTest extends \PHPUnit_Framework_TestCase
         $this->assertEquals(2, substr_count($response->getParameter('access_token'), '.'));
     }
 
-    public function testAccessResourceWithCryptoToken()
+    public function testAccessResourceWithJwtAccessToken()
     {
         // add the test parameters in memory
         $server = $this->getTestServer();
@@ -38,17 +63,17 @@ class CryptoTokenTest extends \PHPUnit_Framework_TestCase
             'client_secret' => 'TestSecret',         // valid client secret
         ));
         $server->handleTokenRequest($request, $response = new Response());
-        $this->assertNotNull($cryptoToken = $response->getParameter('access_token'));
+        $this->assertNotNull($JwtAccessToken = $response->getParameter('access_token'));
 
         // make a call to the resource server using the crypto token
         $request = TestRequest::createPost(array(
-            'access_token' => $cryptoToken,
+            'access_token' => $JwtAccessToken,
         ));
 
         $this->assertTrue($server->verifyResourceRequest($request));
     }
 
-    public function testAccessResourceWithCryptoTokenUsingSecondaryStorage()
+    public function testAccessResourceWithJwtAccessTokenUsingSecondaryStorage()
     {
         // add the test parameters in memory
         $server = $this->getTestServer();
@@ -58,11 +83,11 @@ class CryptoTokenTest extends \PHPUnit_Framework_TestCase
             'client_secret' => 'TestSecret',         // valid client secret
         ));
         $server->handleTokenRequest($request, $response = new Response());
-        $this->assertNotNull($cryptoToken = $response->getParameter('access_token'));
+        $this->assertNotNull($JwtAccessToken = $response->getParameter('access_token'));
 
         // make a call to the resource server using the crypto token
         $request = TestRequest::createPost(array(
-            'access_token' => $cryptoToken,
+            'access_token' => $JwtAccessToken,
         ));
 
         // create a resource server with the "memory" storage from the grant server
@@ -71,16 +96,16 @@ class CryptoTokenTest extends \PHPUnit_Framework_TestCase
         $this->assertTrue($resourceServer->verifyResourceRequest($request));
     }
 
-    public function testCryptoTokenWithRefreshToken()
+    public function testJwtAccessTokenWithRefreshToken()
     {
         $server = $this->getTestServer();
 
-        // add "UserCredentials" grant type and "CryptoToken" response type
-        // and ensure "CryptoToken" response type has "RefreshToken" storage
+        // add "UserCredentials" grant type and "JwtAccessToken" response type
+        // and ensure "JwtAccessToken" response type has "RefreshToken" storage
         $memoryStorage = Bootstrap::getInstance()->getMemoryStorage();
         $server->addGrantType(new UserCredentials($memoryStorage));
         $server->addGrantType(new RefreshToken($memoryStorage));
-        $server->addResponseType(new CryptoToken($memoryStorage, $memoryStorage, $memoryStorage), 'token');
+        $server->addResponseType(new JwtAccessToken($memoryStorage, $memoryStorage, $memoryStorage), 'token');
 
         $request = TestRequest::createPost(array(
             'grant_type'    => 'password',         // valid grant type
@@ -92,11 +117,11 @@ class CryptoTokenTest extends \PHPUnit_Framework_TestCase
 
         // make the call to grant a crypto token
         $server->handleTokenRequest($request, $response = new Response());
-        $this->assertNotNull($cryptoToken = $response->getParameter('access_token'));
+        $this->assertNotNull($JwtAccessToken = $response->getParameter('access_token'));
         $this->assertNotNull($refreshToken = $response->getParameter('refresh_token'));
 
         // decode token and make sure refresh_token isn't set
-        list($header, $payload, $signature) = explode('.', $cryptoToken);
+        list($header, $payload, $signature) = explode('.', $JwtAccessToken);
         $decodedToken = json_decode(base64_decode($payload), true);
         $this->assertFalse(array_key_exists('refresh_token', $decodedToken));
 
@@ -117,15 +142,16 @@ class CryptoTokenTest extends \PHPUnit_Framework_TestCase
         $memoryStorage = Bootstrap::getInstance()->getMemoryStorage();
 
         $storage = array(
-            'access_token' => new CryptoTokenStorage($memoryStorage),
+            'access_token' => new JwtAccessTokenStorage($memoryStorage),
             'client' => $memoryStorage,
             'client_credentials' => $memoryStorage,
         );
         $server = new Server($storage);
         $server->addGrantType(new ClientCredentials($memoryStorage));
 
-        // make the "token" response type a CryptoToken
-        $server->addResponseType(new CryptoToken($memoryStorage, $memoryStorage));
+        // make the "token" response type a JwtAccessToken
+        $config = array('issuer' => 'https://api.example.com');
+        $server->addResponseType(new JwtAccessToken($memoryStorage, $memoryStorage, null, $config));
 
         return $server;
     }
diff --git a/test/OAuth2/ServerTest.php b/test/OAuth2/ServerTest.php
index fd824fc..2d1460c 100644
--- a/test/OAuth2/ServerTest.php
+++ b/test/OAuth2/ServerTest.php
@@ -428,9 +428,9 @@ class ServerTest extends \PHPUnit_Framework_TestCase
     /**
      * @expectedException LogicException OAuth2\Storage\PublicKeyInterface
      **/
-    public function testUsingCryptoTokensWithoutPublicKeyStorageThrowsException()
+    public function testUsingJwtAccessTokensWithoutPublicKeyStorageThrowsException()
     {
-        $server = new Server(array(), array('use_crypto_tokens' => true));
+        $server = new Server(array(), array('use_jwt_access_tokens' => true));
         $server->addGrantType($this->getMock('OAuth2\GrantType\GrantTypeInterface'));
         $server->addStorage($this->getMock('OAuth2\Storage\ClientCredentialsInterface'));
         $server->addStorage($this->getMock('OAuth2\Storage\ClientCredentialsInterface'));
@@ -438,10 +438,10 @@ class ServerTest extends \PHPUnit_Framework_TestCase
         $server->getTokenController();
     }
 
-    public function testUsingJustCryptoTokenStorageWithResourceControllerIsOkay()
+    public function testUsingJustJwtAccessTokenStorageWithResourceControllerIsOkay()
     {
         $pubkey = $this->getMock('OAuth2\Storage\PublicKeyInterface');
-        $server = new Server(array($pubkey), array('use_crypto_tokens' => true));
+        $server = new Server(array($pubkey), array('use_jwt_access_tokens' => true));
 
         $this->assertNotNull($server->getResourceController());
         $this->assertInstanceOf('OAuth2\Storage\PublicKeyInterface', $server->getStorage('public_key'));
@@ -450,31 +450,31 @@ class ServerTest extends \PHPUnit_Framework_TestCase
     /**
      * @expectedException LogicException OAuth2\Storage\ClientInterface
      **/
-    public function testUsingJustCryptoTokenStorageWithAuthorizeControllerThrowsException()
+    public function testUsingJustJwtAccessTokenStorageWithAuthorizeControllerThrowsException()
     {
         $pubkey = $this->getMock('OAuth2\Storage\PublicKeyInterface');
-        $server = new Server(array($pubkey), array('use_crypto_tokens' => true));
+        $server = new Server(array($pubkey), array('use_jwt_access_tokens' => true));
         $this->assertNotNull($server->getAuthorizeController());
     }
 
     /**
      * @expectedException LogicException grant_types
      **/
-    public function testUsingJustCryptoTokenStorageWithTokenControllerThrowsException()
+    public function testUsingJustJwtAccessTokenStorageWithTokenControllerThrowsException()
     {
         $pubkey = $this->getMock('OAuth2\Storage\PublicKeyInterface');
-        $server = new Server(array($pubkey), array('use_crypto_tokens' => true));
+        $server = new Server(array($pubkey), array('use_jwt_access_tokens' => true));
         $server->getTokenController();
     }
 
-    public function testUsingCryptoTokenAndClientStorageWithAuthorizeControllerIsOkay()
+    public function testUsingJwtAccessTokenAndClientStorageWithAuthorizeControllerIsOkay()
     {
         $pubkey = $this->getMock('OAuth2\Storage\PublicKeyInterface');
         $client = $this->getMock('OAuth2\Storage\ClientInterface');
-        $server = new Server(array($pubkey, $client), array('use_crypto_tokens' => true, 'allow_implicit' => true));
+        $server = new Server(array($pubkey, $client), array('use_jwt_access_tokens' => true, 'allow_implicit' => true));
         $this->assertNotNull($server->getAuthorizeController());
 
-        $this->assertInstanceOf('OAuth2\ResponseType\CryptoToken', $server->getResponseType('token'));
+        $this->assertInstanceOf('OAuth2\ResponseType\JwtAccessToken', $server->getResponseType('token'));
     }
 
     /**
@@ -526,7 +526,7 @@ class ServerTest extends \PHPUnit_Framework_TestCase
         $server->getAuthorizeController();
 
         $this->assertInstanceOf('OAuth2\OpenID\ResponseType\IdTokenInterface', $server->getResponseType('id_token'));
-        $this->assertNull($server->getResponseType('token id_token'));
+        $this->assertNull($server->getResponseType('id_token token'));
     }
 
     /**
@@ -546,7 +546,7 @@ class ServerTest extends \PHPUnit_Framework_TestCase
         $server->getAuthorizeController();
     }
 
-    public function testUsingOpenIDConnectWithAllowImplicitAndUseCryptoTokensIsOkay()
+    public function testUsingOpenIDConnectWithAllowImplicitAndUseJwtAccessTokensIsOkay()
     {
         $client = $this->getMock('OAuth2\Storage\ClientInterface');
         $userclaims = $this->getMock('OAuth2\OpenID\Storage\UserClaimsInterface');
@@ -555,13 +555,13 @@ class ServerTest extends \PHPUnit_Framework_TestCase
             'use_openid_connect' => true,
             'issuer' => 'someguy',
             'allow_implicit' => true,
-            'use_crypto_tokens' => true,
+            'use_jwt_access_tokens' => true,
         ));
 
         $server->getAuthorizeController();
 
         $this->assertInstanceOf('OAuth2\OpenID\ResponseType\IdTokenInterface', $server->getResponseType('id_token'));
-        $this->assertInstanceOf('OAuth2\OpenID\ResponseType\TokenIdTokenInterface', $server->getResponseType('token id_token'));
+        $this->assertInstanceOf('OAuth2\OpenID\ResponseType\IdTokenTokenInterface', $server->getResponseType('id_token token'));
     }
 
     public function testUsingOpenIDConnectWithAllowImplicitAndAccessTokenStorageIsOkay()
@@ -579,7 +579,7 @@ class ServerTest extends \PHPUnit_Framework_TestCase
         $server->getAuthorizeController();
 
         $this->assertInstanceOf('OAuth2\OpenID\ResponseType\IdTokenInterface', $server->getResponseType('id_token'));
-        $this->assertInstanceOf('OAuth2\OpenID\ResponseType\TokenIdTokenInterface', $server->getResponseType('token id_token'));
+        $this->assertInstanceOf('OAuth2\OpenID\ResponseType\IdTokenTokenInterface', $server->getResponseType('id_token token'));
     }
 
     public function testUsingOpenIDConnectWithAllowImplicitAndAccessTokenResponseTypeIsOkay()
@@ -600,7 +600,7 @@ class ServerTest extends \PHPUnit_Framework_TestCase
         $server->getAuthorizeController();
 
         $this->assertInstanceOf('OAuth2\OpenID\ResponseType\IdTokenInterface', $server->getResponseType('id_token'));
-        $this->assertInstanceOf('OAuth2\OpenID\ResponseType\TokenIdTokenInterface', $server->getResponseType('token id_token'));
+        $this->assertInstanceOf('OAuth2\OpenID\ResponseType\IdTokenTokenInterface', $server->getResponseType('id_token token'));
     }
 
     /**
@@ -642,6 +642,16 @@ class ServerTest extends \PHPUnit_Framework_TestCase
         $this->assertInstanceOf('OAuth2\OpenID\GrantType\AuthorizationCode', $server->getGrantType('authorization_code'));
     }
 
+    public function testMultipleValuedResponseTypeOrderDoesntMatter()
+    {
+        $responseType = $this->getMock('OAuth2\OpenID\ResponseType\IdTokenTokenInterface');
+        $server = new Server(array(), array(), array(), array(
+            'token id_token' => $responseType,
+        ));
+
+        $this->assertEquals($responseType, $server->getResponseType('id_token token'));
+    }
+
     public function testAddGrantTypeWithoutKey()
     {
         $server = new Server();
diff --git a/test/OAuth2/Storage/CryptoTokenTest.php b/test/OAuth2/Storage/JwtAccessTokenTest.php
index e7f686d..38f8be7 100644
--- a/test/OAuth2/Storage/CryptoTokenTest.php
+++ b/test/OAuth2/Storage/JwtAccessTokenTest.php
@@ -4,7 +4,7 @@ namespace OAuth2\Storage;
 
 use OAuth2\Encryption\Jwt;
 
-class CryptoTokenTest extends BaseTest
+class jwtAccessTokenTest extends BaseTest
 {
     /** @dataProvider provideStorage */
     public function testSetAccessToken($storage)
@@ -14,18 +14,18 @@ class CryptoTokenTest extends BaseTest
             return;
         }
 
-        $crypto = new CryptoToken($storage);
+        $crypto = new jwtAccessToken($storage);
 
         $publicKeyStorage = Bootstrap::getInstance()->getMemoryStorage();
         $encryptionUtil = new Jwt();
 
-        $cryptoToken = array(
+        $jwtAccessToken = array(
             'access_token' => rand(),
             'expires' => time() + 100,
             'scope'   => 'foo',
         );
 
-        $token = $encryptionUtil->encode($cryptoToken, $storage->getPrivateKey(), $storage->getEncryptionAlgorithm());
+        $token = $encryptionUtil->encode($jwtAccessToken, $storage->getPrivateKey(), $storage->getEncryptionAlgorithm());
 
         $this->assertNotNull($token);
 
@@ -34,8 +34,8 @@ class CryptoTokenTest extends BaseTest
         $this->assertTrue(is_array($tokenData));
 
         /* assert the decoded token is the same */
-        $this->assertEquals($tokenData['access_token'], $cryptoToken['access_token']);
-        $this->assertEquals($tokenData['expires'], $cryptoToken['expires']);
-        $this->assertEquals($tokenData['scope'], $cryptoToken['scope']);
+        $this->assertEquals($tokenData['access_token'], $jwtAccessToken['access_token']);
+        $this->assertEquals($tokenData['expires'], $jwtAccessToken['expires']);
+        $this->assertEquals($tokenData['scope'], $jwtAccessToken['scope']);
     }
 }
diff --git a/test/lib/OAuth2/Storage/BaseTest.php b/test/lib/OAuth2/Storage/BaseTest.php
index 579997c..921d525 100644..100755
--- a/test/lib/OAuth2/Storage/BaseTest.php
+++ b/test/lib/OAuth2/Storage/BaseTest.php
@@ -14,6 +14,7 @@ abstract class BaseTest extends \PHPUnit_Framework_TestCase
         $redis = Bootstrap::getInstance()->getRedisStorage();
         $cassandra = Bootstrap::getInstance()->getCassandraStorage();
         $dynamodb = Bootstrap::getInstance()->getDynamoDbStorage();
+        $couchbase = Bootstrap::getInstance()->getCouchbase();
 
         /* hack until we can fix "default_scope" dependencies in other tests */
         $memory->defaultScope = 'defaultscope1 defaultscope2';
@@ -27,6 +28,7 @@ abstract class BaseTest extends \PHPUnit_Framework_TestCase
             array($redis),
             array($cassandra),
             array($dynamodb),
+            array($couchbase),
         );
     }
 }
diff --git a/test/lib/OAuth2/Storage/Bootstrap.php b/test/lib/OAuth2/Storage/Bootstrap.php
index 129ca2f..f1af0ba 100644..100755
--- a/test/lib/OAuth2/Storage/Bootstrap.php
+++ b/test/lib/OAuth2/Storage/Bootstrap.php
@@ -15,6 +15,7 @@ class Bootstrap
     private $cassandra;
     private $configDir;
     private $dynamodb;
+    private $couchbase;
 
     public function __construct()
     {
@@ -167,6 +168,43 @@ class Bootstrap
         return true;
     }
 
+    public function getCouchbase()
+    {
+        if (!$this->couchbase) {
+            $skipCouchbase = $this->getEnvVar('SKIP_COUCHBASE_TESTS');
+            if (!$skipCouchbase && class_exists('Couchbase')) {
+
+                $couchbase = new \Couchbase(array('localhost:8091'), '', '', 'auth', false);
+                if ($this->testCouchbaseConnection($couchbase)) {
+                    $this->clearCouchbase($couchbase);
+                    $this->createCouchbaseDB($couchbase);
+
+                    $this->couchbase = new CouchbaseDB($couchbase);
+                } else {
+                    $this->couchbase = new NullStorage('Couchbase', 'Unable to connect to Couchbase server on "localhost:8091"');
+                }
+            } else {
+                $this->couchbase = new NullStorage('Couchbase', 'Missing Couchbase php extension. Please install couchbase.so');
+            }
+        }
+
+        return $this->couchbase;
+    }
+
+    private function testCouchbaseConnection(\Couchbase $couchbase)
+    {
+        try {
+            if (count($couchbase->getServers()) > 0) {
+                return true;
+            }
+        } catch (\CouchbaseException $e) {
+            return false;
+        }
+
+        return true;
+    }
+
+
     public function getCassandraStorage()
     {
         if (!$this->cassandra) {
@@ -341,6 +379,45 @@ class Bootstrap
         return $this->configDir;
     }
 
+
+    private function createCouchbaseDB(\Couchbase $db) {
+
+        $db->set('oauth_clients-oauth_test_client',json_encode(array(
+            'client_id' => "oauth_test_client",
+            'client_secret' => "testpass",
+            'redirect_uri' => "http://example.com",
+            'grant_types' => 'implicit password'
+        )));
+
+        $db->set('oauth_access_tokens-testtoken',json_encode(array(
+            'access_token' => "testtoken",
+            'client_id' => "Some Client"
+        )));
+
+        $db->set('oauth_authorization_codes-testcode',json_encode(array(
+            'access_token' => "testcode",
+            'client_id' => "Some Client"
+        )));
+
+        $db->set('oauth_users-testuser',json_encode(array(
+            'username' => "testuser",
+            'password' => "password"
+        )));
+
+        $db->set('oauth_jwt-oauth_test_client',json_encode(array(
+            'client_id' => 'oauth_test_client',
+            'key'       => $this->getTestPublicKey(),
+            'subject'   => 'test_subject',
+        )));
+    }
+
+    private function clearCouchbase(\Couchbase $cb) {
+        $cb->delete('oauth_authorization_codes-new-openid-code');
+        $cb->delete('oauth_access_tokens-newtoken');
+        $cb->delete('oauth_authorization_codes-newcode');
+        $cb->delete('oauth_refresh_tokens-refreshtoken');
+    }
+
     private function createMongoDb(\MongoDB $db)
     {
         $db->oauth_clients->insert(array(