stormpath-sdk 1.3.0 → 1.3.1

data/spec/resource/collection_spec.rb

@@ -169,7 +169,7 @@ describe Stormpath::Resource::Collection, :vcr do
 
   context 'live examples' do
     context 'testing limits and offsets' do
-      let(:directory) {test_api_client.directories.create name: random_directory_name }
+      let(:directory) { test_api_client.directories.create(build_directory) }
 
       let(:groups) do
         ('A'..'Z').map do |letter|
@@ -211,7 +211,7 @@ describe Stormpath::Resource::Collection, :vcr do
     end
 
     context 'testing limits and offsets with name checking' do
-      let(:directory) {test_api_client.directories.create name: random_directory_name }
+      let(:directory) { test_api_client.directories.create(build_directory) }
 
       let!(:groups) do
         ('1'..'100').map do |number|
@@ -273,7 +273,7 @@ describe Stormpath::Resource::Collection, :vcr do
     end
 
     context '#wild characters search' do
-      let(:directory) {test_api_client.directories.create name: random_directory_name }
+      let(:directory) { test_api_client.directories.create(build_directory) }
 
       # !@#$%^&*()_-+=?><:]}[{'
       # 'jlpicard/!@$%^*()_-+&=?><:]}[{'
@@ -281,7 +281,7 @@ describe Stormpath::Resource::Collection, :vcr do
 
       let!(:account) do
         directory.accounts.create username: username,
-           email: "capt@enterprise.com",
+           email: "captain#{default_domain}",
            givenName: "Jean-Luc",
            surname: "Picard",
            password: "hakunaMatata179Enterprise"
@@ -300,20 +300,20 @@ describe Stormpath::Resource::Collection, :vcr do
       end
 
       it 'should search accounts by email' do
-        expect(directory.accounts.search(email: "capt@enterprise.com").count).to eq(1)
+        expect(directory.accounts.search(email: "captain#{default_domain}").count).to eq(1)
       end
 
       it 'should search accounts by any column (aiming at email)' do
-        expect(directory.accounts.search("capt@enterprise.com").count).to eq(1)
+        expect(directory.accounts.search("captain#{default_domain}").count).to eq(1)
       end
     end
 
     context '#asterisk search on one attribute' do
-      let(:directory) {test_api_client.directories.create name: random_directory_name }
+      let(:directory) { test_api_client.directories.create(build_directory) }
 
       let!(:account) do
         directory.accounts.create username: "jlpicard",
-           email: "capt@enterprise.com",
+           email: "captain#{default_domain}",
            givenName: "Jean-Luc",
            surname: "Picard",
            password: "hakunaMatata179Enterprise"
@@ -337,11 +337,11 @@ describe Stormpath::Resource::Collection, :vcr do
     end
 
     context '#asterisk search on multiple attribute' do
-      let(:directory) {test_api_client.directories.create name: random_directory_name }
+      let(:directory) { test_api_client.directories.create(build_directory) }
 
       let!(:account) do
         directory.accounts.create username: "jlpicard",
-           email: "capt@enterprise.com",
+           email: "captain#{default_domain}",
            givenName: "Jean-Luc",
            surname: "Picard",
            password: "hakunaMatata179Enterprise"
@@ -352,7 +352,7 @@ describe Stormpath::Resource::Collection, :vcr do
       end
 
       it 'should search accounts by username with asterisk at the beginning' do
-        expect(directory.accounts.search(username: "*card", email: "*enterprise.com").count).to eq(1)
+        expect(directory.accounts.search(username: "*card", email: "*stormpath.com").count).to eq(1)
       end
 
       it 'should search accounts by username with asterisk at the end' do
@@ -360,17 +360,17 @@ describe Stormpath::Resource::Collection, :vcr do
       end
 
       it 'should search accounts by username with asterisk at the beginning and the end' do
-        expect(directory.accounts.search(username: "*pic*", email: "*enterprise*").count).to eq(1)
+        expect(directory.accounts.search(username: "*pic*", email: "*stormpath*").count).to eq(1)
       end
     end
 
     context 'search accounts by custom data' do
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
+      let(:directory) { test_api_client.directories.create(build_directory) }
 
       let(:account) do
         directory.accounts.create(
           username: 'jlpicard',
-          email: 'capt@enterprise.com',
+          email: "capt#{default_domain}",
           givenName: 'Jean-Luc',
           surname: 'Picard',
           password: 'hakunaMatata179Enterprise'
@@ -380,7 +380,7 @@ describe Stormpath::Resource::Collection, :vcr do
       let(:account2) do
         directory.accounts.create(
           username: 'jlpicard2',
-          email: 'capt2@enterprise.com',
+          email: "capt2#{default_domain}",
           givenName: 'Jean-Luc2',
           surname: 'Picard2',
           password: 'hakunaMatata179Enterprise'
@@ -402,7 +402,7 @@ describe Stormpath::Resource::Collection, :vcr do
         it 'should search accounts by custom data attribute' do
           expect(account.custom_data['targetAttribute']).to eq 'findMe'
           expect(directory.accounts.count).to eq 2
-          sleep 1
+          sleep 5
           expect(directory.accounts.search('customData.targetAttribute' => 'findMe').count).to eq(2)
         end
       end
@@ -418,7 +418,7 @@ describe Stormpath::Resource::Collection, :vcr do
         it 'should be able to fetch custom data attributes with snake case' do
           expect(account.custom_data['target_attribute']).to eq 'findMe'
           expect(directory.accounts.count).to eq 2
-          sleep 1
+          sleep 5
           expect(directory.accounts.search('customData.target_attribute' => 'findMe').count).to eq(2)
         end
       end

data/spec/resource/custom_data_spec.rb

@@ -6,7 +6,7 @@ describe Stormpath::Resource::CustomData, :vcr do
   end
 
   context 'wuth caching regions' do
-    let(:directory) { test_api_client.directories.create name: random_directory_name }
+    let(:directory) { test_api_client.directories.create(build_directory) }
 
     it_behaves_like 'account_custom_data'
     it_behaves_like 'group_custom_data'
@@ -17,7 +17,7 @@ describe Stormpath::Resource::CustomData, :vcr do
       @disabled_cache_client ||= Stormpath::Client.new({api_key: test_api_key, cache: { store: Stormpath::Cache::DisabledCacheStore }})
     end
 
-    let(:directory) { disabled_cache_client.directories.create name: random_directory_name }
+    let(:directory) { disabled_cache_client.directories.create(build_directory) }
 
     it_behaves_like 'account_custom_data'
     it_behaves_like 'group_custom_data'

data/spec/resource/directory_spec.rb

@@ -1,31 +1,13 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::Directory, :vcr do
-  def create_account_store_mapping(application, account_store, is_default_group_store=false)
-    test_api_client.account_store_mappings.create({
-      application: application,
-      account_store: account_store,
-      list_index: 0,
-      is_default_account_store: true,
-      is_default_group_store: is_default_group_store
-     })
-  end
-
-  describe "instances should respond to attribute property methods" do
-    let(:app) { test_api_client.applications.create name: random_application_name, description: 'Dummy desc.' }
-    let(:application) { test_api_client.applications.get app.href }
-    let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'description_for_some_test_directory' }
-    let(:directory_with_verification) { test_directory_with_verification }
+  let(:application) { test_api_client.applications.create(build_application) }
+  after { application.delete }
 
-    before do
-      test_api_client.account_store_mappings.create({ application: app, account_store: directory_with_verification,
-        list_index: 1, is_default_account_store: false, is_default_group_store: false })
-    end
+  describe 'instances should respond to attribute property methods' do
+    let(:directory) { test_api_client.directories.create(build_directory) }
 
-    after do
-      directory.delete if directory
-      application.delete if application
-    end
+    after { directory.delete }
 
     it do
       expect(directory).to be_a Stormpath::Resource::Directory
@@ -33,12 +15,12 @@ describe Stormpath::Resource::Directory, :vcr do
       [:name, :description, :status].each do |property_accessor|
         expect(directory).to respond_to(property_accessor)
         expect(directory).to respond_to("#{property_accessor}=")
-        expect(directory.send property_accessor).to be_a String
+        expect(directory.send(property_accessor)).to be_a String
       end
 
       [:created_at, :modified_at].each do |property_getter|
         expect(directory).to respond_to(property_getter)
-        expect(directory.send property_getter).to be_a String
+        expect(directory.send(property_getter)).to be_a String
       end
 
       expect(directory.tenant).to be_a Stormpath::Resource::Tenant
@@ -49,34 +31,28 @@ describe Stormpath::Resource::Directory, :vcr do
   end
 
   describe 'directory_associations' do
-    let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'description_for_some_test_directory' }
+    let(:directory) { test_api_client.directories.create(build_directory) }
 
-    after do
-      directory.delete if directory
-    end
+    after { directory.delete }
 
     context '#accounts' do
-      let(:account) { directory.accounts.create build_account}
+      let(:account) { directory.accounts.create(build_account) }
 
-      after do
-        account.delete if account
-      end
+      after { account.delete if account }
 
       it 'should be able to create an account' do
         expect(directory.accounts).to include(account)
       end
 
       it 'should be able to create and fetch the account' do
-        expect(directory.accounts.get account.href).to be
+        expect(directory.accounts.get(account.href)).to be
       end
     end
 
     context '#groups' do
-      let(:group) { directory.groups.create name: random_group_name }
+      let(:group) { directory.groups.create(build_group) }
 
-      after do
-        group.delete if group
-      end
+      after { group.delete }
 
       it 'should be able to create a group' do
         expect(directory.groups).to include(group)
@@ -111,21 +87,13 @@ describe Stormpath::Resource::Directory, :vcr do
     end
 
     context '#organizations' do
-      let(:organization) do
-        test_api_client.organizations.create(name: 'Test organization name',
-                                             name_key: 'test-organization-name-key')
-      end
+      let(:organization) { test_api_client.organizations.create(build_organization) }
 
       let!(:organization_account_store_mappings) do
-        test_api_client.organization_account_store_mappings.create(
-          account_store: { href: directory.href },
-          organization: { href: organization.href }
-        )
+        map_organization_store(directory, organization)
       end
 
-      after do
-        organization.delete
-      end
+      after { organization.delete }
 
       it 'should be able to get organizations' do
         expect(directory.organizations).to include(organization)
@@ -144,104 +112,98 @@ describe Stormpath::Resource::Directory, :vcr do
   end
 
   describe '#create_account' do
-    let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'description_for_some_test_directory' }
-
-    let(:account) do
-      Stormpath::Resource::Account.new({
-        email: random_email,
-        given_name: 'Ruby SDK',
-        password: 'P@$$w0rd',
-        surname: 'SDK',
-        username: random_user_name
-      })
-    end
+    let(:directory) { test_api_client.directories.create(build_directory) }
+    let(:account) { Stormpath::Resource::Account.new(build_account) }
 
-    after do
-      directory.delete if directory
-    end
+    after { directory.delete }
 
     context 'without registration workflow' do
+      let(:created_account) { directory.create_account(account) }
 
-      let(:created_account) { directory.create_account account }
-
-      after do
-        created_account.delete if created_account
-      end
+      after { created_account.delete }
 
       it 'creates an account with status ENABLED' do
         expect(created_account).to be
         expect(created_account.username).to eq(account.username)
         expect(created_account).to eq(account)
-        expect(created_account.status).to eq("ENABLED")
+        expect(created_account.status).to eq('ENABLED')
         expect(created_account.email_verification_token).not_to be
       end
     end
 
     context 'with registration workflow' do
+      let(:directory_with_verification) { test_api_client.directories.create(build_directory) }
 
-      let(:created_account_with_reg_workflow) { test_directory_with_verification.create_account account }
-
-      after do
-        created_account_with_reg_workflow.delete if created_account_with_reg_workflow
+      before do
+        map_account_store(application, directory_with_verification, 1, false, false)
+        enable_email_verification(directory_with_verification)
       end
 
-      it 'creates an account with status UNVERIFIED' do
-        expect(created_account_with_reg_workflow).to be
-        expect(created_account_with_reg_workflow.username).to eq(account.username)
-        expect(created_account_with_reg_workflow).to eq(account)
-        expect(created_account_with_reg_workflow.status).to eq("UNVERIFIED")
-        expect(created_account_with_reg_workflow.email_verification_token.href).to be
-      end
+      after { directory_with_verification.delete }
 
-    end
+      context 'enabled on account creation' do
+        let(:created_account_with_reg_workflow) do
+          directory_with_verification.create_account(account)
+        end
 
-    context 'with registration workflow but set it to false on account creation' do
-      let(:created_account_with_reg_workflow) { test_directory_with_verification.create_account account, false }
+        after { created_account_with_reg_workflow.delete }
 
-      after do
-        created_account_with_reg_workflow.delete if created_account_with_reg_workflow
+        it 'creates an account with status UNVERIFIED' do
+          expect(created_account_with_reg_workflow).to be
+          expect(created_account_with_reg_workflow.username).to eq(account.username)
+          expect(created_account_with_reg_workflow).to eq(account)
+          expect(created_account_with_reg_workflow.status).to eq('UNVERIFIED')
+          expect(created_account_with_reg_workflow.email_verification_token.href).to be
+        end
       end
 
-      it 'creates an account with status ENABLED' do
-        expect(created_account_with_reg_workflow).to be
-        expect(created_account_with_reg_workflow.username).to eq(account.username)
-        expect(created_account_with_reg_workflow).to eq(account)
-        expect(created_account_with_reg_workflow.status).to eq("ENABLED")
-        expect(created_account_with_reg_workflow.email_verification_token).not_to be
+      context 'disabled on account creation' do
+        let(:created_account_with_reg_workflow) do
+          directory_with_verification.create_account(account, false)
+        end
+
+        after { created_account_with_reg_workflow.delete }
+
+        it 'creates an account with status ENABLED' do
+          expect(created_account_with_reg_workflow).to be
+          expect(created_account_with_reg_workflow.username).to eq(account.username)
+          expect(created_account_with_reg_workflow).to eq(account)
+          expect(created_account_with_reg_workflow.status).to eq('ENABLED')
+          expect(created_account_with_reg_workflow.email_verification_token).not_to be
+        end
       end
     end
   end
 
   describe 'create account with password import MCF feature' do
-    let(:app) { test_api_client.applications.create name: random_application_name, description: 'Dummy desc.' }
-    let(:application) { test_api_client.applications.get app.href }
-    let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'description_for_some_test_directory' }
-    let!(:account_store_mapping) {create_account_store_mapping(application,directory,true)}
+    let(:directory) { test_api_client.directories.create(build_directory) }
+
+    before { map_account_store(application, directory, 0, true, true) }
 
     after do
-      application.delete if application
       directory.delete if directory
-      @account.delete if @account
-    end
-
-    context "MD5 hashing algorithm" do
-      before do
-        account_store_mapping
-        @account = directory.accounts.create({
-          username: "jlucpicard",
-          email: "captain@enterprise.com",
-          given_name: "Jean-Luc",
-          surname: "Picard",
-          password: "$stormpath2$MD5$1$OGYyMmM5YzVlMDEwODEwZTg3MzM4ZTA2YjljZjMxYmE=$EuFAr2NTM83PrizVAYuOvw=="
-        }, password_format: 'mcf')
+      account.delete if account
+    end
+
+    context 'MD5 hashing algorithm' do
+      let!(:account) do
+        directory.accounts.create(
+          {
+            username: 'jlucpicard',
+            email: "captain#{default_domain}",
+            given_name: 'Jean-Luc',
+            surname: 'Picard',
+            password: '$stormpath2$MD5$1$OGYyMmM5YzVlMDEwODEwZTg3MzM4ZTA2YjljZjMxYmE=$EuFAr2NTM83PrizVAYuOvw=='
+          }, password_format: 'mcf'
+        )
       end
 
       it 'creates an account' do
-        expect(@account).to be_a Stormpath::Resource::Account
-        expect(@account.username).to eq("jlucpicard")
-        expect(@account.email).to eq("captain@enterprise.com")
-        expect(@account.given_name).to eq("Jean-Luc")
-        expect(@account.surname).to eq("Picard")
+        expect(account).to be_a Stormpath::Resource::Account
+        expect(account.username).to eq('jlucpicard')
+        expect(account.email).to eq("captain#{default_domain}")
+        expect(account.given_name).to eq('Jean-Luc')
+        expect(account.surname).to eq('Picard')
       end
 
       it 'can authenticate with the account credentials' do
@@ -250,30 +212,31 @@ describe Stormpath::Resource::Directory, :vcr do
 
         expect(auth_result).to be_a Stormpath::Authentication::AuthenticationResult
         expect(auth_result.account).to be_a Stormpath::Resource::Account
-        expect(auth_result.account.email).to eq("captain@enterprise.com")
-        expect(auth_result.account.given_name).to eq("Jean-Luc")
-        expect(auth_result.account.surname).to eq("Picard")
-      end
-    end
-
-    context "SHA-512 hashing algorithm" do
-      before do
-        account_store_mapping
-        @account = directory.accounts.create({
-          username: "jlucpicard",
-          email: "captain@enterprise.com",
-          given_name: "Jean-Luc",
-          surname: "Picard",
-          password: "$stormpath2$SHA-512$1$ZFhBRmpFSnEwVEx2ekhKS0JTMDJBNTNmcg==$Q+sGFg9e+pe9QsUdfnbJUMDtrQNf27ezTnnGllBVkQpMRc9bqH6WkyE3y0svD/7cBk8uJW9Wb3dolWwDtDLFjg=="
-        }, password_format: 'mcf')
+        expect(auth_result.account.email).to eq("captain#{default_domain}")
+        expect(auth_result.account.given_name).to eq('Jean-Luc')
+        expect(auth_result.account.surname).to eq('Picard')
+      end
+    end
+
+    context 'SHA-512 hashing algorithm' do
+      let!(:account) do
+        directory.accounts.create(
+          {
+            username: 'jlucpicard',
+            email: "captain#{default_domain}",
+            given_name: 'Jean-Luc',
+            surname: 'Picard',
+            password: '$stormpath2$SHA-512$1$ZFhBRmpFSnEwVEx2ekhKS0JTMDJBNTNmcg==$Q+sGFg9e+pe9QsUdfnbJUMDtrQNf27ezTnnGllBVkQpMRc9bqH6WkyE3y0svD/7cBk8uJW9Wb3dolWwDtDLFjg=='
+          }, password_format: 'mcf'
+        )
       end
 
       it 'creates an account' do
-        expect(@account).to be_a Stormpath::Resource::Account
-        expect(@account.username).to eq("jlucpicard")
-        expect(@account.email).to eq("captain@enterprise.com")
-        expect(@account.given_name).to eq("Jean-Luc")
-        expect(@account.surname).to eq("Picard")
+        expect(account).to be_a Stormpath::Resource::Account
+        expect(account.username).to eq('jlucpicard')
+        expect(account.email).to eq("captain#{default_domain}")
+        expect(account.given_name).to eq('Jean-Luc')
+        expect(account.surname).to eq('Picard')
       end
 
       it 'can authenticate with the account credentials' do
@@ -282,30 +245,31 @@ describe Stormpath::Resource::Directory, :vcr do
 
         expect(auth_result).to be_a Stormpath::Authentication::AuthenticationResult
         expect(auth_result.account).to be_a Stormpath::Resource::Account
-        expect(auth_result.account.email).to eq("captain@enterprise.com")
-        expect(auth_result.account.given_name).to eq("Jean-Luc")
-        expect(auth_result.account.surname).to eq("Picard")
-      end
-    end
-
-    context "BCrypt 2A hashing algorithm" do
-      before do
-        account_store_mapping
-        @account = directory.accounts.create({
-          username: "jlucpicard",
-          email: "captain@enterprise.com",
-          given_name: "Jean-Luc",
-          surname: "Picard",
-          password: "$2a$10$sWvxHJIvkARbp.u2yBpuJeGzNvpxYQo7AYxAJwFRH0HptXSWyqvwy"
-        }, password_format: 'mcf')
+        expect(auth_result.account.email).to eq("captain#{default_domain}")
+        expect(auth_result.account.given_name).to eq('Jean-Luc')
+        expect(auth_result.account.surname).to eq('Picard')
+      end
+    end
+
+    context 'BCrypt 2A hashing algorithm' do
+      let!(:account) do
+        directory.accounts.create(
+          {
+            username: 'jlucpicard',
+            email: "captain#{default_domain}",
+            given_name: 'Jean-Luc',
+            surname: 'Picard',
+            password: '$2a$10$sWvxHJIvkARbp.u2yBpuJeGzNvpxYQo7AYxAJwFRH0HptXSWyqvwy'
+          }, password_format: 'mcf'
+        )
       end
 
       it 'creates an account' do
-        expect(@account).to be_a Stormpath::Resource::Account
-        expect(@account.username).to eq("jlucpicard")
-        expect(@account.email).to eq("captain@enterprise.com")
-        expect(@account.given_name).to eq("Jean-Luc")
-        expect(@account.surname).to eq("Picard")
+        expect(account).to be_a Stormpath::Resource::Account
+        expect(account.username).to eq('jlucpicard')
+        expect(account.email).to eq("captain#{default_domain}")
+        expect(account.given_name).to eq('Jean-Luc')
+        expect(account.surname).to eq('Picard')
       end
 
       it 'can authenticate with the account credentials' do
@@ -314,55 +278,40 @@ describe Stormpath::Resource::Directory, :vcr do
 
         expect(auth_result).to be_a Stormpath::Authentication::AuthenticationResult
         expect(auth_result.account).to be_a Stormpath::Resource::Account
-        expect(auth_result.account.email).to eq("captain@enterprise.com")
-        expect(auth_result.account.given_name).to eq("Jean-Luc")
-        expect(auth_result.account.surname).to eq("Picard")
+        expect(auth_result.account.email).to eq("captain#{default_domain}")
+        expect(auth_result.account.given_name).to eq('Jean-Luc')
+        expect(auth_result.account.surname).to eq('Picard')
       end
     end
 
     context 'with account data as hash' do
-      let(:account_email) { random_email }
-
-      let(:created_account_with_hash) do
-        directory.create_account({
-          email: account_email,
-          given_name: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK',
-          username: random_user_name
-        })
-      end
-
-      after do
-        created_account_with_hash.delete if created_account_with_hash
-      end
+      let(:account_email) { 'rubysdk' }
+      let(:account) { directory.create_account(build_account(email: account_email)) }
 
       it 'creates an account with status ENABLED' do
-        expect(created_account_with_hash.email).to eq(account_email)
-        expect(created_account_with_hash.given_name).to eq('Ruby SDK')
-        expect(created_account_with_hash.surname).to eq('SDK')
-        expect(created_account_with_hash.status).to eq("ENABLED")
+        expect(account.email).to eq("#{account_email}#{default_domain}")
+        expect(account.given_name).to eq('givenname')
+        expect(account.surname).to eq('surname')
+        expect(account.status).to eq('ENABLED')
       end
     end
-
   end
 
   describe '#create_directory_with_custom_data' do
-    let(:directory_name) { random_directory_name }
-
-    let(:directory) { test_api_client.directories.create name: directory_name, description: 'description_for_some_test_directory' }
-
-    after do
-      directory.delete if directory
+    let(:directory) do
+      test_api_client.directories.create(build_directory(name: 'rubysdkdir',
+                                                         description: 'rubysdkdir desc'))
     end
 
+    after { directory.delete }
+
     it 'creates an directory with custom data' do
-      directory.custom_data["category"] = "classified"
+      directory.custom_data['category'] = 'classified'
 
       directory.save
-      expect(directory.name).to eq(directory_name)
-      expect(directory.description).to eq('description_for_some_test_directory')
-      expect(directory.custom_data["category"]).to eq("classified")
+      expect(directory.name).to eq('rubysdkdir')
+      expect(directory.description).to eq('rubysdkdir desc')
+      expect(directory.custom_data['category']).to eq('classified')
     end
   end
 
@@ -370,7 +319,7 @@ describe Stormpath::Resource::Directory, :vcr do
     context 'valida data' do
       let(:directory) do
         test_api_client.directories.create(
-          name: random_directory_name,
+          name: 'rubysdkdir',
           description: 'description_for_some_test_directory',
           provider: {
             provider_id: "saml",
@@ -405,7 +354,7 @@ describe Stormpath::Resource::Directory, :vcr do
       it 'raises Stormpath::Error' do
         expect do
           test_api_client.directories.create(
-            name: random_directory_name,
+            name: 'rubysdkdir',
             description: 'description_for_some_test_directory',
             provider: {
               provider_id: "saml",
@@ -423,7 +372,7 @@ describe Stormpath::Resource::Directory, :vcr do
   describe 'saml #provider' do
     let(:directory) do
       test_api_client.directories.create(
-        name: random_directory_name,
+        name: 'rubysdkdir',
         description: 'description_for_some_test_directory',
         provider: {
           provider_id: "saml",
@@ -459,7 +408,7 @@ describe Stormpath::Resource::Directory, :vcr do
   describe 'saml #provider_metadata' do
     let(:directory) do
       test_api_client.directories.create(
-        name: random_directory_name,
+        name: 'rubysdkdir',
         description: 'description_for_some_test_directory',
         provider: {
           provider_id: "saml",
@@ -495,7 +444,7 @@ describe Stormpath::Resource::Directory, :vcr do
   describe 'saml mapping rules' do
     let(:directory) do
       test_api_client.directories.create(
-        name: random_directory_name,
+        name: 'rubysdkdir',
         description: 'description_for_some_test_directory',
         provider: {
           provider_id: "saml",
@@ -535,74 +484,49 @@ describe Stormpath::Resource::Directory, :vcr do
   end
 
   describe '#create_account_with_custom_data' do
-    let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'description_for_some_test_directory' }
+    let(:directory) { test_api_client.directories.create(build_directory) }
 
-    after do
-      directory.delete if directory
-    end
+    after { directory.delete }
 
-      it 'creates an account with custom data' do
-        account =  Stormpath::Resource::Account.new({
-          email: random_email,
-          given_name: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK',
-          username: random_user_name
-        })
+    it 'creates an account with custom data' do
+      account = Stormpath::Resource::Account.new(build_account)
 
-        account.custom_data["birth_date"] = "2305-07-13"
+      account.custom_data['birth_date'] = '2305-07-13'
 
-        created_account = directory.create_account account
+      created_account = directory.create_account account
 
-        expect(created_account).to be
-        expect(created_account.username).to eq(account.username)
-        expect(created_account).to eq(account)
-        expect(created_account.custom_data["birth_date"]).to eq("2305-07-13")
-        created_account.delete
+      expect(created_account).to be
+      expect(created_account.username).to eq(account.username)
+      expect(created_account).to eq(account)
+      expect(created_account.custom_data['birth_date']).to eq('2305-07-13')
+      created_account.delete
     end
   end
 
   describe '#create_group' do
-    let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'description_for_some_test_directory' }
+    let(:directory) { test_api_client.directories.create(build_directory) }
 
-    after do
-      directory.delete if directory
-    end
+    after { directory.delete }
 
     context 'given a valid group' do
-      let(:group_name) { "valid_test_group" }
+      let(:created_group) { directory.groups.create(build_group(name: 'rubysdkgroup')) }
 
-      let(:created_group) { directory.groups.create name: group_name }
-
-      after do
-        created_group.delete if created_group
-      end
+      after { created_group.delete }
 
       it 'creates a group' do
         expect(created_group).to be
-        expect(created_group.name).to eq(group_name)
+        expect(created_group.name).to eq('rubysdkgroup')
       end
     end
   end
 
   describe '#delete_directory' do
+    let(:directory) { test_api_client.directories.create(build_directory) }
+    let!(:group) { directory.groups.create(build_group) }
+    let!(:account) { directory.accounts.create(build_account) }
+    let!(:account_store_mapping) { map_account_store(application, directory, 0, true, true) }
 
-    let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-    let(:application) { test_api_client.applications.create name: random_application_name }
-
-    let!(:group) { directory.groups.create name: 'someGroup' }
-
-    let!(:account) { directory.accounts.create({ email: 'rubysdk@example.com', given_name: 'Ruby SDK', password: 'P@$$w0rd',surname: 'SDK' }) }
-
-    let!(:account_store_mapping) do
-      test_api_client.account_store_mappings.create({ application: application, account_store: directory })
-    end
-
-    after do
-      application.delete if application
-      directory.delete if directory
-    end
+    after { directory.delete }
 
     it 'and all of its associations' do
       expect(directory.groups.count).to eq(1)