public function testGetFacebookProvider()
 {
     $clientId = makeUniqueName("mockClientId");
     $clientSecret = makeUniqueName("mockClientSecret");
     $provider = self::$client->dataStore->instantiate(\Stormpath\Stormpath::FACEBOOK_PROVIDER);
     $provider->clientId = $clientId;
     $provider->clientSecret = $clientSecret;
     $directoryName = makeUniqueName("my-facebook-directory-2");
     $directoryDescription = makeUniqueName("A Facebook directory");
     $directory = self::$client->dataStore->instantiate(\Stormpath\Stormpath::DIRECTORY);
     $directory->name = $directoryName;
     $directory->description = $directoryDescription;
     $directory->provider = $provider;
     $tenant = self::$client->getCurrentTenant();
     $returnedDirectory = $tenant->createDirectory($directory);
     $this->assertNotNull($returnedDirectory);
     $returnedProvider = self::$client->dataStore->getResource($returnedDirectory->href . "/" . Provider::PATH, \Stormpath\Stormpath::FACEBOOK_PROVIDER);
     $this->assertEquals(FacebookProvider::FACEBOOK_PROVIDER_ID, $returnedProvider->providerId);
     $this->assertNotEmpty($returnedProvider->createdAt);
     $this->assertNotEmpty($returnedProvider->modifiedAt);
     $this->assertEquals($clientId, $returnedProvider->clientId);
     $this->assertEquals($clientSecret, $returnedProvider->clientSecret);
     $tokens = explode('/', $returnedDirectory->href);
     $directoryId = end($tokens);
     $this->assertEquals($returnedProvider, FacebookProvider::get($directoryId));
     $this->assertEquals($returnedProvider, FacebookProvider::get($directoryId . '/' . Provider::PATH));
     $this->assertEquals($returnedProvider, FacebookProvider::get(Directory::PATH . '/' . $directoryId . '/' . Provider::PATH));
     $this->assertEquals($returnedProvider, FacebookProvider::get($returnedDirectory->href));
     $this->assertEquals($returnedProvider, FacebookProvider::get($returnedDirectory->href . '/' . Provider::PATH));
     $returnedDirectory->delete();
 }

 public static function setUpBeforeClass()
 {
     parent::setUpBeforeClass();
     self::$application = \Stormpath\Resource\Application::instantiate(array('name' => makeUniqueName('Application ApiRequestAuthenticatorTest'), 'description' => 'Application for ApiRequestAuthenticatorTest', 'status' => 'enabled'));
     parent::createResource(\Stormpath\Resource\Application::PATH, self::$application, array('createDirectory' => true));
     self::$account = \Stormpath\Resource\Account::instantiate(array('givenName' => 'PHP', 'middleName' => 'ApiRequestAuthenticatorTest', 'surname' => 'Test', 'username' => makeUniqueName('ApiRequestAuthenticatorTest'), 'email' => makeUniqueName('ApiRequestAuthenticatorTest') . '@unknown123.kot', 'password' => 'superP4ss'));
     self::$application->createAccount(self::$account);
     self::$apiKey = self::$account->createApiKey();
 }

 public static function setUpBeforeClass()
 {
     parent::setUpBeforeClass();
     self::$samlProvider = \Stormpath\Resource\SamlProvider::instantiate(['ssoLoginUrl' => 'http://google.com/login', 'ssoLogoutUrl' => 'http://google.com/logout', 'encodedX509SigningCert' => self::getDummyCertForSaml(), 'requestSignatureAlgorithm' => 'RSA-SHA1']);
     self::$directory = \Stormpath\Resource\Directory::create(['name' => makeUniqueName('DirectoryTest samlProvider'), 'provider' => self::$samlProvider]);
     $parts = explode('/', self::$directory->href);
     self::$directoryId = end($parts);
     self::$metadata = SamlProvider::get(self::$directory->provider->href)->serviceProviderMetadata;
 }

 public function testCreateDirectory()
 {
     $tenant = self::$client->tenant;
     $name = makeUniqueName('TenantTest createDirectory');
     $directory = \Stormpath\Resource\Directory::instantiate(array('name' => $name));
     $tenant->createDirectory($directory);
     //$this->assertInstanceOf('\Stormpath\Resource\Directory', $directory);
     $this->assertEquals($tenant->name, $directory->tenant->name);
     $this->assertEquals($name, $directory->name);
     foreach ($tenant->directories as $dir) {
         $this->assertInstanceOf('\\Stormpath\\Resource\\Directory', $dir);
     }
     $directory->delete();
 }

 /**
  * @expectedException \Stormpath\Resource\ResourceError
  */
 public function testDelete()
 {
     $group = \Stormpath\Resource\Group::instantiate(array('name' => makeUniqueName('GroupMembershipTest testDelete')));
     self::$directory->createGroup($group);
     $account = \Stormpath\Resource\Account::instantiate(array('givenName' => 'Account Name', 'surname' => 'Surname', 'email' => makeUniqueName('GroupMembershipTest testDelete') . '@unknown12345678.kot', 'password' => 'superP4ss'));
     self::$directory->createAccount($account);
     $groupMembership = \Stormpath\Resource\GroupMembership::create(array('account' => $account, 'group' => $group));
     $groupMembership = \Stormpath\Resource\GroupMembership::get($groupMembership->href);
     $this->assertInstanceOf('\\Stormpath\\Resource\\GroupMembership', $groupMembership);
     $this->assertContains('testDelete', $groupMembership->group->name);
     $this->assertContains('@unknown12345678.kot', $groupMembership->account->email);
     $href = $groupMembership->href;
     $groupMembership->delete();
     \Stormpath\Resource\GroupMembership::get($href);
 }

 private function createDirectory()
 {
     $directory = \Stormpath\Resource\Directory::instantiate(array('name' => makeUniqueName('Directory For Request Signer Test'), 'description' => 'Main Directory description'));
     return self::createResource(\Stormpath\Resource\Directory::PATH, $directory);
 }

 /**
  * @test
  */
 public function it_can_add_an_account_store_mapping()
 {
     $application = \Stormpath\Resource\Application::instantiate(['name' => makeUniqueName('OrgTest'), 'description' => 'Description of Main App', 'status' => 'enabled']);
     $application = self::createResource(\Stormpath\Resource\Application::PATH, $application);
     $accountStoreMapping = \Stormpath\Resource\AccountStoreMapping::instantiate(['organization' => self::$organization, 'accountStore' => self::$directory, 'isDefaultAccountStore' => true, 'isDefaultGroupStore' => true]);
     $test1 = self::$organization->createOrganizationAccountStoreMapping($accountStoreMapping);
     $this->assertInstanceOf('\\Stormpath\\Resource\\AccountStoreMapping', $test1);
     $accountStoreMapping = \Stormpath\Resource\AccountStoreMapping::instantiate(['accountStore' => self::$organization, 'application' => $application, 'isDefaultAccountStore' => true]);
     $test2 = $application->createAccountStoreMapping($accountStoreMapping);
     $this->assertInstanceOf('\\Stormpath\\Resource\\AccountStoreMapping', $test2);
     $org = Organization::get(self::$organization->href);
     $this->assertNotNull($org->accountStoreMappings->href);
     $this->assertInstanceOf('Stormpath\\Resource\\AccountStore', $org->defaultAccountStoreMapping);
     $this->assertInstanceOf('Stormpath\\Resource\\AccountStore', $org->defaultGroupStoreMapping);
     $asm = $org->accountStoreMappings;
     foreach ($asm as $mapping) {
         $this->assertEquals($org->href, $mapping->organization->href);
         $this->assertEquals(self::$directory->href, $mapping->accountStore->href);
     }
     $app = Application::get($application->href);
     $this->assertNotNull($app->accountStoreMappings->href);
     $asm = $app->accountStoreMappings;
     foreach ($asm as $mapping) {
         $this->assertEquals($app->href, $mapping->application->href);
         $this->assertEquals(self::$organization->href, $mapping->accountStore->href);
     }
     $application->delete();
 }

 public function testShouldBeAbleToGetGroupViaHTMLFragment()
 {
     $group = \Stormpath\Resource\Group::instantiate(array('name' => makeUniqueName('GroupTest htmlFragment')));
     self::$directory->createGroup($group);
     $href = $group->href;
     $hrefParts = array_reverse(explode('/', $href));
     $group = \Stormpath\Resource\Group::get($hrefParts[0]);
     $this->assertInstanceOf('\\Stormpath\\Resource\\Group', $group);
     $this->assertEquals($href, $group->href);
     $group2 = \Stormpath\Client::get($hrefParts[1] . '/' . $hrefParts[0], Stormpath::GROUP);
     $this->assertInstanceOf('\\Stormpath\\Resource\\Group', $group2);
     $this->assertEquals($href, $group2->href);
     $group->delete();
 }

 /** @test */
 public function an_application_should_allow_setting_authorized_callback_uri()
 {
     $application = \Stormpath\Resource\Application::create(array('name' => makeUniqueName('ApplicationTest authorizedCallbackUri')));
     $application->setAuthorizedCallbackUris(['http://myapplication.com/whatever/callback', 'http://myapplication.com/whatever/callback2']);
     $application->save();
     $application = \Stormpath\Resource\Application::get($application->href);
     $this->assertCount(2, $application->authorizedCallbackUris);
     $application->delete();
 }

 public static function setUpBeforeClass()
 {
     parent::setUpBeforeClass();
     self::$directory = \Stormpath\Resource\Directory::create(array('name' => makeUniqueName('AccountCreationPolicyTest')));
     self::$acp = self::$directory->accountCreationPolicy;
 }

 public function testShouldBeAbleToGetDirectoryViaHTMLFragment()
 {
     $directory = \Stormpath\Resource\Directory::create(array('name' => makeUniqueName('DirectoryTest htmlFragment')));
     $href = $directory->href;
     $hrefParts = array_reverse(explode('/', $href));
     $dir = \Stormpath\Resource\Directory::get($hrefParts[0]);
     $this->assertInstanceOf('\\Stormpath\\Resource\\Directory', $dir);
     $this->assertEquals($href, $dir->href);
     $dir2 = \Stormpath\Client::get($hrefParts[1] . '/' . $hrefParts[0], Stormpath::DIRECTORY);
     $this->assertInstanceOf('\\Stormpath\\Resource\\Directory', $dir2);
     $this->assertEquals($href, $dir2->href);
     $directory->delete();
 }

 /** @test */
 public function a_directory_can_add_a_saml_provider()
 {
     $samlProvider = \Stormpath\Resource\SamlProvider::instantiate(['ssoLoginUrl' => 'http://google.com/login', 'ssoLogoutUrl' => 'http://google.com/logout', 'encodedX509SigningCert' => $this->getDummyCertForSaml(), 'requestSignatureAlgorithm' => 'RSA-SHA1']);
     $directory = \Stormpath\Resource\Directory::create(['name' => makeUniqueName('DirectoryTest samlProvider'), 'provider' => $samlProvider]);
     $this->assertInstanceOf('Stormpath\\Resource\\Directory', $directory);
     $this->assertInstanceOf('Stormpath\\Resource\\Provider', $directory->provider);
     $this->assertEquals('saml', $directory->provider->providerId);
     $directory->delete();
 }

 /**
  * @expectedException \Stormpath\Resource\ResourceError
  */
 public function testDelete()
 {
     $application = \Stormpath\Resource\Application::create(array('name' => makeUniqueName('ApplicationTest testDelete')));
     $this->assertInstanceOf('Stormpath\\Resource\\Application', $application);
     $this->assertContains('testDelete', $application->name);
     $href = $application->href;
     $application->delete();
     \Stormpath\Resource\Application::get($href);
 }

 public function testDelete()
 {
     $application = \Stormpath\Resource\Application::instantiate(array('name' => makeUniqueName('AccountStoreMappingTest Test Delete')));
     self::createResource(\Stormpath\Resource\Application::PATH, $application);
     $accountStoreMappingWithDir = \Stormpath\Resource\AccountStoreMapping::create(array('accountStore' => self::$directory, 'application' => $application));
     $href = $accountStoreMappingWithDir->href;
     $accountStoreMapping = \Stormpath\Resource\AccountStoreMapping::get($href);
     $this->assertInstanceOf('Stormpath\\Resource\\AccountStoreMapping', $accountStoreMapping);
     $this->assertInstanceOf('Stormpath\\Resource\\Directory', $accountStoreMapping->accountStore);
     $accountStoreMapping->delete();
     try {
         \Stormpath\Resource\AccountStoreMapping::get($href);
         $application->delete();
         $this->fail('Should have thrown a ResourceError.');
     } catch (\Stormpath\Resource\ResourceError $re) {
         $this->assertTrue(true);
     }
     $application->delete();
 }

 public function testShouldBeAbleToGetApplicationViaHTMLFragment()
 {
     $application = \Stormpath\Resource\Application::create(array('name' => makeUniqueName('ApplicationTest testFragment')));
     $href = $application->href;
     $hrefParts = array_reverse(explode('/', $href));
     $app = \Stormpath\Resource\Application::get($hrefParts[0]);
     $this->assertInstanceOf('\\Stormpath\\Resource\\Application', $app);
     $this->assertEquals($href, $app->href);
     $app2 = \Stormpath\Client::get($hrefParts[1] . '/' . $hrefParts[0], Stormpath::APPLICATION);
     $this->assertInstanceOf('\\Stormpath\\Resource\\Application', $app2);
     $this->assertEquals($href, $app2->href);
     $application->delete();
 }

 /**
  * @expectedException \Stormpath\Resource\ResourceError
  * @expectedExceptionMessage The imported password designates an algorithm that is an unsupported value.
  */
 public function testImportingInvalidPasswordFormatTypeShouldThrowException()
 {
     $username = makeUniqueName('AccountTest testImportingInvalidPasswordFormat') . 'username';
     $client = Client::getInstance();
     self::$application = \Stormpath\Resource\Application::instantiate(array('name' => 'Main App for passwordImport' . makeUniqueName('AccountTest testImportingInvalidPasswordFormat'), 'description' => 'Description of Main App', 'status' => 'enabled'));
     self::createResource(\Stormpath\Resource\Application::PATH, self::$application, array('createDirectory' => true));
     $account = $client->dataStore->instantiate(\Stormpath\Stormpath::ACCOUNT);
     $account->email = '[email protected]';
     $account->givenName = 'John';
     $account->password = '$2a$08$VbNS17zvQNYtMyfRiYXxWuec2F2y3SuLB/e7hU8RWdcCxxluUB3m.';
     $account->surname = 'Smith';
     $account->username = $username;
     self::$application->createAccount($account, array('passwordFormat' => 'someOtherMCF'));
     $result = self::$application->authenticate($username, 'SomePassw0rd!');
     $this->assertEquals($username, $result->account->username);
     $account->delete();
 }

 /** @test */
 public function a_provider_can_save_an_attribute_statement_mapping_rule()
 {
     $samlProvider = \Stormpath\Resource\SamlProvider::instantiate(['ssoLoginUrl' => 'http://google.com/login', 'ssoLogoutUrl' => 'http://google.com/logout', 'encodedX509SigningCert' => self::getDummyCertForSaml(), 'requestSignatureAlgorithm' => 'RSA-SHA1']);
     $directory = \Stormpath\Resource\Directory::create(['name' => makeUniqueName('DirectoryTest samlProvider'), 'provider' => $samlProvider]);
     $providerHref = $directory->provider->href;
     $provider = SamlProvider::get($providerHref);
     $ruleBuilder = new \Stormpath\Saml\AttributeStatementMappingRuleBuilder();
     $rule = $ruleBuilder->setName('test1')->setAccountAttributes(['customData.test1'])->build();
     $rule2 = $ruleBuilder->setName('test2')->setAccountAttributes(['customData.test2'])->build();
     $rulesBuilder = new \Stormpath\Saml\AttributeStatementMappingRulesBuilder();
     $rulesBuilder->setAttributeStatementMappingRules([$rule, $rule2]);
     $rules = $rulesBuilder->build();
     $provider->setAttributeStatementMappingRules($rules);
     $provider->save();
     $provider = SamlProvider::get($providerHref);
     $mappingRules = $provider->getAttributeStatementMappingRules();
     $this->assertCount(2, $mappingRules->items);
     foreach ($mappingRules->items as $item) {
         $this->assertInstanceOf('Stormpath\\Saml\\AttributeStatementMappingRule', $item);
     }
     $this->assertEquals('test2', $mappingRules->items[1]->name);
     $directory->delete();
 }