stormpath-sdk 1.3.0 → 1.3.1

data/spec/resource/account_store_mapping_spec.rb

@@ -1,22 +1,9 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::AccountStoreMapping, :vcr do
-
-  def create_account_store_mapping(application, account_store, options={})
-    test_api_client.account_store_mappings.create({
-      application: application,
-      account_store: account_store,
-      list_index: options[:list_index] || 0,
-      is_default_account_store: options[:is_default_account_store] || false,
-      is_default_group_store: options[:is_default_group_store] || false
-     })
-  end
-
-  let(:directory_name) { random_directory_name }
-
-  let(:directory) { test_api_client.directories.create name: directory_name, description: 'testDirectory for AccountStoreMappings' }
-
-  let(:application) { test_api_client.applications.create name: random_application_name, description: 'testApplication for AccountStoreMappings' }
+  let(:directory_name) { 'rubysdktestdir' }
+  let(:directory) { test_api_client.directories.create(build_directory(name: directory_name)) }
+  let(:application) { test_api_client.applications.create(build_application) }
 
   after do
     application.delete if application
@@ -24,7 +11,9 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   end
 
   describe "instances" do
-    let(:account_store_mapping) {create_account_store_mapping(application,directory, is_default_account_store: true)}
+    let!(:account_store_mapping) do
+      map_account_store(application, directory, 0, true, false)
+    end
 
     it do
       [:list_index, :is_default_account_store, :is_default_group_store, :default_account_store, :default_group_store ].each do |prop_accessor|
@@ -51,7 +40,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
 
 
   describe 'given an application' do
-    let(:reloaded_application) { test_api_client.applications.get application.href}
+    let(:reloaded_application) { test_api_client.applications.get application.href }
 
     context 'on application creation' do
       it 'there should be no default account/group store' do
@@ -61,33 +50,33 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
     end
 
     it 'should retrive a default account store mapping one is created' do
-      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true, is_default_group_store: true)
+      account_store_mapping = map_account_store(application, directory, 0, true, true)
       expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
     end
 
     it 'should retrive a default group store mapping when one is created' do
-      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true, is_default_group_store: true)
+      account_store_mapping = map_account_store(application, directory, 0, true, true)
       expect(reloaded_application.default_group_store_mapping).to eq(account_store_mapping)
     end
 
     it 'change the default account store mapping, the application needs to be reloaded' do
-      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true)
+      account_store_mapping = map_account_store(application, directory, 0, true, false)
       expect(application.default_account_store_mapping).to eq(nil)
       expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
     end
 
     it 'change the default group store mapping, the application needs to be reloaded' do
-      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true, is_default_group_store: true)
+      account_store_mapping = map_account_store(application, directory, 0, true, true)
       expect(application.default_group_store_mapping).to eq(nil)
       expect(reloaded_application.default_group_store_mapping).to eq(account_store_mapping)
     end
 
     context 'remove the added default account/group store mapping' do
-      let(:re_reloaded_application) { test_api_client.applications.get application.href}
+      let(:re_reloaded_application) { test_api_client.applications.get application.href }
 
       it 'there should not be a default account store mapping in the beginning and the end' do
         expect(application.default_account_store_mapping).to eq(nil)
-        account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true)
+        account_store_mapping = map_account_store(application, directory, 0, true, false)
 
         expect(application.default_account_store_mapping).to eq(nil)
         expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
@@ -102,7 +91,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
 
       it 'there should not be a default group store mapping in the beginning and the end' do
         expect(application.default_account_store_mapping).to eq(nil)
-        account_store_mapping = create_account_store_mapping(application,directory, is_default_group_store: true)
+        account_store_mapping = map_account_store(application, directory, 0, false, true)
 
         expect(application.default_group_store_mapping).to eq(nil)
         expect(reloaded_application.default_group_store_mapping).to eq(account_store_mapping)
@@ -119,7 +108,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   end
 
   describe "given a directory" do
-    before { create_account_store_mapping(application, directory) }
+    before { map_account_store(application, directory, 0, false, false) }
 
     it 'add an account store mapping' do
       expect(application.account_store_mappings.count).to eq(1)
@@ -127,7 +116,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   end
 
   describe "given a group" do
-    let(:group) { directory.groups.create name: 'testGroup', description: 'testGroup for AccountStoreMappings' }
+    let(:group) { directory.groups.create(build_group) }
     let(:reloaded_application) { test_api_client.applications.get application.href }
 
     after do
@@ -136,7 +125,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
 
     context 'add an account store mapping' do
       it 'being a default account store' do
-        account_store_mapping = create_account_store_mapping(application, group, is_default_account_store: true)
+        account_store_mapping = map_account_store(application, group, 0, true, false)
         expect(application.default_account_store_mapping).to eq(nil)
         expect(application.account_store_mappings.count).to eq(1)
         expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
@@ -144,7 +133,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
 
       it 'being a default group store, should raise an error' do
         expect do
-          create_account_store_mapping(application, group, is_default_group_store: true)
+          map_account_store(application, group, 0, false, true)
         end.to raise_error Stormpath::Error
       end
 
@@ -153,7 +142,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   end
 
   describe "update attribute default_group_store" do
-    let(:account_store_mapping) { create_account_store_mapping(application, directory, is_default_account_store: true) }
+    let(:account_store_mapping) { map_account_store(application, directory, 0, true, false) }
     let(:reloaded_mapping){ application.account_store_mappings.get account_store_mapping.href }
 
     it 'should go from true to false' do
@@ -165,7 +154,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   end
 
   describe "given a mapping" do
-    let!(:account_store_mapping) { create_account_store_mapping(application, directory, is_default_account_store: true) }
+    let!(:account_store_mapping) { map_account_store(application, directory, 0, true, false) }
     let(:reloaded_application) { test_api_client.applications.get application.href}
 
     it 'function delete should destroy it' do
@@ -183,5 +172,4 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
       end
     end
   end
-
 end

data/spec/resource/account_store_spec.rb

@@ -1,33 +1,10 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::AccountStore, :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
-
-  let(:application) do
-    test_api_client.applications.create name: random_application_name,
-                                        description: 'testApplication for AccountStoreMappings'
-  end
-
-  let(:directory) do
-    test_api_client.directories.create name: random_directory_name,
-                                       description: 'testDirectory for AccountStoreMappings'
-  end
-
-  let(:group) do
-    directory.groups.create name: 'testGroup', description: 'testGroup for AccountStoreMappings'
-  end
-
-  let(:organization) do
-    test_api_client.organizations.create name: 'testOrganization', name_key: 'test-organization'
-  end
+  let(:application) { test_api_client.applications.create(build_application) }
+  let(:directory) { test_api_client.directories.create(build_directory) }
+  let(:group) { directory.groups.create(build_group) }
+  let(:organization) { test_api_client.organizations.create(build_organization) }
 
   after do
     application.delete if application
@@ -37,7 +14,7 @@ describe Stormpath::Resource::AccountStore, :vcr do
   end
 
   describe 'given an account_store_mapping and a directory' do
-    let!(:account_store_mapping) { create_account_store_mapping(application, directory, true) }
+    let!(:account_store_mapping) { map_account_store(application, directory, 0, true, true) }
     let(:reloaded_mapping) { application.account_store_mappings.get account_store_mapping.href }
 
     it 'should return a directory' do
@@ -47,7 +24,7 @@ describe Stormpath::Resource::AccountStore, :vcr do
   end
 
   describe 'given an account_store_mapping and a group' do
-    let!(:account_store_mapping) { create_account_store_mapping(application, group) }
+    let!(:account_store_mapping) { map_account_store(application, group, 0, true, false) }
     let(:reloaded_mapping) { application.account_store_mappings.get account_store_mapping.href }
 
     it 'should return a group' do
@@ -57,7 +34,7 @@ describe Stormpath::Resource::AccountStore, :vcr do
   end
 
   describe 'given an account_store_mapping and an organization' do
-    let!(:account_store_mapping) { create_account_store_mapping(application, organization) }
+    let!(:account_store_mapping) { map_account_store(application, organization, 0, true, false) }
     let(:reloaded_mapping) { application.account_store_mappings.get account_store_mapping.href }
 
     it 'should return an organization' do
@@ -69,7 +46,7 @@ describe Stormpath::Resource::AccountStore, :vcr do
   describe 'given an undefined account_store_mapping' do
     it 'should raise an error' do
       expect do
-        create_account_store_mapping(application, 'undefined')
+        map_account_store(application, 'undefined', 0, true, false)
       end.to raise_error
     end
   end

data/spec/resource/api_key_spec.rb

@@ -1,23 +1,20 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::ApiKey, :vcr do
-  let(:application) { test_application }
+  let(:application) { test_api_client.applications.create(build_application) }
+  let(:directory) { test_api_client.directories.create(build_directory) }
   let(:tenant) { application.tenant }
-
-  let(:account) do
-    application.accounts.create(
-      email: 'test@example.com',
-      given_name: 'Ruby SDK',
-      password: 'P@$$w0rd',
-      surname: 'SDK'
-    )
-  end
-
+  let(:account) { application.accounts.create(build_account) }
   let(:api_key) { account.api_keys.create({}) }
+  before { map_account_store(application, directory, 1, true, false) }
 
-  after { account.delete }
+  after do
+    application.delete
+    directory.delete
+    account.delete
+  end
 
-  describe "instances should respond to attribute property methods" do
+  describe 'instances should respond to attribute property methods' do
     it do
       [:name, :description, :status].each do |property_accessor|
         expect(api_key).to respond_to(property_accessor)
@@ -26,7 +23,7 @@ describe Stormpath::Resource::ApiKey, :vcr do
 
       [:id, :secret].each do |property_getter|
         expect(api_key).to respond_to(property_getter)
-        expect(api_key.send property_getter).to be_a String
+        expect(api_key.send(property_getter)).to be_a String
       end
 
       expect(api_key.tenant).to be_a Stormpath::Resource::Tenant

data/spec/resource/application_spec.rb

@@ -2,14 +2,12 @@ require 'spec_helper'
 include UUIDTools
 
 describe Stormpath::Resource::Application, :vcr do
-  let(:app) { test_api_client.applications.create name: random_application_name, description: 'Dummy desc.' }
+  let(:app) { test_api_client.applications.create(build_application) }
   let(:application) { test_api_client.applications.get app.href }
-  let(:directory) { test_api_client.directories.create name: random_directory_name }
-  let(:directory_with_verification) { test_directory_with_verification }
+  let(:directory) { test_api_client.directories.create(build_directory) }
 
   before do
-   test_api_client.account_store_mappings.create({ application: app, account_store: directory,
-      list_index: 1, is_default_account_store: true, is_default_group_store: true })
+    map_account_store(app, directory, 1, true, true)
   end
 
   after do
@@ -69,7 +67,7 @@ describe Stormpath::Resource::Application, :vcr do
   describe 'application_associations' do
 
     context '#accounts' do
-      let(:account) { application.accounts.create build_account}
+      let(:account) { application.accounts.create(build_account) }
 
       after do
         account.delete if account
@@ -86,11 +84,9 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context '#groups' do
-      let(:group) { application.groups.create name: random_group_name }
+      let(:group) { application.groups.create(build_group) }
 
-      after do
-        group.delete if group
-      end
+      after { group.delete }
 
       it 'should be able to create a group' do
         expect(application.groups).to include(group)
@@ -118,15 +114,7 @@ describe Stormpath::Resource::Application, :vcr do
 
 
   describe '#create_account' do
-    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(:account) { Stormpath::Resource::Account.new(build_account) }
 
     context 'with registration workflow' do
       it 'creates an account with worflow enabled' do
@@ -209,10 +197,8 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'given a wrong directory' do
-      let(:new_directory) { test_api_client.directories.create name: random_directory_name('new') }
-
+      let(:new_directory) { test_api_client.directories.create(build_directory) }
       let(:account) { new_directory.accounts.create build_account(password: 'P@$$w0rd') }
-
       let(:login_request) do
         Stormpath::Authentication::UsernamePasswordRequest.new account.username, password, account_store: directory
       end
@@ -227,7 +213,7 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'given a group' do
-      let(:group) {directory.groups.create name: random_group_name }
+      let(:group) {directory.groups.create(build_group) }
 
       let(:account) { directory.accounts.create build_account(password: 'P@$$w0rd') }
 
@@ -236,7 +222,7 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       before do
-        test_api_client.account_store_mappings.create({ application: application, account_store: group })
+        map_account_store(application, group, 0, true, false)
       end
 
       after do
@@ -276,12 +262,7 @@ describe Stormpath::Resource::Application, :vcr do
 
       context 'of an existing account not mapped to the application' do
         let(:account) { other_directory.accounts.create build_account  }
-
-        let(:other_directory) do
-          test_api_client.directories.create(
-            name: random_directory_name('password_reset_account_store_href')
-          )
-        end
+        let(:other_directory) { test_api_client.directories.create(build_directory) }
 
         after do
           account.delete
@@ -337,13 +318,7 @@ describe Stormpath::Resource::Application, :vcr do
 
       context 'of an existing account not mapped to the application with an account store href' do
         let(:account) { directory.accounts.create build_account  }
-
-        let(:other_directory) do
-          test_api_client.directories.create(
-            name: random_directory_name('password_reset_account_store_href'),
-            description: 'abc'
-          )
-        end
+        let(:other_directory) { test_api_client.directories.create(build_directory) }
 
         after do
           account.delete
@@ -373,22 +348,17 @@ describe Stormpath::Resource::Application, :vcr do
 
       context 'of an existing account on the application with a right account store organization namekey' do
         let(:account) { account_directory.accounts.create build_account  }
-
-        let(:account_directory) do
-          test_api_client.directories.create(
-            name: random_directory_name('password_reset_account_store_href')
-          )
-        end
+        let(:account_directory) { test_api_client.directories.create(build_directory) }
 
         let(:reloaded_account_directory) do
           test_api_client.directories.get(account_directory.href)
         end
 
-        let(:organization_name_key) { "#{random_string}-org-name-key" }
+        let(:organization_name_key) { 'ruby-test-org-name-key' }
 
         let(:organization) do
           test_api_client.organizations.create(
-            name: "#{random_string}_organization_name",
+            name: "ruby_test_organization_name",
             name_key: organization_name_key
           )
         end
@@ -404,12 +374,8 @@ describe Stormpath::Resource::Application, :vcr do
         end
 
         before do
-          test_api_client.organization_account_store_mappings.create(
-            account_store: { href: account_directory.href },
-            organization: { href: organization.href }
-          )
-
-          test_api_client.account_store_mappings.create(application: application, account_store: organization)
+          map_organization_store(account_directory, organization)
+          map_account_store(application, organization, 0, true, true)
         end
 
         it 'sends a password reset request of the account' do
@@ -421,26 +387,11 @@ describe Stormpath::Resource::Application, :vcr do
 
       context 'of an existing account on the application with a right account store organization resource object' do
         let(:account) { account_directory.accounts.create build_account  }
-
-        let(:account_directory) do
-          test_api_client.directories.create(
-            name: random_directory_name('password_reset_account_store_href')
-          )
-        end
-
+        let(:account_directory) { test_api_client.directories.create(build_directory) }
         let(:reloaded_account_directory) do
           test_api_client.directories.get(account_directory.href)
         end
-
-        let(:organization_name_key) { "#{random_string}-org-name-key" }
-
-        let(:organization) do
-          test_api_client.organizations.create(
-            name: "#{random_string}_organization_name",
-            name_key: organization_name_key
-          )
-        end
-
+        let(:organization) { test_api_client.organizations.create(build_organization) }
         let(:sent_to_account) do
           application.send_password_reset_email(account.email, account_store: organization)
         end
@@ -452,12 +403,8 @@ describe Stormpath::Resource::Application, :vcr do
         end
 
         before do
-          test_api_client.organization_account_store_mappings.create(
-            account_store: { href: account_directory.href },
-            organization: { href: organization.href }
-          )
-
-          test_api_client.account_store_mappings.create(application: application, account_store: organization)
+          map_organization_store(account_directory, organization)
+          map_account_store(application, organization, 0, true, true)
         end
 
         it 'sends a password reset request of the account' do
@@ -469,34 +416,12 @@ describe Stormpath::Resource::Application, :vcr do
 
       context 'of an existing account on the application with a wrong account store organization namekey' do
         let(:account) { account_directory.accounts.create build_account  }
-
-        let(:account_directory) do
-          test_api_client.directories.create(
-            name: random_directory_name('password_reset_account_store_href')
-          )
-        end
-
+        let(:account_directory) { test_api_client.directories.create(build_directory) }
         let(:reloaded_account_directory) do
           test_api_client.directories.get(account_directory.href)
         end
-
-        let(:organization_name_key) { "#{random_string}-org-name-key" }
-
-        let(:other_organization_name_key) { "#{random_string}-other-org-name-key" }
-
-        let(:organization) do
-          test_api_client.organizations.create(
-            name: "#{random_string}_organization_name",
-            name_key: organization_name_key
-          )
-        end
-
-        let(:other_organization) do
-          test_api_client.organizations.create(
-            name: "#{random_string}_other_organization_name",
-            name_key: other_organization_name_key
-          )
-        end
+        let(:organization) { test_api_client.organizations.create(build_organization) }
+        let(:other_organization) { test_api_client.organizations.create(build_organization) }
 
         after do
           account.delete
@@ -506,12 +431,8 @@ describe Stormpath::Resource::Application, :vcr do
         end
 
         before do
-          test_api_client.organization_account_store_mappings.create(
-            account_store: { href: account_directory.href },
-            organization: { href: organization.href }
-          )
-
-          test_api_client.account_store_mappings.create(application: application, account_store: organization)
+          map_organization_store(account_directory, organization)
+          map_account_store(application, organization, 0, true, true)
         end
 
         it 'sends a password reset request of the account' do
@@ -524,29 +445,21 @@ describe Stormpath::Resource::Application, :vcr do
   end
 
   describe '#verification_emails' do
-    let(:directory_with_verification) { test_directory_with_verification }
+    let(:directory_with_verification) { test_api_client.directories.create(build_directory) }
 
     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
-
-    let(:account) do
-      directory_with_verification.accounts.create({
-        email: random_email,
-        given_name: 'Ruby SDK',
-        password: 'P@$$w0rd',
-        surname: 'SDK',
-        username: random_user_name
-      })
+      map_account_store(application, directory_with_verification, 1, false, false)
+      enable_email_verification(directory_with_verification)
     end
 
+    let(:account) { directory_with_verification.accounts.create(build_account) }
     let(:verification_emails) do
       application.verification_emails.create(login: account.email)
     end
 
     after do
       account.delete if account
+      directory_with_verification.delete
     end
 
     it 'returns verification email' do
@@ -555,15 +468,7 @@ describe Stormpath::Resource::Application, :vcr do
   end
 
   describe 'create_login_attempt' do
-    let(:account) do
-      directory.accounts.create({
-        email: random_email,
-        given_name: 'Ruby SDK',
-        password: 'P@$$w0rd',
-        surname: 'SDK',
-        username: random_user_name
-      })
-    end
+    let(:account) { directory.accounts.create(build_account) }
 
     context 'valid credentials' do
       let(:username_password_request) do
@@ -585,30 +490,16 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'with organization as account store option' do
-      def create_organization_account_store_mapping(organization, account_store)
-        test_api_client.organization_account_store_mappings.create({
-          account_store: { href: account_store.href },
-          organization: { href: organization.href }
-        })
-      end
-
-      def create_application_account_store_mapping(application, account_store)
-        test_api_client.account_store_mappings.create(
-          application: application,
-          account_store: account_store
-        )
-      end
-
       let(:organization) do
-        test_api_client.organizations.create name: 'test_organization',
-           name_key: "testorganization"
+        test_api_client.organizations.create(name: 'test_organization',
+                                             name_key: 'testorganization')
       end
 
       let(:auth_request) { application.authenticate_account(username_password_request) }
 
       before do
-        create_organization_account_store_mapping(organization, directory)
-        create_application_account_store_mapping(application, organization)
+        map_organization_store(directory, organization)
+        map_account_store(application, organization, 0, true, false)
       end
 
       after do
@@ -739,20 +630,10 @@ describe Stormpath::Resource::Application, :vcr do
   end
 
   describe '#verify_password_reset_token' do
-    let(:account) do
-      directory.accounts.create({
-        email: random_email,
-        given_name: 'Ruby SDK',
-        password: 'P@$$w0rd',
-        surname: 'SDK',
-        username: random_user_name
-      })
-    end
-
+    let(:account) { directory.accounts.create(build_account) }
     let(:password_reset_token) do
       application.password_reset_tokens.create(email: account.email).token
     end
-
     let(:reset_password_account) do
       application.verify_password_reset_token password_reset_token
     end
@@ -785,8 +666,6 @@ describe Stormpath::Resource::Application, :vcr do
         Stormpath::Authentication::UsernamePasswordRequest.new account.username, new_password
       end
 
-      let(:expected_email) { 'test2@example.com' }
-
       let(:authentication_result) do
         application.authenticate_account login_request
       end
@@ -1095,16 +974,8 @@ describe Stormpath::Resource::Application, :vcr do
         end
 
         before do
-          test_api_client.account_store_mappings.create(
-            application: application,
-            account_store: organization
-          )
-
-          test_api_client.organization_account_store_mappings.create(
-            account_store: { href: account_directory.href },
-            organization: { href: organization.href }
-          )
-
+          map_account_store(application, organization, 0, true, true)
+          map_organization_store(account_directory, organization)
           account_directory.accounts.create account_data
         end