stormpath-sdk 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9ba021abe721aacd48f6507ca61e7d23bbe85f1
-  data.tar.gz: 4a0a74ae0bd2d179888becafc4ba94c8598b6c8a
+  metadata.gz: 7c94bbec690d16f6c04eda0f7e46dd79c9406747
+  data.tar.gz: 10271a383fb9537813d22cacc1646df9c67b709d
 SHA512:
-  metadata.gz: 70784a596911dde78a22749952d552bf8c35042fad1387720796284f3a66ec4cd52c8757eb1117925a6c4d8d47546d0cb46ee6c7430a236becb5c32f046bcdc7
-  data.tar.gz: 6eb7a9b888f7a5e3c4ab1b5078aa38f82f5eac37fc86ccf2befe3ff34d78e4e6d88a2dcaa026683eb2687e463f5cc1aa2e206b7722b53728926e340eeb1797c2
+  metadata.gz: 284ad0976afabc1777161def9266669f855f2eb3bcb6eaaa026bb66e195de22537da218f7cea5b33d68554202d28d5f4714e39e9c7e0e01f91de2b94dabf68e0
+  data.tar.gz: dc7e80f1a5501e989c7fab8f5b1f2ee889b3c71ae9f75bb1a91bb023e593bed70c83d8ee6bf1da8288556f73a709405c9f6245a12d2019f6d469326a1ff07c59

data/.rspec

@@ -0,0 +1 @@
+--color --format Fivemat

data/.travis.yml

@@ -11,6 +11,3 @@ env:
   global:
   - secure: MeyjZGgySZvpYVRm2i7wkrhvu9KUeU7eQ5aKj7FXqIYlQe3T67k+KKA3Ejp6WC3wUEVPUFseWMZCuNkRc0UeGA5/4e4LLc++XuaZn1jLTm1yNofh/CFAAjt5VdIYz4R7sKxpyLxs0orK2+HcaiCoqSDj7ehw2SlDca9VEi0GoQk=
   - secure: MrtbhfH1IfwDkkvf0pq6trgj68to/fK4c+L1daKvMaNiNvwggbA3s0ea9QjHxXfWmPqL5bf8Q5N7YqXUw8cLpRPrKUA65JkyhyzIju8FgzXz83aCvjJD+5XhJIGzpLM8qHeKh7F0K6/iURTKIUgZXbguK4HpEeCMrrdPYcof3Ew=
-  - secure: JChx6k5NOw/PBzH6gpHdqxHPy8hpaTALVs2riTVXorJZ5p06F3riqFBQbMh6REzXdJLjD6VKPORt19WOkmLHCPW8x0g7HxIRHT0DCDLX/4980dZZAev3blSvfJ7t1cWlBVsZb0LgVEkswvKdSYEZvDQTy5XlWsIMuNhHUclsTZk=
-  - secure: c5tUXb7FPMDD/KkpDwYNfnZ2k0N0RltBAQt1IYOFkdcztIAdcGmWPtT4l07He+UJiF2Vy92KrsSK709FFDwdxAleSgFKwpCrtgJRXXqRqT/gDiJUsGU1jC4QgXpu/QWCWsCSs/v1l1GzZyZF61aQzqINVrGwF5n2/MeMGOAJkaA=
-  - secure: SepFOaSOjRr5EJLBlXKT60FgSmKZ604zhhDaes+s9rQgJcaUsVkTxFYhkE6mkDadH7dZ6ACW1TaWWTmFm+JMFuli/bcyvX9wm5akWM6EF3BdJ8djMac34iJuTB3MWED+fOaFco9oZjMQOYZlSu9nS4VOvH0ekcTnQnThzxYxpfs=

data/CHANGES.md

@@ -1,6 +1,15 @@
 stormpath-sdk-ruby Changelog
 ============================
 
+Version 1.3.1
+-------------
+
+Released on November 07, 2016
+
+- Add oauth jwt errors
+- Refactor and DRY up specs
+
+
 Version 1.3.0
 -------------
 

data/README.md

@@ -79,13 +79,13 @@ If you have not already done so, register as a developer on
 1.  **Create an account for a user** on the directory.
 
     ```ruby
-    account = directory.accounts.create({
+    account = directory.accounts.create(
       given_name: 'John',
       surname: 'Smith',
       email: 'john.smith@example.com',
       username: 'johnsmith',
       password: '4P@$$w0rd!'
-    })
+    )
     ```
 
 1.  **Update an account**
@@ -517,13 +517,13 @@ ways:
   on the directory:
 
   ```ruby
-  account = directory.accounts.create({
+  account = directory.accounts.create(
     given_name: 'John',
     surname: 'Smith',
     email: 'john.smith@example.com',
     username: 'johnsmith',
     password: '4P@$$w0rd!'
-  })
+  )
   ```
 
 Both these methods can take either a <code>Hash</code> of the account
@@ -945,27 +945,14 @@ account.custom_data.delete
 ### Setup
 
 The functional tests of the SDK run against a Stormpath tenant. In that
-account, create:
-
-* An application reserved for testing.
-* A directory reserved for test accounts. _Be sure to associate this
-  directory to the test application as a login source_.
-* Another directory reserved for test accounts with the account
-  verification workflow turned on. _Be sure to associate this directory
-  to the test application as a login source_.
+account they automatically create and destroy resources.
 
-The following environment variables need will then need to be set:
+The following environment variables need to be set:
 
-* <code>STORMPATH_SDK_TEST_API_KEY_ID</code> - The <code>id</code> from
+* <code>STORMPATH_CLIENT_APIKEY_ID</code> - The <code>id</code> from
   your Stormpath API key.
-* <code>STORMPATH_SDK_TEST_API_KEY_SECRET</code> - The
+* <code>STORMPATH_CLIENT_APIKEY_SECRET</code> - The
   <code>secret</code> from your Stormpath API key.
-* <code>STORMPATH_SDK_TEST_APPLICATION_URL</code> - The URL to the
-  application created above.
-* <code>STORMPATH_SDK_TEST_DIRECTORY_URL</code> - The URL to the first
-  directory created above.
-* <code>STORMPATH_SDK_TEST_DIRECTORY_WITH_VERIFICATION_URL</code> - The
-  URL to the second directory created above.
 
 ### Running
 

data/Rakefile

@@ -3,8 +3,6 @@ require 'rubygems'
 require 'rubygems/package_task'
 require 'rspec/core/rake_task'
 require 'stormpath-sdk'
-require './support/api'
-
 
 spec = eval(File.read('stormpath-sdk.gemspec'))
 
@@ -17,16 +15,4 @@ RSpec::Core::RakeTask.new do |t|
   t.rspec_opts = ['-c']
 end
 
-task :default => :spec
-
-namespace :api do
-  task :clean do
-    Stormpath::Support::Api.destroy_resources(
-      ENV['STORMPATH_SDK_TEST_API_KEY_ID'],
-      ENV['STORMPATH_SDK_TEST_API_KEY_SECRET'],
-      ENV['STORMPATH_SDK_TEST_APPLICATION_URL'],
-      ENV['STORMPATH_SDK_TEST_DIRECTORY_URL'],
-      ENV['STORMPATH_SDK_TEST_DIRECTORY_WITH_VERIFICATION_URL']
-    )
-  end
-end
+task default: :spec

data/lib/stormpath-sdk/oauth/error.rb

@@ -37,6 +37,27 @@ module Stormpath
             message: 'Token is invalid',
             developer_message: 'Token is invalid because the issued at time (iat) is after the current time',
             request_id: 'Oauth error UUID'
+          },
+          jwt_invalid_issuer: {
+            status: 400,
+            code: 10014,
+            message: 'Token is invalid',
+            developer_message: 'Token is invalid because the issuer of the token does not match the Application validating the token.',
+            request_id: 'Oauth error UUID'
+          },
+          jwt_invalid_signature: {
+            status: 400,
+            code: 10017,
+            message: 'Token is invalid',
+            developer_message: 'Token is invalid because verifying the signature of a JWT failed.',
+            request_id: 'Oauth error UUID'
+          },
+          jwt_invalid_stt: {
+            status: 400,
+            code: nil,
+            message: 'Token is invalid',
+            developer_message: "Token is invalid because the stt header doesn't match the right type",
+            request_id: 'Oauth error UUID'
           }
         }
       end

data/lib/stormpath-sdk/oauth/local_access_token_verification.rb

@@ -26,12 +26,12 @@ module Stormpath
 
       def validate_jwt_is_an_access_token
         return if decoded_jwt.second['stt'] == 'access'
-        raise ArgumentError, 'Token is not an access token'
+        raise Stormpath::Oauth::Error, :jwt_invalid_stt
       end
 
       def validate_jwt_has_a_valid_issuer
         return if decoded_jwt.first['iss'] == application.href
-        raise ArgumentError, 'Token issuer is invalid'
+        raise Stormpath::Oauth::Error, :jwt_invalid_issuer
       end
     end
 

data/lib/stormpath-sdk/oauth/remote_access_token_verification.rb

@@ -16,8 +16,8 @@ module Stormpath
       end
 
       def validate_access_token
-        raise Stormpath::Oauth::Error, :jwt_invalid unless decoded_jwt.second['stt'] == 'access'
-        raise Stormpath::Oauth::Error, :jwt_invalid unless decoded_jwt.first['iss'] == application.href
+        raise Stormpath::Oauth::Error, :jwt_invalid_stt unless decoded_jwt.second['stt'] == 'access'
+        raise Stormpath::Oauth::Error, :jwt_invalid_issuer unless decoded_jwt.first['iss'] == application.href
       end
 
       def decoded_jwt

data/lib/stormpath-sdk/version.rb

@@ -14,6 +14,6 @@
 # limitations under the License.
 #
 module Stormpath
-  VERSION = '1.3.0'
-  VERSION_DATE = '2016-11-04'
+  VERSION = '1.3.1'
+  VERSION_DATE = '2016-11-07'
 end

data/spec/auth/http_basic_authentication_spec.rb

@@ -1,33 +1,18 @@
 require 'spec_helper'
 
 describe 'HttpBasicAuthentication', vcr: true do
-  let(:application) { test_api_client.applications.create(name: 'ruby sdk test app') }
-  let(:directory) { test_api_client.directories.create(name: random_directory_name) }
-  let(:account) do
-    application.accounts.create(
-      email: 'test@example.com',
-      given_name: 'Ruby SDK',
-      password: 'P@$$w0rd',
-      surname: 'SDK'
-    )
-  end
+  let(:application) { test_api_client.applications.create(build_application) }
+  let(:directory) { test_api_client.directories.create(build_directory) }
+  let(:account) { application.accounts.create(build_account) }
   let(:api_key) { account.api_keys.create({}) }
   let(:api_key_id) { api_key.id }
   let(:api_key_secret) { api_key.secret }
   let(:encoded_api_key) { Base64.encode64("#{api_key_id}:#{api_key_secret}") }
   let(:basic_authorization_header) { "Basic #{encoded_api_key}" }
-  let(:authenticate) do
-    Stormpath::Authentication::HttpBasicAuthentication.new(application,
-                                                           basic_authorization_header).authenticate!
-  end
+  let(:authenticator) { Stormpath::Authentication::HttpBasicAuthentication }
+  let(:authenticate) { authenticator.new(application, basic_authorization_header).authenticate! }
 
-  before do
-    test_api_client.account_store_mappings.create(application: application,
-                                                  account_store: directory,
-                                                  list_index: 1,
-                                                  is_default_account_store: true,
-                                                  is_default_group_store: true)
-  end
+  before { map_account_store(application, directory, 1, true, true) }
 
   after do
     account.delete

data/spec/auth/http_bearer_authentication_spec.rb

@@ -1,39 +1,25 @@
 require 'spec_helper'
 
 describe 'HttpBearerAuthentication', vcr: true do
-  let(:application) { test_api_client.applications.create(name: 'ruby sdk test app') }
-  let(:directory) { test_api_client.directories.create(name: random_directory_name) }
-  let(:account) do
-    application.accounts.create(
-      email: 'test@example.com',
-      given_name: 'Ruby SDK',
-      password: 'P@$$w0rd',
-      surname: 'SDK'
-    )
-  end
+  let(:application) { test_api_client.applications.create(build_application) }
+  let(:directory) { test_api_client.directories.create(build_directory) }
   let(:password_grant_request) do
-    Stormpath::Oauth::PasswordGrantRequest.new('test@example.com', 'P@$$w0rd')
+    Stormpath::Oauth::PasswordGrantRequest.new("test#{default_domain}", 'P@$$w0rd')
   end
   let(:aquire_token) { application.authenticate_oauth(password_grant_request) }
 
   let(:access_token) { aquire_token.access_token }
   let(:bearer_authorization_header) { "Bearer #{access_token}" }
+  let(:authenticator) { Stormpath::Authentication::HttpBearerAuthentication }
   let(:authenticate_locally) do
-    Stormpath::Authentication::HttpBearerAuthentication.new(application,
-                                                            bearer_authorization_header,
-                                                            local: true).authenticate!
+    authenticator.new(application, bearer_authorization_header, local: true).authenticate!
   end
   let(:authenticate_remotely) do
-    Stormpath::Authentication::HttpBearerAuthentication.new(application,
-                                                            bearer_authorization_header).authenticate!
+    authenticator.new(application, bearer_authorization_header).authenticate!
   end
-  before do
-    test_api_client.account_store_mappings.create(application: application,
-                                                  account_store: directory,
-                                                  list_index: 1,
-                                                  is_default_account_store: true,
-                                                  is_default_group_store: true)
-    account
+  before { map_account_store(application, directory, 1, true, true) }
+  let!(:account) do
+    application.accounts.create(build_account(email: 'test', password: 'P@$$w0rd'))
   end
 
   after do
@@ -78,7 +64,8 @@ describe 'HttpBearerAuthentication', vcr: true do
   describe 'local authentication' do
     context 'with a valid bearer authorization header' do
       it 'should return account' do
-        expect(authenticate_locally).to be_kind_of(Stormpath::Oauth::LocalAccessTokenVerificationResult)
+        expect(authenticate_locally)
+          .to be_kind_of(Stormpath::Oauth::LocalAccessTokenVerificationResult)
         expect(authenticate_locally.account).to eq(account)
       end
     end

data/spec/client_spec.rb

@@ -33,7 +33,7 @@ describe Stormpath::Client, :vcr do
 
       context 'with an api key file location', 'that points to a file' do
         after do
-          File.delete(api_key_file_location) if File.exists?(api_key_file_location)
+          File.delete(api_key_file_location) if File.exist?(api_key_file_location)
         end
 
         context 'by default' do
@@ -59,10 +59,10 @@ properties
             File.join(File.dirname(__FILE__), 'testApiKey.fooId.properties')
           end
           let(:client) do
-            Stormpath::Client.new({
+            Stormpath::Client.new(
               api_key_file_location: api_key_file_location,
               api_key_id_property_name: 'foo.id'
-            })
+            )
           end
 
           before do
@@ -82,10 +82,10 @@ properties
             File.join(File.dirname(__FILE__), 'testApiKey.barBazSecret.properties')
           end
           let(:client) do
-            Stormpath::Client.new({
+            Stormpath::Client.new(
               api_key_file_location: api_key_file_location,
               api_key_secret_property_name: 'bar.baz'
-            })
+            )
           end
 
           before do
@@ -105,9 +105,9 @@ properties
             File.join(File.dirname(__FILE__), 'testApiKey.noApiKeyId.properties')
           end
           let(:client) do
-            Stormpath::Client.new({
+            Stormpath::Client.new(
               api_key_file_location: api_key_file_location,
-            })
+            )
           end
 
           before do
@@ -132,11 +132,7 @@ properties
           let(:api_key_file_location) do
             File.join(File.dirname(__FILE__), 'testApiKey.noApiKeySecret.properties')
           end
-          let(:client) do
-            Stormpath::Client.new({
-              api_key_file_location: api_key_file_location,
-            })
-          end
+          let(:client) { Stormpath::Client.new(api_key_file_location: api_key_file_location) }
 
           before do
             File.open(api_key_file_location, 'w') do |f|
@@ -147,11 +143,14 @@ properties
           end
 
           it 'raises an error' do
-            expect { client }.to raise_error ArgumentError,
-              "No API secret in properties. Please provide a 'apiKey.secret' property in '" +
-              api_key_file_location +
-              "' or pass in an 'api_key_secret_property_name' to the Stormpath::Client " +
-              "constructor to specify an alternative property."
+            expect { client }
+              .to raise_error(
+                ArgumentError,
+                "No API secret in properties. Please provide a 'apiKey.secret' property in '" +
+                api_key_file_location +
+                "' or pass in an 'api_key_secret_property_name' to the Stormpath::Client " \
+                'constructor to specify an alternative property.'
+              )
           end
         end
 
@@ -159,17 +158,15 @@ properties
           let(:api_key_file_location) do
             'no_such_file'
           end
-          let(:client) do
-            Stormpath::Client.new({
-              api_key_file_location: api_key_file_location,
-            })
-          end
+          let(:client) { Stormpath::Client.new(api_key_file_location: api_key_file_location) }
 
           it 'raises an error' do
-            expect { client }.to raise_error ArgumentError,
+            expect { client }.to raise_error(
+              ArgumentError,
               "No API Key file could be found or loaded from '" +
               api_key_file_location +
               "'."
+            )
           end
         end
       end
@@ -177,7 +174,9 @@ properties
       context 'with a base url' do
         context 'creates a client that connects to that base' do
           let(:api_key) { Stormpath::ApiKey.new(test_api_key_id, test_api_key_secret) }
-          let(:client) { Stormpath::Client.new(api_key: api_key, base_url: "https://api.stormpath.com/v1") }
+          let(:client) do
+            Stormpath::Client.new(api_key: api_key, base_url: 'https://api.stormpath.com/v1')
+          end
 
           it_behaves_like 'a valid client'
         end
@@ -193,11 +192,12 @@ properties
 
         context 'as a hash' do
           let(:client) do
-            Stormpath::Client.new({
-              api_key: { id: test_api_key_id,
-                         secret: test_api_key_secret
+            Stormpath::Client.new(
+              api_key: {
+                id: test_api_key_id,
+                secret: test_api_key_secret
               }
-            })
+            )
           end
 
           it_behaves_like 'a valid client'
@@ -206,24 +206,26 @@ properties
 
       context 'with no api key', 'and no api key file location' do
         it 'raises an error' do
-          expect { Stormpath::Client.new({}) }.to raise_error ArgumentError,
+          expect { Stormpath::Client.new({}) }.to raise_error(
+            ArgumentError,
             /^No API key has been provided\./
+          )
         end
       end
 
       context 'with cache configuration' do
         let(:api_key_file_location) { 'http://fake.server.com/apiKey.properties' }
         let(:client) do
-          Stormpath::Client.new( {
+          Stormpath::Client.new(
             api_key_file_location: api_key_file_location,
             cache: {
               store: Stormpath::Test::FakeStore1,
               regions: {
                 directories: { ttl_seconds: 40, tti_seconds: 20 },
-                groups:      { ttl_seconds: 80, tti_seconds: 40, store: Stormpath::Test::FakeStore2 }
+                groups: { ttl_seconds: 80, tti_seconds: 40, store: Stormpath::Test::FakeStore2 }
               }
             }
-          })
+          )
         end
 
         before do
@@ -271,16 +273,9 @@ properties
 
   describe '#applications' do
     context 'by default' do
-      let(:applications) do
-        test_api_client.applications
-      end
+      let(:applications) { test_api_client.applications }
 
-      let(:application) do
-        applications.create(
-          name: 'Client Applications Test',
-          description: 'A test description'
-        )
-      end
+      let(:application) { applications.create(build_application) }
 
       it 'returns the collection' do
         expect(applications).to be_kind_of(Stormpath::Resource::Collection)
@@ -295,7 +290,7 @@ properties
     context 'pagination' do
       let!(:applications) do
         (0..2).to_a.map do |index|
-          test_api_client.applications.create name: random_application_name(index), description: 'foo'
+          test_api_client.applications.create(build_application(name: "ruby-sdk-test-#{index}"))
         end
       end
 
@@ -304,58 +299,21 @@ properties
         expect(test_api_client.applications.offset(1).limit(2).count).to be >= 2
       end
 
-      after do
-        applications.each do |application|
-          application.delete
-        end
-      end
+      after { applications.each(&:delete) }
     end
 
     context 'expansion' do
-      let(:client) do
-        # every time a client is instantiated a new cache is created, so make
-        # sure we use the same client across each "it" block
-        test_api_client
-      end
-
-      let(:cache_manager) do
-        data_store = client.instance_variable_get '@data_store'
-        cache_manager = data_store.cache_manager
-      end
-
-      let(:accounts_cache_summary) do
-        cache_manager.get_cache('accounts').stats.summary
-      end
-
-      let(:directories_cache_summary) do
-        cache_manager.get_cache('directories').stats.summary
-      end
-
-      let(:groups_cache_summary) do
-        cache_manager.get_cache('groups').stats.summary
-      end
-
-      let(:directory) do
-        client.directories.create name: random_directory_name
-      end
-
-      let(:group) do
-        directory.groups.create name: random_group_name
-      end
-
-      let(:account) do
-        directory.accounts.create({
-          email: 'rubysdk@example.com',
-          given_name: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK',
-          username: 'rubysdk'
-        })
-      end
-
-      before do
-        group.add_account account
-      end
+      let(:client) { test_api_client }
+      let(:data_store) { client.instance_variable_get '@data_store' }
+      let(:cache_manager) { data_store.cache_manager }
+      let(:accounts_cache_summary) { cache_manager.get_cache('accounts').stats.summary }
+      let(:directories_cache_summary) { cache_manager.get_cache('directories').stats.summary }
+      let(:groups_cache_summary) { cache_manager.get_cache('groups').stats.summary }
+      let(:directory) { client.directories.create(build_directory) }
+      let(:group) { directory.groups.create(build_group) }
+      let(:account) { directory.accounts.create(build_account) }
+
+      before { group.add_account(account) }
 
       after do
         group.delete if group
@@ -368,9 +326,7 @@ properties
           client.accounts.get account.href, Stormpath::Resource::Expansion.new('directory')
         end
 
-        before do
-          client.data_store.initialize_cache(Hash.new)
-        end
+        before { client.data_store.initialize_cache({}) }
 
         it 'caches the nested resource' do
           expect(cached_account.directory.name).to be
@@ -382,14 +338,9 @@ properties
         let(:cached_account) do
           client.accounts.get account.href, Stormpath::Resource::Expansion.new('groups')
         end
+        let(:group) { directory.groups.create(build_group) }
 
-        let(:group) do
-          directory.groups.create name: random_group_name
-        end
-
-        before do
-          client.data_store.initialize_cache(Hash.new)
-        end
+        before { client.data_store.initialize_cache({}) }
 
         it 'caches the nested resource' do
           expect(cached_account.groups.first.name).to eq(group.name)
@@ -399,19 +350,16 @@ properties
     end
 
     context 'search' do
-      let(:first_application_name) { random_application_name(1) }
-      let(:second_application_name) { random_application_name(2) }
-
       let!(:applications) do
         [
-          test_api_client.applications.create(name: first_application_name, description: 'foo'),
-          test_api_client.applications.create(name: second_application_name, description: 'foo')
+          test_api_client.applications.create(build_application(name: 'rubytestapp1')),
+          test_api_client.applications.create(build_application(name: 'rubytestapp2'))
         ]
       end
 
       context 'by any attribute' do
         let(:search_results) do
-          test_api_client.applications.search(first_application_name)
+          test_api_client.applications.search('rubytestapp1')
         end
 
         it 'returns the application' do
@@ -421,7 +369,7 @@ properties
 
       context 'by an explicit attribute' do
         let(:search_results) do
-          test_api_client.applications.search(name: first_application_name)
+          test_api_client.applications.search(name: 'rubytestapp1')
         end
 
         it 'returns the application' do
@@ -429,15 +377,11 @@ properties
         end
       end
 
-      after do
-        applications.each do |application|
-          application.delete
-        end
-      end
+      after { applications.each(&:delete) }
     end
 
     describe '.create' do
-      let(:application_name) { random_application_name }
+      let(:application_name) { 'rubytestapp' }
 
       let(:application_attributes) do
         {
@@ -447,9 +391,7 @@ properties
       end
 
       context do
-        let(:application) do
-          test_api_client.applications.create application_attributes
-        end
+        let(:application) { test_api_client.applications.create application_attributes }
 
         it 'creates that application' do
           expect(application).to be
@@ -457,9 +399,7 @@ properties
           expect(application.description).to eq(application_attributes[:description])
         end
 
-        after do
-          application.delete
-        end
+        after { application.delete }
       end
 
       describe 'auto directory creation' do
@@ -471,22 +411,19 @@ properties
 
         context 'login source' do
           let(:options) { { createDirectory: true } }
-
           let!(:account) do
             application.accounts.create(
-                given_name: 'John',
-                surname: 'Smith 2',
-                email: 'john.smith2@example.com',
-                username: 'johnsmith2',
-                password: '4P@$$w0rd!'
+              build_account(username: 'johnsmith2', password: '4P@$$w0rd!')
             )
           end
+          let(:auth_request) do
+            Stormpath::Authentication::UsernamePasswordRequest.new 'johnsmith2', '4P@$$w0rd!'
+          end
+          let(:auth_result) { application.authenticate_account(auth_request) }
 
           before { application }
 
           it 'serves as the accounts store and login source' do
-            auth_request = Stormpath::Authentication::UsernamePasswordRequest.new 'johnsmith2', '4P@$$w0rd!'
-            auth_result = application.authenticate_account auth_request
             expect(account).to eq(auth_result.account)
           end
         end
@@ -502,7 +439,7 @@ properties
           context 'and existing directory' do
             it 'resolves naming conflict by adding (n) to directory name' do
               test_api_client.directories.each { |d| d.delete if "#{application_name} Directory" == d.name }
-              test_api_client.directories.create({name: "#{application_name} Directory"})
+              test_api_client.directories.create(name: "#{application_name} Directory")
               application
               expect(directories.map(&:name)).to include("#{application_name} Directory (2)")
             end
@@ -558,39 +495,24 @@ properties
 
   describe '#directories' do
     context 'given a collection' do
-      let(:directories) do
-        test_api_client.directories
-      end
-
-      let(:directory) do
-        directories.create(
-          name: 'Client Directories Test',
-          description: 'A test description'
-        )
-      end
+      let(:directories) { test_api_client.directories }
+      let(:directory) { directories.create(build_directory) }
 
       it 'returns the collection' do
         expect(directories).to be_kind_of(Stormpath::Resource::Collection)
         expect(directories.count).to be >= 1
       end
 
-      after do
-        directory.delete
-      end
+      after { directory.delete }
     end
 
     context 'given a collection with a limit' do
-      let!(:directory_1) do
-        test_api_client.directories.create name: random_directory_name(1)
-      end
-
-      let!(:directory_2) do
-        test_api_client.directories.create name: random_directory_name(2)
-      end
+      let!(:directory_1) { test_api_client.directories.create(build_directory) }
+      let!(:directory_2) { test_api_client.directories.create(build_directory) }
 
       after do
-        directory_1.delete if directory_1
-        directory_2.delete if directory_2
+        directory_1.delete
+        directory_2.delete
       end
 
       it 'should retrieve the number of directories described with the limit' do
@@ -599,46 +521,29 @@ properties
     end
 
     describe '.create' do
-
-      let(:directory_name) { random_directory_name }
-
-      let(:directory_attributes) do
-        {
-          name: directory_name,
-          description: 'A test description'
-        }
-      end
-
       let(:directory) do
-        test_api_client.directories.create directory_attributes
+        test_api_client.directories.create(build_directory(name: 'ruby', description: 'ruby'))
       end
 
       it 'creates that application' do
         expect(directory).to be
-        expect(directory.name).to eq(directory_attributes[:name])
-        expect(directory.description).to eq(directory_attributes[:description])
+        expect(directory.name).to eq('ruby')
+        expect(directory.description).to eq('ruby')
       end
 
-      after do
-        directory.delete
-      end
+      after { directory.delete }
     end
   end
 
   describe '#organization' do
     context 'search' do
-      let(:organization_name) { random_organization_name }
-
       let!(:organization) do
-        test_api_client.organizations.create(
-          name: organization_name,
-          name_key: "testorganization"
-        )
+        test_api_client.organizations.create(build_organization(name: 'ruby-org'))
       end
 
       context 'by any attribute' do
         let(:search_results) do
-          test_api_client.organizations.search(organization_name)
+          test_api_client.organizations.search('ruby-org')
         end
 
         it 'returns the application' do
@@ -647,9 +552,7 @@ properties
       end
 
       context 'by an explicit attribute' do
-        let(:search_results) do
-          test_api_client.organizations.search(name: organization_name)
-        end
+        let(:search_results) { test_api_client.organizations.search(name: 'ruby-org') }
 
         it 'returns the application' do
           expect(search_results.count).to eq 1
@@ -660,13 +563,7 @@ properties
     end
 
     context 'given a collection' do
-      let(:organization) do
-        test_api_client.organizations.create(
-            name: random_organization_name,
-            name_key: random_name_key,
-            description: 'A test description'
-        )
-      end
+      let(:organization) { test_api_client.organizations.create(build_organization) }
 
       it 'returns the collection' do
         expect(test_api_client.organizations).to be_kind_of(Stormpath::Resource::Collection)
@@ -677,13 +574,8 @@ properties
     end
 
     context 'given a collection with a limit' do
-      let!(:organization_1) do
-        test_api_client.organizations.create name: random_organization_name(1), name_key: random_name_key(1)
-      end
-
-      let!(:organization_2) do
-        test_api_client.organizations.create name: random_organization_name(2), name_key: random_name_key(2)
-      end
+      let!(:organization_1) { test_api_client.organizations.create(build_organization) }
+      let!(:organization_2) { test_api_client.organizations.create(build_organization) }
 
       after do
         organization_1.delete
@@ -696,54 +588,35 @@ properties
     end
 
     describe '.create' do
-      let(:organization_name) { random_organization_name }
-
-      let(:organization_attributes) do
-        {
-          name: organization_name,
-          name_key: random_name_key,
-          description: 'A test description'
-        }
-      end
-
       let(:organization) do
-        test_api_client.organizations.create organization_attributes
+        test_api_client.organizations.create(build_organization(name: 'ruby',
+                                                                name_key: 'ruby-org',
+                                                                description: 'ruby-org'))
       end
 
       it 'creates an organization' do
         expect(organization).to be
-        expect(organization.name).to eq(organization_attributes[:name])
-        expect(organization.name_key).to eq(organization_attributes[:name_key])
-        expect(organization.description).to eq(organization_attributes[:description])
+        expect(organization.name).to eq('ruby')
+        expect(organization.name_key).to eq('ruby-org')
+        expect(organization.description).to eq('ruby-org')
       end
 
-      after do
-        organization.delete
-      end
+      after { organization.delete }
     end
   end
 
-  describe "#organization_account_store_mappings" do
-    let(:organization) do
-      test_api_client.organizations.create name: 'test_organization',
-      name_key: "testorganization"
-    end
+  describe '#organization_account_store_mappings' do
+    let(:organization) { test_api_client.organizations.create(build_organization) }
+    let(:directory) { test_api_client.directories.create(build_directory) }
 
-    let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-    let(:organization_account_store_mappings) do
-      test_api_client.organization_account_store_mappings.create({
-        account_store: { href: directory.href },
-        organization: { href: organization.href }
-      })
-    end
+    let(:organization_account_store_mappings) { map_organization_store(directory, organization) }
 
     after do
-      organization.delete if organization
-      directory.delete if directory
+      organization.delete
+      directory.delete
     end
 
-    it "returns the mapping" do
+    it 'returns the mapping' do
       expect(organization_account_store_mappings.is_default_account_store).to eq(false)
       expect(organization_account_store_mappings.is_default_group_store).to eq(false)
       expect(organization_account_store_mappings.organization).to eq(organization)
@@ -754,30 +627,28 @@ properties
 
   describe '#accounts.verify_account_email' do
     context 'given a verfication token of an account' do
-      let(:directory) { test_directory_with_verification }
-
-      let(:account) do
-        account = Stormpath::Resource::Account.new({
-          email: random_email,
-          givenName: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK',
-          username: random_user_name
-        })
-        directory.create_account account
+      let(:application) { test_api_client.applications.create(build_application) }
+      let(:directory_with_verification) do
+        test_api_client.directories.create(build_directory(description: 'verification enabled'))
       end
 
-      let(:verification_token) do
-        account.email_verification_token.token
+      before do
+        map_account_store(application, directory_with_verification, 1, false, false)
+        enable_email_verification(directory_with_verification)
       end
 
-      let(:verified_account) do
-        test_api_client.accounts.verify_email_token verification_token
+      after do
+        application.delete
+        account.delete
+        directory_with_verification.delete
       end
 
-      after do
-        account.delete if account
+      let(:account) do
+        directory_with_verification.create_account(Stormpath::Resource::Account.new(build_account))
       end
+      let(:verification_token) { account.email_verification_token.token }
+
+      let(:verified_account) { test_api_client.accounts.verify_email_token verification_token }
 
       it 'returns the account' do
         expect(verified_account).to be
@@ -799,28 +670,15 @@ properties
     end
 
     before do
-      test_api_client.account_store_mappings.create(
-        application: application,
-        account_store: directory1,
-        list_index: 1,
-        is_default_account_store: true,
-        is_default_group_store: false
-      )
-
-      test_api_client.account_store_mappings.create(
-        application: application,
-        account_store: directory2,
-        list_index: 2,
-        is_default_account_store: false,
-        is_default_group_store: false
-      )
+      map_account_store(application, directory1, 1, true, false)
+      map_account_store(application, directory2, 2, false, false)
     end
 
     let!(:account1) do
-      directory1.accounts.create(build_account(email: 'jekyll@example.com', username: 'account1'))
+      directory1.accounts.create(build_account(email: 'jekyll', username: 'jekyll'))
     end
     let!(:account2) do
-      directory2.accounts.create(build_account(email: 'hyde@example.com', username: 'account2'))
+      directory2.accounts.create(build_account(email: 'hyde', username: 'hyde'))
     end
 
     let(:link_accounts) do