stormpath-sdk 1.6.0 → 1.7.0

data/spec/oauth/access_token_authentication_result_spec.rb

@@ -31,7 +31,10 @@ describe Stormpath::Oauth::AccessTokenAuthenticationResult, :vcr do
 
     expect(account.access_tokens.count).to eq(1)
 
-    jti = JWT.decode(jwt_authentication_result.access_token, test_api_client.data_store.api_key.secret).first['jti']
+    jti = JWT.decode(
+      jwt_authentication_result.access_token,
+      test_api_client.data_store.api_key.secret
+    ).first['jti']
 
     fetched_access_token = test_api_client.access_tokens.get(jti)
 
@@ -49,7 +52,10 @@ describe Stormpath::Oauth::AccessTokenAuthenticationResult, :vcr do
 
     expect(account.refresh_tokens.count).to eq(1)
 
-    jti = JWT.decode(jwt_authentication_result.refresh_token, test_api_client.data_store.api_key.secret).first['jti']
+    jti = JWT.decode(
+      jwt_authentication_result.refresh_token,
+      test_api_client.data_store.api_key.secret
+    ).first['jti']
 
     fetched_refresh_token = test_api_client.refresh_tokens.get(jti)
 

data/spec/provider/account_resolver_spec.rb

@@ -30,10 +30,12 @@ describe 'ProviderAccountResolver' do
 
       context 'with account store as a parameter' do
         let(:account_request) do
-          Stormpath::Provider::AccountRequest.new(:facebook,
-                                                  :access_token,
-                                                  'some-token',
-                                                  account_store: { name_key: 'app1' })
+          Stormpath::Provider::AccountRequest.new(
+            :facebook,
+            :access_token,
+            'some-token',
+            account_store: { name_key: 'app1' }
+          )
         end
 
         it 'a ProviderResult is returned' do

data/spec/provider/provider_spec.rb

@@ -121,7 +121,7 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create stormpath directory with empty provider credentials' do
-    let(:name) { 'Stormpath' }
+    let(:name) { "ruby-sdk-stormpath-#{random_number}" }
     let(:description) { 'Directory for testing Stormpath directories.' }
     let(:provider_id) { 'stormpath' }
 
@@ -139,7 +139,7 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create facebook directory with provider credentials' do
-    let(:name) { 'Facebook' }
+    let(:name) { "ruby-sdk-facebook-#{random_number}" }
     let(:description) { 'Directory for testing Facebook directories.' }
 
     let(:provider_id) { 'facebook' }
@@ -154,7 +154,7 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create google directory with provider credentials' do
-    let(:name) { 'Google' }
+    let(:name) { "ruby-sdk-google-#{random_number}" }
     let(:description) { 'Directory for testing Google directories.' }
 
     let(:provider_id) { 'google' }
@@ -181,7 +181,7 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create linkedin directory with provider credentials' do
-    let(:name) { 'Linkedin' }
+    let(:name) { "ruby-sdk-linkedin-#{random_number}" }
     let(:description) { 'Directory for testing Linkedin directories.' }
 
     let(:provider_id) { 'linkedin' }
@@ -196,7 +196,7 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create github directory with provider credentials' do
-    let(:name) { 'Github' }
+    let(:name) { "ruby-sdk-github-#{random_number}" }
     let(:description) { 'Directory for testing Github directories.' }
 
     let(:provider_id) { 'github' }
@@ -211,7 +211,7 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create twitter directory with provider credentials' do
-    let(:name) { 'Twitter' }
+    let(:name) { "ruby-sdk-twitter-#{random_number}" }
     let(:description) { 'Directory for testing Twitter directories.' }
 
     let(:provider_id) { 'twitter' }

data/spec/resource/account_creation_policy_spec.rb

@@ -99,7 +99,7 @@ describe Stormpath::Resource::AccountCreationPolicy, :vcr do
 
     context 'when domain not string' do
       it 'should raise error' do
-        blacklisted = ['*spam.com', 12345]
+        blacklisted = ['*spam.com', 12_345]
         account_creation_policy.email_domain_blacklist = blacklisted
         expect do
           account_creation_policy.save

data/spec/resource/account_link_spec.rb

@@ -1,27 +1,19 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::AccountLink, :vcr do
-  let(:application) do
-    test_api_client.applications.create(name: 'ruby sdk app', description: 'ruby sdk desc')
-  end
-  let(:directory1) do
-    test_api_client.directories.create(name: 'ruby sdk dir 1')
-  end
-  let(:directory2) do
-    test_api_client.directories.create(name: 'ruby sdk dir 2')
-  end
+  let(:application) { test_api_client.applications.create(application_attrs) }
+  let(:directory1) { test_api_client.directories.create(directory_attrs) }
+  let(:directory2) { test_api_client.directories.create(directory_attrs) }
+  let(:username1) { "jekyll-#{random_number}" }
+  let(:username2) { "hyde-#{random_number}" }
 
   before do
     map_account_store(application, directory1, 1, true, false)
     map_account_store(application, directory2, 2, false, false)
   end
 
-  let!(:account1) do
-    directory1.accounts.create(account_attrs(email: 'jekyll', username: 'jekyll'))
-  end
-  let!(:account2) do
-    directory2.accounts.create(account_attrs(email: 'hyde', username: 'hyde'))
-  end
+  let!(:account1) { directory1.accounts.create(account_attrs(email: username1, username: username1)) }
+  let!(:account2) { directory2.accounts.create(account_attrs(email: username2, username: username2)) }
 
   let!(:account_link) do
     test_api_client.account_links.create(

data/spec/resource/account_spec.rb

@@ -4,10 +4,14 @@ describe Stormpath::Resource::Account, :vcr do
   describe 'instances should respond to attribute property methods' do
     let(:directory) { test_api_client.directories.create(directory_attrs) }
     let(:account) do
-      directory.accounts.create(account_attrs(email: 'ruby',
-                                              given_name: 'ruby',
-                                              surname: 'ruby',
-                                              middle_name: 'ruby'))
+      directory.accounts.create(
+        account_attrs(
+          email: 'ruby',
+          given_name: 'ruby',
+          surname: 'ruby',
+          middle_name: 'ruby'
+        )
+      )
     end
 
     after do
@@ -120,9 +124,7 @@ describe Stormpath::Resource::Account, :vcr do
 
       it 'adds and removes the group from the account' do
         expect(account.groups).to include(group)
-
         account.remove_group group
-
         expect(account.groups).not_to include(group)
       end
     end
@@ -237,11 +239,13 @@ describe Stormpath::Resource::Account, :vcr do
       end
 
       let(:factor) do
-        account.create_factor(:sms,
-                              phone: { number: '+12025550173',
-                                       name: 'Rspec test phone',
-                                       description: 'This is a testing phone number' },
-                              challenge: { message: 'Enter code please: ' })
+        account.create_factor(
+          :sms,
+          phone: { number: '+12025550173',
+                   name: 'Rspec test phone',
+                   description: 'This is a testing phone number' },
+          challenge: { message: 'Enter code please: ' }
+        )
       end
 
       it 'factor should be created' do
@@ -250,9 +254,7 @@ describe Stormpath::Resource::Account, :vcr do
     end
 
     context 'type google-authenticator' do
-      let(:factor) do
-        account.create_factor(:google_authenticator, options)
-      end
+      let(:factor) { account.create_factor(:google_authenticator, options) }
 
       context 'with account_name' do
         let(:account_name) { "marko.cilimkovic#{default_domain}" }
@@ -295,9 +297,7 @@ describe Stormpath::Resource::Account, :vcr do
     end
 
     context 'with bad type set' do
-      let(:factor) do
-        account.create_factor(:invalid_type)
-      end
+      let(:factor) { account.create_factor(:invalid_type) }
 
       it 'should raise error' do
         expect { factor }.to raise_error(Stormpath::Error)

data/spec/resource/account_store_mapping_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::AccountStoreMapping, :vcr do
-  let(:directory_name) { 'rubysdktestdir' }
+  let(:directory_name) { "rubysdktestdir-#{random_number}" }
   let(:directory) { test_api_client.directories.create(directory_attrs(name: directory_name)) }
   let(:application) { test_api_client.applications.create(application_attrs) }
 
@@ -10,13 +10,13 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
     directory.delete if directory
   end
 
-  describe "instances" do
+  describe 'instances' do
     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|
+      [:list_index, :is_default_account_store, :is_default_group_store, :default_account_store, :default_group_store].each do |prop_accessor|
         expect(account_store_mapping).to respond_to(prop_accessor)
         expect(account_store_mapping).to respond_to("#{prop_accessor}=")
       end
@@ -25,11 +25,11 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
         expect(account_store_mapping).to respond_to(prop_getter)
       end
 
-      expect(account_store_mapping.list_index).to be_a Fixnum
+      expect(account_store_mapping.list_index).to be_a Integer
 
       [:default_account_store, :default_group_store].each do |default_store_method|
         [default_store_method, "is_#{default_store_method}", "#{default_store_method}?"].each do |specific_store_method|
-          expect(account_store_mapping.send specific_store_method).to be_boolean
+          expect(account_store_mapping.send(specific_store_method)).to be_boolean
         end
       end
 
@@ -38,9 +38,8 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
     end
   end
 
-
   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
@@ -72,7 +71,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
     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)
@@ -104,10 +103,9 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
         expect(re_reloaded_application.default_group_store_mapping).to eq(nil)
       end
     end
-
   end
 
-  describe "given a directory" do
+  describe 'given a directory' do
     before { map_account_store(application, directory, 0, false, false) }
 
     it 'add an account store mapping' do
@@ -115,13 +113,11 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
     end
   end
 
-  describe "given a group" do
+  describe 'given a group' do
     let(:group) { directory.groups.create(group_attrs) }
-    let(:reloaded_application) { test_api_client.applications.get application.href }
+    let(:reloaded_application) { test_api_client.applications.get(application.href) }
 
-    after do
-      group.delete if group
-    end
+    after { group.delete if group }
 
     context 'add an account store mapping' do
       it 'being a default account store' do
@@ -136,26 +132,24 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
           map_account_store(application, group, 0, false, true)
         end.to raise_error Stormpath::Error
       end
-
     end
-
   end
 
-  describe "update attribute default_group_store" do
+  describe 'update attribute default_group_store' do
     let(:account_store_mapping) { map_account_store(application, directory, 0, true, false) }
-    let(:reloaded_mapping){ application.account_store_mappings.get account_store_mapping.href }
+    let(:reloaded_mapping) { application.account_store_mappings.get(account_store_mapping.href) }
 
     it 'should go from true to false' do
       expect(account_store_mapping.is_default_account_store).to eq(true)
-      account_store_mapping.default_account_store= false
+      account_store_mapping.default_account_store = false
       account_store_mapping.save
       expect(reloaded_mapping.is_default_account_store).to eq(false)
     end
   end
 
-  describe "given a mapping" do
+  describe 'given a mapping' do
     let!(:account_store_mapping) { map_account_store(application, directory, 0, true, false) }
-    let(:reloaded_application) { test_api_client.applications.get application.href}
+    let(:reloaded_application) { test_api_client.applications.get(application.href) }
 
     it 'function delete should destroy it' do
       expect(application.account_store_mappings.count).to eq(1)

data/spec/resource/account_store_spec.rb

@@ -15,7 +15,7 @@ describe Stormpath::Resource::AccountStore, :vcr do
 
   describe 'given an account_store_mapping and a directory' do
     let!(:account_store_mapping) { map_account_store(application, directory, 0, true, true) }
-    let(:reloaded_mapping) { application.account_store_mappings.get account_store_mapping.href }
+    let(:reloaded_mapping) { application.account_store_mappings.get(account_store_mapping.href) }
 
     it 'should return a directory' do
       expect(reloaded_mapping.account_store.class).to eq(Stormpath::Resource::Directory)
@@ -25,7 +25,7 @@ describe Stormpath::Resource::AccountStore, :vcr do
 
   describe 'given an account_store_mapping and a group' do
     let!(:account_store_mapping) { map_account_store(application, group, 0, true, false) }
-    let(:reloaded_mapping) { application.account_store_mappings.get account_store_mapping.href }
+    let(:reloaded_mapping) { application.account_store_mappings.get(account_store_mapping.href) }
 
     it 'should return a group' do
       expect(reloaded_mapping.account_store.class).to eq(Stormpath::Resource::Group)
@@ -35,7 +35,7 @@ describe Stormpath::Resource::AccountStore, :vcr do
 
   describe 'given an account_store_mapping and an organization' do
     let!(:account_store_mapping) { map_account_store(application, organization, 0, true, false) }
-    let(:reloaded_mapping) { application.account_store_mappings.get account_store_mapping.href }
+    let(:reloaded_mapping) { application.account_store_mappings.get(account_store_mapping.href) }
 
     it 'should return an organization' do
       expect(reloaded_mapping.account_store.class).to eq(Stormpath::Resource::Organization)

data/spec/resource/application_spec.rb

@@ -3,12 +3,10 @@ include UUIDTools
 
 describe Stormpath::Resource::Application, :vcr do
   let(:app) { test_api_client.applications.create(application_attrs) }
-  let(:application) { test_api_client.applications.get app.href }
+  let(:application) { test_api_client.applications.get(app.href) }
   let(:directory) { test_api_client.directories.create(directory_attrs) }
 
-  before do
-    map_account_store(app, directory, 1, true, true)
-  end
+  before { map_account_store(app, directory, 1, true, true) }
 
   after do
     application.delete if application
@@ -16,24 +14,23 @@ describe Stormpath::Resource::Application, :vcr do
   end
 
   it 'instances should respond to attribute property methods' do
-
     expect(application).to be_a Stormpath::Resource::Application
 
     [:name, :description, :status].each do |property_accessor|
       expect(application).to respond_to(property_accessor)
       expect(application).to respond_to("#{property_accessor}=")
-      expect(application.send property_accessor).to be_a String
+      expect(application.send(property_accessor)).to be_a String
     end
 
     [:authorized_callback_uris, :authorized_origin_uris].each do |property_accessor|
       expect(application).to respond_to(property_accessor)
       expect(application).to respond_to("#{property_accessor}=")
-      expect(application.send property_accessor).to be_a Array
+      expect(application.send(property_accessor)).to be_a Array
     end
 
     [:created_at, :modified_at].each do |property_getter|
       expect(application).to respond_to(property_getter)
-      expect(application.send property_getter).to be_a String
+      expect(application.send(property_getter)).to be_a String
     end
 
     expect(application.tenant).to be_a Stormpath::Resource::Tenant
@@ -47,6 +44,7 @@ describe Stormpath::Resource::Application, :vcr do
     expect(application.verification_emails).to be_a Stormpath::Resource::Collection
     expect(application.account_store_mappings).to be_a Stormpath::Resource::Collection
     expect(application.account_linking_policy).to be_a Stormpath::Resource::AccountLinkingPolicy
+    expect(application.saml_policy).to be_a Stormpath::Resource::SamlPolicy
   end
 
   describe '.load' do
@@ -72,13 +70,10 @@ describe Stormpath::Resource::Application, :vcr do
   end
 
   describe 'application_associations' do
-
     context '#accounts' do
       let(:account) { application.accounts.create(account_attrs) }
 
-      after do
-        account.delete if account
-      end
+      after { account.delete if account }
 
       it 'should be able to create an account' do
         expect(application.accounts).to include(account)
@@ -86,7 +81,7 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       it 'should be able to create and fetch the account' do
-        expect(application.accounts.get account.href).to be
+        expect(application.accounts.get(account.href)).to be
       end
     end
 
@@ -101,12 +96,13 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       it 'should be able to create and fetch a group' do
-        expect(application.groups.get group.href).to be
+        expect(application.groups.get(group.href)).to be
       end
     end
 
     context '#web_config' do
       let(:web_config) { application.web_config }
+      let(:dns_label) { "ruby-dns-label-#{random_number}" }
 
       it 'should have web_config' do
         expect(application.web_config).to be_a Stormpath::Resource::ApplicationWebConfig
@@ -123,15 +119,15 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       it 'changing dns_label should affect domain_name' do
-        web_config.dns_label = 'stormtrooper'
+        web_config.dns_label = dns_label
         web_config.save
-        expect(application.web_config.domain_name).to eq 'stormtrooper.apps.stormpath.io'
+        expect(application.web_config.domain_name).to eq "#{dns_label}.apps.stormpath.io"
       end
     end
   end
 
   describe 'edit authorized_callback_uris' do
-    let(:authorized_callback_uris) { ["https://myapplication.com/whatever/callback", "https://myapplication.com/whatever/callback2"] }
+    let(:authorized_callback_uris) { ['https://myapplication.com/whatever/callback', 'https://myapplication.com/whatever/callback2'] }
 
     it 'changes authorized callback uris on application' do
       application.authorized_callback_uris = authorized_callback_uris
@@ -178,24 +174,17 @@ describe Stormpath::Resource::Application, :vcr do
   end
 
   describe '#authenticate_account' do
-    let(:account) do
-      directory.accounts.create account_attrs(password: 'P@$$w0rd')
-    end
-
+    let(:account) { directory.accounts.create(account_attrs(password: 'P@$$w0rd')) }
     let(:login_request) do
-      Stormpath::Authentication::UsernamePasswordRequest.new account.username, password
+      Stormpath::Authentication::UsernamePasswordRequest.new(account.username, password)
     end
 
-    let(:authentication_result) do
-      application.authenticate_account login_request
-    end
+    let(:authentication_result) { application.authenticate_account login_request }
 
-    after do
-      account.delete if account
-    end
+    after { account.delete if account }
 
     context 'given a valid username and password' do
-      let(:password) {'P@$$w0rd' }
+      let(:password) { 'P@$$w0rd' }
 
       it 'returns an authentication result' do
         expect(authentication_result).to be
@@ -215,19 +204,20 @@ describe Stormpath::Resource::Application, :vcr do
   end
 
   describe '#authenticate_account_with_an_account_store_specified' do
-    let(:password) {'P@$$w0rd' }
-
+    let(:password) { 'P@$$w0rd' }
     let(:authentication_result) { application.authenticate_account login_request }
 
-    after do
-      account.delete if account
-    end
+    after { account.delete if account }
 
     context 'given a proper directory' do
-      let(:account) { directory.accounts.create account_attrs(password: 'P@$$w0rd') }
+      let(:account) { directory.accounts.create(account_attrs(password: 'P@$$w0rd')) }
 
       let(:login_request) do
-        Stormpath::Authentication::UsernamePasswordRequest.new account.username, password, account_store: directory
+        Stormpath::Authentication::UsernamePasswordRequest.new(
+          account.username,
+          password,
+          account_store: directory
+        )
       end
 
       it 'should return an authentication result' do
@@ -240,14 +230,16 @@ describe Stormpath::Resource::Application, :vcr do
 
     context 'given a wrong directory' do
       let(:new_directory) { test_api_client.directories.create(directory_attrs) }
-      let(:account) { new_directory.accounts.create account_attrs(password: 'P@$$w0rd') }
+      let(:account) { new_directory.accounts.create(account_attrs(password: 'P@$$w0rd')) }
       let(:login_request) do
-        Stormpath::Authentication::UsernamePasswordRequest.new account.username, password, account_store: directory
+        Stormpath::Authentication::UsernamePasswordRequest.new(
+          account.username,
+          password,
+          account_store: directory
+        )
       end
 
-      after do
-        new_directory.delete if new_directory
-      end
+      after { new_directory.delete if new_directory }
 
       it 'raises an error' do
         expect { authentication_result }.to raise_error Stormpath::Error
@@ -255,21 +247,19 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'given a group' do
-      let(:group) {directory.groups.create(group_attrs) }
-
-      let(:account) { directory.accounts.create account_attrs(password: 'P@$$w0rd') }
-
+      let(:group) { directory.groups.create(group_attrs) }
+      let(:account) { directory.accounts.create(account_attrs(password: 'P@$$w0rd')) }
       let(:login_request) do
-        Stormpath::Authentication::UsernamePasswordRequest.new account.username, password, account_store: group
+        Stormpath::Authentication::UsernamePasswordRequest.new(
+          account.username,
+          password,
+          account_store: group
+        )
       end
 
-      before do
-        map_account_store(application, group, 0, true, false)
-      end
+      before { map_account_store(application, group, 0, true, false) }
 
-      after do
-        group.delete if group
-      end
+      after { group.delete if group }
 
       it 'and assigning the account to it, should return a authentication result' do
         group.add_account account
@@ -283,16 +273,13 @@ describe Stormpath::Resource::Application, :vcr do
         expect { authentication_result }.to raise_error Stormpath::Error
       end
     end
-
   end
 
   describe '#send_password_reset_email' do
     context 'given an email' do
       context 'of an existing account on the application' do
-        let(:account) { directory.accounts.create account_attrs  }
-
+        let(:account) { directory.accounts.create(account_attrs) }
         let(:sent_to_account) { application.send_password_reset_email account.email }
-
         after { account.delete if account }
 
         it 'sends a password reset request of the account' do
@@ -303,7 +290,7 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       context 'of an existing account not mapped to the application' do
-        let(:account) { other_directory.accounts.create account_attrs  }
+        let(:account) { other_directory.accounts.create(account_attrs) }
         let(:other_directory) { test_api_client.directories.create(directory_attrs) }
 
         after do
@@ -321,14 +308,13 @@ describe Stormpath::Resource::Application, :vcr do
       context 'of a non exisitng account' do
         it 'raises an exception' do
           expect do
-            application.send_password_reset_email "test@example.com"
+            application.send_password_reset_email 'test@example.com'
           end.to raise_error Stormpath::Error
         end
       end
 
       context 'of an existing account on the application with an account store href' do
-        let(:account) { directory.accounts.create account_attrs  }
-
+        let(:account) { directory.accounts.create(account_attrs) }
         let(:sent_to_account) do
           application.send_password_reset_email(account.email, account_store: { href: directory.href })
         end
@@ -343,8 +329,7 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       context 'of an existing account on the application with an account store resource object' do
-        let(:account) { directory.accounts.create account_attrs  }
-
+        let(:account) { directory.accounts.create(account_attrs) }
         let(:sent_to_account) do
           application.send_password_reset_email(account.email, account_store: directory)
         end
@@ -359,7 +344,7 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       context 'of an existing account not mapped to the application with an account store href' do
-        let(:account) { directory.accounts.create account_attrs  }
+        let(:account) { directory.accounts.create(account_attrs) }
         let(:other_directory) { test_api_client.directories.create(directory_attrs) }
 
         after do
@@ -375,36 +360,21 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       context 'of an existing account on the application with a non existant account store organization namekey' do
-        let(:account) { directory.accounts.create account_attrs  }
-
-        after do
-          account.delete
-        end
+        let(:account) { directory.accounts.create(account_attrs) }
+        after { account.delete }
 
         it 'sends a password reset request of the account' do
           expect do
-            application.send_password_reset_email(account.email, account_store: { name_key: "NoKey" })
+            application.send_password_reset_email(account.email, account_store: { name_key: 'NoKey' })
           end.to raise_error Stormpath::Error
         end
       end
 
       context 'of an existing account on the application with a right account store organization namekey' do
-        let(:account) { account_directory.accounts.create account_attrs  }
+        let(:account) { account_directory.accounts.create(account_attrs) }
         let(:account_directory) { test_api_client.directories.create(directory_attrs) }
-
-        let(:reloaded_account_directory) do
-          test_api_client.directories.get(account_directory.href)
-        end
-
-        let(:organization_name_key) { 'ruby-test-org-name-key' }
-
-        let(:organization) do
-          test_api_client.organizations.create(
-            name: "ruby_test_organization_name",
-            name_key: organization_name_key
-          )
-        end
-
+        let(:reloaded_account_directory) { test_api_client.directories.get(account_directory.href) }
+        let(:organization) { test_api_client.organizations.create(organization_attrs) }
         let(:sent_to_account) do
           application.send_password_reset_email(account.email, account_store: { name_key: organization.name_key })
         end
@@ -428,11 +398,9 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       context 'of an existing account on the application with a right account store organization resource object' do
-        let(:account) { account_directory.accounts.create account_attrs  }
+        let(:account) { account_directory.accounts.create(account_attrs) }
         let(:account_directory) { test_api_client.directories.create(directory_attrs) }
-        let(:reloaded_account_directory) do
-          test_api_client.directories.get(account_directory.href)
-        end
+        let(:reloaded_account_directory) { test_api_client.directories.get(account_directory.href) }
         let(:organization) { test_api_client.organizations.create(organization_attrs) }
         let(:sent_to_account) do
           application.send_password_reset_email(account.email, account_store: organization)
@@ -457,11 +425,9 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       context 'of an existing account on the application with a wrong account store organization namekey' do
-        let(:account) { account_directory.accounts.create account_attrs  }
+        let(:account) { account_directory.accounts.create(account_attrs) }
         let(:account_directory) { test_api_client.directories.create(directory_attrs) }
-        let(:reloaded_account_directory) do
-          test_api_client.directories.get(account_directory.href)
-        end
+        let(:reloaded_account_directory) { test_api_client.directories.get(account_directory.href) }
         let(:organization) { test_api_client.organizations.create(organization_attrs) }
         let(:other_organization) { test_api_client.organizations.create(organization_attrs) }
 
@@ -514,12 +480,8 @@ describe Stormpath::Resource::Application, :vcr do
 
     context 'valid credentials' do
       let(:username_password_request) do
-        Stormpath::Authentication::UsernamePasswordRequest.new(
-          account.email,
-          "P@$$w0rd"
-        )
+        Stormpath::Authentication::UsernamePasswordRequest.new(account.email, 'P@$$w0rd')
       end
-
       let(:auth_request) { application.authenticate_account(username_password_request) }
 
       it 'returns login attempt response' do
@@ -532,11 +494,7 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'with organization as account store option' do
-      let(:organization) do
-        test_api_client.organizations.create(name: 'test_organization',
-                                             name_key: 'testorganization')
-      end
-
+      let(:organization) { test_api_client.organizations.create(organization_attrs) }
       let(:auth_request) { application.authenticate_account(username_password_request) }
 
       before do
@@ -544,15 +502,13 @@ describe Stormpath::Resource::Application, :vcr do
         map_account_store(application, organization, 0, true, false)
       end
 
-      after do
-        organization.delete if organization
-      end
+      after { organization.delete if organization }
 
       describe 'when sending the proper organization' do
         describe 'using an organization name_key' do
           let(:username_password_request) do
             Stormpath::Authentication::UsernamePasswordRequest.new(
-              account.email, "P@$$w0rd",
+              account.email, 'P@$$w0rd',
               account_store: { name_key: organization.name_key }
             )
           end
@@ -569,7 +525,7 @@ describe Stormpath::Resource::Application, :vcr do
         describe 'using an organization href' do
           let(:username_password_request) do
             Stormpath::Authentication::UsernamePasswordRequest.new(
-              account.email, "P@$$w0rd",
+              account.email, 'P@$$w0rd',
               account_store: { href: organization.href }
             )
           end
@@ -586,7 +542,7 @@ describe Stormpath::Resource::Application, :vcr do
         describe 'using an organization object' do
           let(:username_password_request) do
             Stormpath::Authentication::UsernamePasswordRequest.new(
-              account.email, "P@$$w0rd",
+              account.email, 'P@$$w0rd',
               account_store: organization
             )
           end
@@ -605,7 +561,7 @@ describe Stormpath::Resource::Application, :vcr do
         describe 'using an organization name_key' do
           let(:username_password_request) do
             Stormpath::Authentication::UsernamePasswordRequest.new(
-              account.email, "P@$$w0rd",
+              account.email, 'P@$$w0rd',
               account_store: { name_key: 'wrong-name-key' }
             )
           end
@@ -618,55 +574,47 @@ describe Stormpath::Resource::Application, :vcr do
         describe 'using an organization href' do
           let(:username_password_request) do
             Stormpath::Authentication::UsernamePasswordRequest.new(
-              account.email, "P@$$w0rd",
+              account.email, 'P@$$w0rd',
               account_store: { href: other_organization.href }
             )
           end
-
-          let(:other_organization) do
-            test_api_client.organizations.create name: 'other_organization',
-               name_key: "other-organization"
-          end
+          let(:other_organization) { test_api_client.organizations.create(organization_attrs) }
 
           it 'raises an error' do
             expect { auth_request }.to raise_error(Stormpath::Error)
           end
+
+          after { other_organization.delete }
         end
 
         describe 'using an organization object' do
           let(:username_password_request) do
             Stormpath::Authentication::UsernamePasswordRequest.new(
-              account.email, "P@$$w0rd",
+              account.email, 'P@$$w0rd',
               account_store: other_organization
             )
           end
-
-          let(:other_organization) do
-            test_api_client.organizations.create name: 'other_organization',
-               name_key: "other-organization"
-          end
+          let(:other_organization) { test_api_client.organizations.create(organization_attrs) }
 
           it 'raises an error' do
             expect { auth_request }.to raise_error(Stormpath::Error)
           end
+
+          after { other_organization.delete }
         end
       end
     end
 
     context 'with invalid credentials' do
       let(:username_password_request) do
-        Stormpath::Authentication::UsernamePasswordRequest.new(
-          account.email,
-          "invalid"
-        )
+        Stormpath::Authentication::UsernamePasswordRequest.new(account.email, 'invalid')
       end
-
       let(:auth_request) { application.authenticate_account(username_password_request) }
 
       it 'returns stormpath error' do
-        expect {
+        expect do
           auth_request
-        }.to raise_error(Stormpath::Error)
+        end.to raise_error(Stormpath::Error)
       end
     end
   end
@@ -680,9 +628,7 @@ describe Stormpath::Resource::Application, :vcr do
       application.verify_password_reset_token password_reset_token
     end
 
-    after do
-      account.delete if account
-    end
+    after { account.delete if account }
 
     context 'with decoded password reset token' do
       it 'retrieves the account with the reset password' do
@@ -703,14 +649,10 @@ describe Stormpath::Resource::Application, :vcr do
 
     context 'and if the password is changed' do
       let(:new_password) { 'N3wP@$$w0rd' }
-
       let(:login_request) do
-        Stormpath::Authentication::UsernamePasswordRequest.new account.username, new_password
-      end
-
-      let(:authentication_result) do
-        application.authenticate_account login_request
+        Stormpath::Authentication::UsernamePasswordRequest.new(account.username, new_password)
       end
+      let(:authentication_result) { application.authenticate_account login_request }
 
       before do
         reset_password_account.password = new_password
@@ -728,29 +670,31 @@ describe Stormpath::Resource::Application, :vcr do
 
   describe '#create_application_with_custom_data' do
     it 'creates an application with custom data' do
-      application.custom_data["category"] = "classified"
+      application.custom_data['category'] = 'classified'
       application.save
 
-      expect(application.custom_data["category"]).to eq("classified")
+      expect(application.custom_data['category']).to eq('classified')
     end
   end
 
   describe '#create_id_site_url' do
-    let(:jwt_token) { JWT.encode({
-        'iat' => Time.now.to_i,
-        'jti' => UUID.method(:random_create).call.to_s,
-        'aud' => test_api_key_id,
-        'sub' => application.href,
-        'cb_uri' => 'http://localhost:9292/redirect',
-        'path' => '',
-        'state' => ''
-      }, test_api_key_secret, 'HS256')
-    }
-
-    let(:create_id_site_url_result) do
-      options = { callback_uri: 'http://localhost:9292/redirect' }
-      application.create_id_site_url options
+    let(:jwt_token) do
+      JWT.encode(
+        {
+          'iat' => Time.now.to_i,
+          'jti' => UUID.method(:random_create).call.to_s,
+          'aud' => test_api_key_id,
+          'sub' => application.href,
+          'cb_uri' => 'http://localhost:9292/redirect',
+          'path' => '',
+          'state' => ''
+        }, test_api_key_secret, 'HS256'
+      )
     end
+    let(:create_id_site_url_result) { application.create_id_site_url(options) }
+    let(:options) { { callback_uri: 'http://localhost:9292/redirect' } }
+    let(:uri) { Addressable::URI.parse(create_id_site_url_result) }
+    let(:jwt_token) { JWT.decode(uri.query_values['jwtRequest'], test_api_key_secret).first }
 
     it 'should create a url with jwtRequest' do
       expect(create_id_site_url_result).to include('jwtRequest')
@@ -761,37 +705,52 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     it 'should create a jwtRequest that is signed wit the client secret' do
-      uri = Addressable::URI.parse(create_id_site_url_result)
-      jwt_token = JWT.decode(uri.query_values["jwtRequest"], test_api_key_secret).first
-
-      expect(jwt_token["iss"]).to eq test_api_key_id
-      expect(jwt_token["sub"]).to eq application.href
-      expect(jwt_token["cb_uri"]).to eq 'http://localhost:9292/redirect'
+      expect(jwt_token['iss']).to eq test_api_key_id
+      expect(jwt_token['sub']).to eq application.href
+      expect(jwt_token['cb_uri']).to eq 'http://localhost:9292/redirect'
     end
 
     context 'with logout option' do
+      before { options[:logout] = true }
+
       it 'shoud create a request to /sso/logout' do
+        expect(create_id_site_url_result).to include('/sso/logout')
       end
     end
 
-    context 'without providing cb_uri' do
-      let(:create_id_site_url_result) do
-        options = { callback_uri: '' }
-        application.create_id_site_url options
+    context 'with bad cb_uri' do
+      context 'blank' do
+        before { options[:callback_uri] = '' }
+
+        it 'should raise Stormpath Error with correct id_site error data' do
+          begin
+            create_id_site_url_result
+          rescue Stormpath::Error => error
+            expect(error.status).to eq(400)
+            expect(error.code).to eq(400)
+            expect(error.message).to eq('The specified callback URI (cb_uri) is not valid')
+            expect(error.developer_message).to eq('The specified callback URI (cb_uri) is not valid.'\
+              ' Make sure the callback URI specified in your ID Site configuration matches the value specified.')
+          end
+        end
       end
 
-      it 'should raise Stormpath Error with correct id_site error data' do
-        begin
-          create_id_site_url_result
-        rescue Stormpath::Error => error
-          expect(error.status).to eq(400)
-          expect(error.code).to eq(400)
-          expect(error.message).to eq("The specified callback URI (cb_uri) is not valid")
-          expect(error.developer_message).to eq("The specified callback URI (cb_uri) is not valid. Make sure the "\
-            "callback URI specified in your ID Site configuration matches the value specified.")
+      context 'nil' do
+        before { options.delete(:callback_uri) }
+
+        it 'should raise Stormpath Error' do
+          expect { create_id_site_url_result }.to raise_error(Stormpath::Error)
         end
       end
     end
+
+    context 'with providing require_mfa' do
+      before { options[:require_mfa] = ['sms'] }
+
+      it 'should create a jwtRequest that contains require_mfa' do
+        expect(jwt_token['require_mfa']).to eq ['sms']
+      end
+    end
   end
 
   describe '#handle_id_site_callback' do
@@ -804,89 +763,95 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'with a valid jwt response' do
-      let(:jwt_token) { JWT.encode({
-          'iat' => Time.now.to_i,
-          'aud' => test_api_key_id,
-          'sub' => application.href,
-          'path' => '',
-          'state' => '',
-          'isNewSub' => true,
-          'status' => "REGISTERED"
-        }, test_api_key_secret, 'HS256')
-      }
-
-      before do
-        @site_result = application.handle_id_site_callback(callback_uri_base + jwt_token)
+      let(:jwt_token) do
+        JWT.encode(
+          {
+            'iat' => Time.now.to_i,
+            'aud' => test_api_key_id,
+            'sub' => application.href,
+            'path' => '',
+            'state' => '',
+            'isNewSub' => true,
+            'status' => 'REGISTERED'
+          }, test_api_key_secret, 'HS256'
+        )
       end
+      let!(:site_result) { application.handle_id_site_callback(callback_uri_base + jwt_token) }
 
       it 'should return IdSiteResult object' do
-        expect(@site_result).to be_kind_of(Stormpath::IdSite::IdSiteResult)
+        expect(site_result).to be_kind_of(Stormpath::IdSite::IdSiteResult)
       end
 
       it 'should set the correct account on IdSiteResult object' do
-        expect(@site_result.account_href).to eq(application.href)
+        expect(site_result.account_href).to eq(application.href)
       end
 
       it 'should set the correct status on IdSiteResult object' do
-        expect(@site_result.status).to eq("REGISTERED")
+        expect(site_result.status).to eq('REGISTERED')
       end
 
       it 'should set the correct state on IdSiteResult object' do
-        expect(@site_result.state).to eq("")
+        expect(site_result.state).to eq('')
       end
 
       it 'should set the correct is_new_account on IdSiteResult object' do
-        expect(@site_result.new_account?).to eq(true)
+        expect(site_result.new_account?).to eq(true)
       end
     end
 
     context 'with an expired token' do
-      let(:jwt_token) { JWT.encode({
-          'iat' => Time.now.to_i,
-          'aud' => test_api_key_id,
-          'sub' => application.href,
-          'path' => '',
-          'state' => '',
-          'exp' => Time.now.to_i - 1,
-          'isNewSub' => true,
-          'status' => "REGISTERED"
-        }, test_api_key_secret, 'HS256')
-      }
+      let(:jwt_token) do
+        JWT.encode(
+          {
+            'iat' => Time.now.to_i,
+            'aud' => test_api_key_id,
+            'sub' => application.href,
+            'path' => '',
+            'state' => '',
+            'exp' => Time.now.to_i - 1,
+            'isNewSub' => true,
+            'status' => 'REGISTERED'
+          }, test_api_key_secret, 'HS256'
+        )
+      end
 
       it 'should raise Stormpath Error with correct data' do
         begin
           application.handle_id_site_callback(callback_uri_base + jwt_token)
         rescue Stormpath::Error => error
           expect(error.status).to eq(400)
-          expect(error.code).to eq(10011)
-          expect(error.message).to eq("Token is invalid")
-          expect(error.developer_message).to eq("Token is no longer valid because it has expired")
+          expect(error.code).to eq(10_011)
+          expect(error.message).to eq('Token is invalid')
+          expect(error.developer_message).to eq('Token is no longer valid because it has expired')
         end
       end
 
       it 'should raise expiration error' do
-        expect {
+        expect do
           application.handle_id_site_callback(callback_uri_base + jwt_token)
-        }.to raise_error(Stormpath::Error)
+        end.to raise_error(Stormpath::Error)
       end
     end
 
     context 'with a different client id (aud)' do
-      let(:jwt_token) { JWT.encode({
-          'iat' => Time.now.to_i,
-          'aud' => UUID.method(:random_create).call.to_s,
-          'sub' => application.href,
-          'path' => '',
-          'state' => '',
-          'isNewSub' => true,
-          'status' => "REGISTERED"
-        }, test_api_key_secret, 'HS256')
-      }
+      let(:jwt_token) do
+        JWT.encode(
+          {
+            'iat' => Time.now.to_i,
+            'aud' => UUID.method(:random_create).call.to_s,
+            'sub' => application.href,
+            'path' => '',
+            'state' => '',
+            'isNewSub' => true,
+            'status' => 'REGISTERED'
+          }, test_api_key_secret, 'HS256'
+        )
+      end
 
       it 'should raise error' do
-        expect {
+        expect do
           application.handle_id_site_callback(callback_uri_base + jwt_token)
-        }.to raise_error(Stormpath::Error)
+        end.to raise_error(Stormpath::Error)
       end
 
       it 'should raise Stormpath Error with correct id_site error data' do
@@ -894,88 +859,98 @@ describe Stormpath::Resource::Application, :vcr do
           application.handle_id_site_callback(callback_uri_base + jwt_token)
         rescue Stormpath::Error => error
           expect(error.status).to eq(400)
-          expect(error.code).to eq(10012)
-          expect(error.message).to eq("Token is invalid")
-          expect(error.developer_message).to eq("Token is invalid because the issued at time (iat) "\
-            "is after the current time")
+          expect(error.code).to eq(10_012)
+          expect(error.message).to eq('Token is invalid')
+          expect(error.developer_message).to eq('Token is invalid because the issued at time (iat) '\
+            'is after the current time')
         end
       end
     end
 
     context 'with an invalid exp value' do
-      let(:jwt_token) { JWT.encode({
-          'iat' => Time.now.to_i,
-          'aud' => test_api_key_id,
-          'sub' => application.href,
-          'path' => '',
-          'state' => '',
-          'exp' => 'not gona work',
-          'isNewSub' => true,
-          'status' => "REGISTERED"
-        }, test_api_key_secret, 'HS256')
-      }
+      let(:jwt_token) do
+        JWT.encode(
+          {
+            'iat' => Time.now.to_i,
+            'aud' => test_api_key_id,
+            'sub' => application.href,
+            'path' => '',
+            'state' => '',
+            'exp' => 'not gona work',
+            'isNewSub' => true,
+            'status' => 'REGISTERED'
+          }, test_api_key_secret, 'HS256'
+        )
+      end
 
       it 'should error with the stormpath error' do
-        expect {
+        expect do
           application.handle_id_site_callback(callback_uri_base + jwt_token)
-        }.to raise_error(Stormpath::Error)
+        end.to raise_error(Stormpath::Error)
       end
     end
 
     context 'with an invalid signature' do
-      let(:jwt_token) { JWT.encode({
-          'iat' => Time.now.to_i,
-          'aud' => test_api_key_id,
-          'sub' => application.href,
-          'path' => '',
-          'state' => '',
-          'isNewSub' => true,
-          'status' => "REGISTERED"
-        }, 'false key', 'HS256')
-      }
+      let(:jwt_token) do
+        JWT.encode(
+          {
+            'iat' => Time.now.to_i,
+            'aud' => test_api_key_id,
+            'sub' => application.href,
+            'path' => '',
+            'state' => '',
+            'isNewSub' => true,
+            'status' => 'REGISTERED'
+          }, 'false key', 'HS256'
+        )
+      end
 
       it 'should reject the signature' do
-        expect {
+        expect do
           application.handle_id_site_callback(callback_uri_base + jwt_token)
-        }.to raise_error(JWT::DecodeError)
+        end.to raise_error(JWT::DecodeError)
       end
     end
 
     context 'with show_organization_field key specified' do
-      let(:jwt_token) { JWT.encode({
-          'iat' => Time.now.to_i,
-          'aud' => test_api_key_id,
-          'sub' => application.href,
-          'path' => '',
-          'state' => '',
-          'isNewSub' => true,
-          'status' => "REGISTERED",
-          'organization_name_key' => 'stormtroopers',
-          'usd' => true,
-          'sof' => true
-        }, test_api_key_secret, 'HS256')
-      }
-
-      before do
-        @site_result = application.handle_id_site_callback(callback_uri_base + jwt_token)
+      let(:jwt_token) do
+        JWT.encode(
+          {
+            'iat' => Time.now.to_i,
+            'aud' => test_api_key_id,
+            'sub' => application.href,
+            'path' => '',
+            'state' => '',
+            'isNewSub' => true,
+            'status' => 'REGISTERED',
+            'organization_name_key' => 'stormtroopers',
+            'usd' => true,
+            'sof' => true
+          }, test_api_key_secret, 'HS256'
+        )
       end
+      let!(:site_result) { application.handle_id_site_callback(callback_uri_base + jwt_token) }
 
       it 'should return IdSiteResult object' do
-        expect(@site_result).to be_kind_of(Stormpath::IdSite::IdSiteResult)
+        expect(site_result).to be_kind_of(Stormpath::IdSite::IdSiteResult)
       end
     end
   end
 
   describe '#authenticate_oauth' do
     let(:account_data) { account_attrs }
-    let(:password_grant_request) { Stormpath::Oauth::PasswordGrantRequest.new account_data[:email], account_data[:password] }
+    let(:password_grant_request) do
+      Stormpath::Oauth::PasswordGrantRequest.new(account_data[:email], account_data[:password])
+    end
     let(:aquire_token) { application.authenticate_oauth(password_grant_request) }
-    let(:account) { application.accounts.create account_data }
+    let(:account) { application.accounts.create(account_data) }
 
     before { account }
 
     context 'generate access token from password grant request' do
-      let(:password_grant_request) { Stormpath::Oauth::PasswordGrantRequest.new account_data[:email], account_data[:password] }
+      let(:password_grant_request) do
+        Stormpath::Oauth::PasswordGrantRequest.new(account_data[:email], account_data[:password])
+      end
       let(:authenticate_oauth) { application.authenticate_oauth(password_grant_request) }
 
       context 'without organization_name_key' do
@@ -993,21 +968,21 @@ describe Stormpath::Resource::Application, :vcr do
       end
 
       context 'with the organization name key' do
-        let!(:organization) do
-          test_api_client.organizations.create name: 'rspec-test-org', name_key: 'rspec-test-org'
-        end
-        let(:account_directory) do
-          test_api_client.directories.create(
-            name: 'rspec-directory'
+        let!(:organization) { test_api_client.organizations.create(organization_attrs) }
+        let(:account_directory) { test_api_client.directories.create(directory_attrs) }
+        let(:reloaded_account_directory) { test_api_client.directories.get(account_directory.href) }
+        let(:password_grant_request) do
+          Stormpath::Oauth::PasswordGrantRequest.new(
+            account_data[:email],
+            account_data[:password],
+            organization_name_key: organization.name_key
           )
         end
-        let(:reloaded_account_directory) do
-          test_api_client.directories.get(account_directory.href)
-        end
-        let(:password_grant_request) do
-          Stormpath::Oauth::PasswordGrantRequest.new(account_data[:email],
-                                                     account_data[:password],
-                                                     organization_name_key: 'rspec-test-org')
+
+        before do
+          map_account_store(application, organization, 0, true, true)
+          map_organization_store(account_directory, organization)
+          account_directory.accounts.create(account_data)
         end
 
         after do
@@ -1015,12 +990,6 @@ describe Stormpath::Resource::Application, :vcr do
           reloaded_account_directory.delete
         end
 
-        before do
-          map_account_store(application, organization, 0, true, true)
-          map_organization_store(account_directory, organization)
-          account_directory.accounts.create account_data
-        end
-
         it 'should return access token response' do
           expect(authenticate_oauth).to be_kind_of(Stormpath::Oauth::AccessTokenAuthenticationResult)
         end
@@ -1095,14 +1064,12 @@ describe Stormpath::Resource::Application, :vcr do
 
     context 'generate access token from client credentials request' do
       let(:account_api_key) { account.api_keys.create({}) }
-
       let(:client_credentials_grant_request) do
         Stormpath::Oauth::ClientCredentialsGrantRequest.new(
           account_api_key.id,
           account_api_key.secret
         )
       end
-
       let(:authenticate_oauth) { application.authenticate_oauth(client_credentials_grant_request) }
 
       it 'should return access token response' do
@@ -1126,9 +1093,10 @@ describe Stormpath::Resource::Application, :vcr do
           Stormpath::Oauth::SocialGrantRequest.new(:google, code: code)
         end
         before do
-          stub_request(:post,
-          "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token")
-          .to_return(body: Stormpath::Test.mocked_social_grant_response)
+          stub_request(
+            :post,
+            "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token"
+          ).to_return(body: Stormpath::Test.mocked_social_grant_response)
         end
 
         it 'should return access token response' do
@@ -1150,9 +1118,10 @@ describe Stormpath::Resource::Application, :vcr do
           Stormpath::Oauth::SocialGrantRequest.new(:linkedin, code: code)
         end
         before do
-          stub_request(:post,
-          "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token")
-          .to_return(body: Stormpath::Test.mocked_social_grant_response)
+          stub_request(
+            :post,
+            "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token"
+          ).to_return(body: Stormpath::Test.mocked_social_grant_response)
         end
 
         it 'should return access token response' do
@@ -1174,9 +1143,10 @@ describe Stormpath::Resource::Application, :vcr do
           Stormpath::Oauth::SocialGrantRequest.new(:google, access_token: access_token)
         end
         before do
-          stub_request(:post,
-          "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token")
-          .to_return(body: Stormpath::Test.mocked_social_grant_response)
+          stub_request(
+            :post,
+            "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token"
+          ).to_return(body: Stormpath::Test.mocked_social_grant_response)
         end
 
         it 'should return access token response' do
@@ -1198,9 +1168,10 @@ describe Stormpath::Resource::Application, :vcr do
           Stormpath::Oauth::SocialGrantRequest.new(:github, access_token: access_token)
         end
         before do
-          stub_request(:post,
-          "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token")
-          .to_return(body: Stormpath::Test.mocked_social_grant_response)
+          stub_request(
+            :post,
+            "https://#{test_api_key_id}:#{test_api_key_secret}@api.stormpath.com/v1/applications/#{application.href.split('/').last}/oauth/token"
+          ).to_return(body: Stormpath::Test.mocked_social_grant_response)
         end
 
         it 'should return access token response' do
@@ -1219,13 +1190,15 @@ describe Stormpath::Resource::Application, :vcr do
 
     context 'generate access token from challenge factor grant request' do
       before do
-        stub_request(:post,
-                     "https://#{test_api_key_id}:#{test_api_key_secret}@#{test_host}/v1/accounts/#{account.href.split('/').last}/factors?challenge=true")
-          .to_return(body: Stormpath::Test.mocked_factor_response)
+        stub_request(
+          :post,
+          "https://#{test_api_key_id}:#{test_api_key_secret}@#{test_host}/v1/accounts/#{account.href.split('/').last}/factors?challenge=true"
+        ).to_return(body: Stormpath::Test.mocked_factor_response)
 
-        stub_request(:post,
-                     "https://#{test_api_key_id}:#{test_api_key_secret}@#{test_host}/v1/applications/#{application.href.split('/').last}/oauth/token")
-          .to_return(body: Stormpath::Test.mocked_challenge_factor_grant_response)
+        stub_request(
+          :post,
+          "https://#{test_api_key_id}:#{test_api_key_secret}@#{test_host}/v1/applications/#{application.href.split('/').last}/oauth/token"
+        ).to_return(body: Stormpath::Test.mocked_challenge_factor_grant_response)
       end
       let(:account_data) { account_attrs }
       let(:authenticate_oauth) { application.authenticate_oauth(challenge_factor_grant_request) }
@@ -1236,11 +1209,13 @@ describe Stormpath::Resource::Application, :vcr do
         application.accounts.create(account_data)
       end
       let(:factor) do
-        account.create_factor(:sms,
-                              phone: { number: '+12025550173',
-                                       name: 'Rspec test phone',
-                                       description: 'This is a testing phone number' },
-                              challenge: { message: 'Enter code please: ' })
+        account.create_factor(
+          :sms,
+          phone: { number: '+12025550173',
+                   name: 'Rspec test phone',
+                   description: 'This is a testing phone number' },
+          challenge: { message: 'Enter code please: ' }
+        )
       end
       let(:challenge) { "https://#{test_host}/v1/challenges/29300284904" }
       let(:code) { '123456' }
@@ -1260,28 +1235,28 @@ describe Stormpath::Resource::Application, :vcr do
 
     context 'exchange id site token for access_token with invalid jwt' do
       let(:invalid_jwt_token) { 'invalid_token' }
-
-      let(:id_site_grant_request) { Stormpath::Oauth::IdSiteGrantRequest.new invalid_jwt_token }
+      let(:id_site_grant_request) { Stormpath::Oauth::IdSiteGrantRequest.new(invalid_jwt_token) }
       let(:authenticate_oauth) { application.authenticate_oauth(id_site_grant_request) }
 
       it 'should raise invalid token error' do
-        expect {
-          authenticate_oauth
-        }.to raise_error(Stormpath::Error)
+        expect { authenticate_oauth }.to raise_error(Stormpath::Error)
       end
     end
 
     context 'echange id site token for access_token with valid jwt' do
-      let(:jwt_token) { JWT.encode({
-          'iat' => Time.now.to_i,
-          'jti' => UUID.method(:random_create).call.to_s,
-          'iss' => test_api_client.data_store.api_key.id,
-          'sub' => application.href,
-          'cb_uri' => 'http://localhost:9292/redirect',
-          'path' => '',
-          'state' => ''
-        }, test_api_client.data_store.api_key.secret, 'HS256')
-      }
+      let(:jwt_token) do
+        JWT.encode(
+          {
+            'iat' => Time.now.to_i,
+            'jti' => UUID.method(:random_create).call.to_s,
+            'iss' => test_api_client.data_store.api_key.id,
+            'sub' => application.href,
+            'cb_uri' => 'http://localhost:9292/redirect',
+            'path' => '',
+            'state' => ''
+          }, test_api_client.data_store.api_key.secret, 'HS256'
+        )
+      end
 
       it 'should create a jwtRequest that is signed wit the client secret' do
         allow(application.client.data_store).to receive(:create).and_return(Stormpath::Oauth::AccessTokenAuthenticationResult)
@@ -1289,7 +1264,7 @@ describe Stormpath::Resource::Application, :vcr do
           .with(Stormpath::Oauth::IdSiteGrant)
           .and_return(Stormpath::Oauth::IdSiteGrant.new({}, application.client))
 
-        grant_request = Stormpath::Oauth::IdSiteGrantRequest.new jwt_token
+        grant_request = Stormpath::Oauth::IdSiteGrantRequest.new(jwt_token)
         response = application.authenticate_oauth(grant_request)
 
         expect(response).to be(Stormpath::Oauth::AccessTokenAuthenticationResult)
@@ -1297,7 +1272,7 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'refresh token' do
-      let(:refresh_grant_request) { Stormpath::Oauth::RefreshGrantRequest.new aquire_token.refresh_token }
+      let(:refresh_grant_request) { Stormpath::Oauth::RefreshGrantRequest.new(aquire_token.refresh_token) }
       let(:authenticate_oauth) { application.authenticate_oauth(refresh_grant_request) }
 
       it 'should return access token response with refreshed token' do
@@ -1363,10 +1338,29 @@ describe Stormpath::Resource::Application, :vcr do
         access_token = aquire_token.access_token
         aquire_token.delete
 
-        expect {
+        expect do
           Stormpath::Oauth::VerifyAccessToken.new(application).verify(access_token)
-        }.to raise_error(Stormpath::Error)
+        end.to raise_error(Stormpath::Error)
       end
     end
   end
+
+  describe '#register_service_provider' do
+    let(:assertion_consumer_service_url) { 'https://some.sp.com/saml/sso/post' }
+    let(:entity_id) { 'urn:sp:A1B2C3' }
+    let(:registered_service_provider) do
+      application.register_service_provider(
+        assertion_consumer_service_url: assertion_consumer_service_url,
+        entity_id: entity_id
+      )
+    end
+
+    after { registered_service_provider.delete }
+
+    it 'should successfully create and register a service provider' do
+      expect(registered_service_provider).to(
+        be_a(Stormpath::Resource::RegisteredSamlServiceProvider)
+      )
+    end
+  end
 end