stormpath-sdk 1.3.0 → 1.3.1

data/spec/oauth/access_token_authentication_result_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
 describe Stormpath::Oauth::AccessTokenAuthenticationResult, :vcr do
-  let(:account_data) { build_account(email: email, password: password) }
-
-  let(:email) { random_email }
-
-  let(:password) { 'P@$$w0rd' }
-
-  let(:account) { test_application.accounts.create(account_data) }
-
-  let(:password_grant_request) { Stormpath::Oauth::PasswordGrantRequest.new(email, password) }
-
-  let(:jwt_authentication_result) do
-    test_application.authenticate_oauth(password_grant_request)
+  let(:application) { test_api_client.applications.create(build_application) }
+  let(:directory) { test_api_client.directories.create(build_directory) }
+  before { map_account_store(application, directory, 1, true, false) }
+  let!(:account) do
+    application.accounts.create(build_account(email: 'ruby25', password: 'P@$$w0rd'))
+  end
+  let(:password_grant_request) do
+    Stormpath::Oauth::PasswordGrantRequest.new("ruby25#{default_domain}", 'P@$$w0rd')
   end
+  let(:jwt_authentication_result) { application.authenticate_oauth(password_grant_request) }
 
-  before { account }
-  after { account.delete }
+  after do
+    application.delete
+    directory.delete
+    account.delete
+  end
 
   it 'instances should expose a method to get an account' do
     expect(jwt_authentication_result.account).to eq(account)

data/spec/provider/provider_spec.rb

@@ -1,22 +1,12 @@
 require 'spec_helper'
 
 describe Stormpath::Provider::Provider, :vcr do
-
-  let(:application) do
-    test_api_client.applications.create name: random_application_name,
-                                        description: 'Test Provider Application for AccountStoreMappings'
-  end
-
-  let(:account_store_mapping) do
-    test_api_client.account_store_mappings.create application: application, account_store: directory
-  end
-
-  let(:directory) do
-    test_api_client.directories.create directory_hash
-  end
+  let(:application) { test_api_client.applications.create(build_application) }
+  let(:account_store_mapping) { map_account_store(application, directory, 0, false, false) }
+  let(:directory) { test_api_client.directories.create(directory_hash) }
 
   let(:directory_hash) do
-    Hash.new.tap do |hash|
+    {}.tap do |hash|
       hash[:name] = name
       hash[:description] = description
       hash[:provider] = provider_info if defined? provider_info
@@ -35,7 +25,7 @@ describe Stormpath::Provider::Provider, :vcr do
   shared_examples 'a provider directory' do
     it { should be_kind_of Stormpath::Provider::Provider }
 
-    it "assign provider directory to an application" do
+    it 'assign provider directory to an application' do
       expect(application.account_store_mappings.count).to eq(0)
       expect(account_store_mapping.application).to eq(application)
       expect(account_store_mapping.account_store).to eq(directory)
@@ -46,17 +36,17 @@ describe Stormpath::Provider::Provider, :vcr do
       expect(provider.provider_id).to eq(provider_id)
       expect(provider.created_at).to be
       expect(provider.modified_at).to be
-      expect(provider.href).to eq(directory.href + "/provider")
+      expect(provider.href).to eq(directory.href + '/provider')
 
       provider_clazz = "Stormpath::Provider::#{provider_id.capitalize}Provider".constantize
       expect(provider).to be_instance_of(provider_clazz)
 
-      if provider_id == "google" || provider_id == "facebook"
+      if provider_id == 'google' || provider_id == 'facebook'
         expect(provider.client_id).to eq(client_id)
         expect(provider.client_secret).to eq(client_secret)
       end
 
-      if provider_id == "google"
+      if provider_id == 'google'
         expect(provider.redirect_uri).to eq(redirect_uri)
       end
     end
@@ -66,15 +56,17 @@ describe Stormpath::Provider::Provider, :vcr do
     it 'should be able to store provider accounts' do
       account_store_mapping
 
-      access_token = "xyz"
+      access_token = 'xyz'
       request = Stormpath::Provider::AccountRequest.new(provider_id, :access_token, access_token)
 
-      stub_request(:post, application.href + "/accounts").to_return(body: Stormpath::Test.mocked_account(provider_id), status: 201)
+      stub_request(:post, application.href + '/accounts')
+        .to_return(body: Stormpath::Test.mocked_account(provider_id), status: 201)
       result = application.get_provider_account(request)
       expect(result.is_new_account?).to be
       expect(result.account).to be_kind_of(Stormpath::Resource::Account)
 
-      stub_request(:get, result.account.href + "/providerData").to_return(body: Stormpath::Test.mocked_provider_data(provider_id))
+      stub_request(:get, result.account.href + '/providerData')
+        .to_return(body: Stormpath::Test.mocked_provider_data(provider_id))
 
       expect(result.account.provider_data).to be_kind_of(Stormpath::Provider::ProviderData)
       provider_data_clazz = "Stormpath::Provider::#{provider_id.capitalize}ProviderData".constantize
@@ -89,27 +81,22 @@ describe Stormpath::Provider::Provider, :vcr do
         expect(result.account.provider_data.refresh_token).to be
       end
 
-      stub_request(:post, application.href + "/accounts").to_return(body: Stormpath::Test.mocked_account(provider_id), status: 200)
+      stub_request(:post, application.href + '/accounts')
+        .to_return(body: Stormpath::Test.mocked_account(provider_id), status: 200)
       new_result = application.get_provider_account(request)
       expect(new_result.is_new_account).not_to be
     end
   end
 
   describe 'create stormpath directory with empty provider credentials' do
-    let(:name) { random_directory_name('Stormpath') }
+    let(:name) { 'Stormpath' }
     let(:description) { 'Directory for testing Stormpath directories.' }
-    let(:provider_id) { "stormpath" }
+    let(:provider_id) { 'stormpath' }
 
     it_behaves_like 'a provider directory'
 
     it 'should be able to retrieve provider data from a regular account' do
-      account = directory.accounts.create({
-        given_name: 'John',
-        surname: 'Smith',
-        email: 'john.smith@example.com',
-        username: 'johnsmith',
-        password: '4P@$$w0rd!'
-      })
+      account = directory.accounts.create(build_account)
 
       expect(account.provider_data).to be_kind_of(Stormpath::Provider::ProviderData)
       expect(account.provider_data.provider_id).to eq(provider_id)
@@ -120,10 +107,10 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create facebook directory with provider credentials' do
-    let(:name) { random_directory_name('Facebook') }
+    let(:name) { 'Facebook' }
     let(:description) { 'Directory for testing Facebook directories.' }
 
-    let(:provider_id) { "facebook" }
+    let(:provider_id) { 'facebook' }
     let(:client_id) { 'FACEBOOK_APP_ID' }
     let(:client_secret) { 'FACEBOOK_APP_SECRET' }
     let(:provider_info) do
@@ -135,15 +122,20 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create google directory with provider credentials' do
-    let(:name) { random_directory_name('Google') }
+    let(:name) { 'Google' }
     let(:description) { 'Directory for testing Google directories.' }
 
-    let(:provider_id) { "google" }
+    let(:provider_id) { 'google' }
     let(:client_id) { 'GOOGLE_CLIENT_ID' }
     let(:client_secret) { 'GOOGLE_CLIENT_SECRET' }
     let(:redirect_uri) { 'GOOGLE_REDIRECT_URI' }
     let(:provider_info) do
-      { provider_id: provider_id, client_id: client_id, client_secret: client_secret, redirect_uri: redirect_uri }
+      {
+        provider_id: provider_id,
+        client_id: client_id,
+        client_secret: client_secret,
+        redirect_uri: redirect_uri
+      }
     end
 
     it_behaves_like 'a provider directory'
@@ -151,10 +143,10 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create linkedin directory with provider credentials' do
-    let(:name) { random_directory_name('Linkedin') }
+    let(:name) { 'Linkedin' }
     let(:description) { 'Directory for testing Linkedin directories.' }
 
-    let(:provider_id) { "linkedin" }
+    let(:provider_id) { 'linkedin' }
     let(:client_id) { 'LINKEDIN_APP_ID' }
     let(:client_secret) { 'LINKEDIN_APP_SECRET' }
     let(:provider_info) do
@@ -166,10 +158,10 @@ describe Stormpath::Provider::Provider, :vcr do
   end
 
   describe 'create github directory with provider credentials' do
-    let(:name) { random_directory_name('Github') }
+    let(:name) { 'Github' }
     let(:description) { 'Directory for testing Github directories.' }
 
-    let(:provider_id) { "github" }
+    let(:provider_id) { 'github' }
     let(:client_id) { 'GITHUB_APP_ID' }
     let(:client_secret) { 'GITHUB_APP_SECRET' }
     let(:provider_info) do

data/spec/resource/account_creation_policy_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Stormpath::Resource::AccountCreationPolicy, :vcr do
   describe 'instances should respond to attribute property methods' do
-    let(:application) { test_application }
-    let(:directory) { test_api_client.directories.create(name: random_directory_name) }
+    let(:application) { test_api_client.applications.create(build_application) }
+    let(:directory) { test_api_client.directories.create(build_directory) }
     let(:account_creation_policy) { directory.account_creation_policy }
     let(:create_valid_account) do
       directory.accounts.create(
@@ -24,17 +24,12 @@ describe Stormpath::Resource::AccountCreationPolicy, :vcr do
       )
     end
 
-    before do
-      test_api_client.account_store_mappings.create(
-        application: application,
-        account_store: directory,
-        list_index: 1,
-        is_default_account_store: false,
-        is_default_group_store: false
-      )
-    end
+    before { map_account_store(application, directory, 1, false, false) }
 
-    after { directory.delete }
+    after do
+      application.delete
+      directory.delete
+    end
 
     it do
       expect(account_creation_policy).to be_a Stormpath::Resource::AccountCreationPolicy
@@ -155,7 +150,7 @@ describe Stormpath::Resource::AccountCreationPolicy, :vcr do
             account_creation_policy.save
 
             expect do
-              @account = directory.accounts.create(
+              directory.accounts.create(
                 username: 'cilim',
                 email: 'cilim@spam.com',
                 given_name: 'Marko',

data/spec/resource/account_link_spec.rb

@@ -12,28 +12,15 @@ describe Stormpath::Resource::AccountLink, :vcr do
   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!(:account_link) do

data/spec/resource/account_spec.rb

@@ -1,42 +1,36 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::Account, :vcr do
-
-  describe "instances should respond to attribute property methods" do
-    let(:directory) { test_api_client.directories.create name: random_directory_name }
-    let(:given_name) { 'Ruby SDK' }
-    let(:middle_name) { 'Gruby' }
-    let(:surname) { 'SDK' }
+  describe 'instances should respond to attribute property methods' do
+    let(:directory) { test_api_client.directories.create(build_directory) }
     let(:account) do
-      directory.accounts.create email: 'test@example.com',
-          given_name: given_name,
-          password: 'P@$$w0rd',
-          middle_name: middle_name,
-          surname: surname,
-          username: 'rubysdk'
+      directory.accounts.create(build_account(email: 'ruby',
+                                              given_name: 'ruby',
+                                              surname: 'ruby',
+                                              middle_name: 'ruby'))
     end
 
     after do
-      account.delete if account
-      directory.delete if directory
+      account.delete
+      directory.delete
     end
 
     it do
       [:given_name, :username, :middle_name, :surname, :email, :status].each do |property_accessor|
         expect(account).to respond_to(property_accessor)
         expect(account).to respond_to("#{property_accessor}=")
-        expect(account.send property_accessor).to be_a String
+        expect(account.send(property_accessor)).to be_a String
       end
 
       [:created_at, :modified_at, :password_modified_at].each do |property_getter|
         expect(account).to respond_to(property_getter)
-        expect(account.send property_getter).to be_a String
+        expect(account.send(property_getter)).to be_a String
       end
 
       expect(account).to respond_to(:full_name)
       expect(account.full_name).to be_a String
-      expect(account.full_name).to eq("#{given_name} #{middle_name} #{surname}")
-      expect(account).to respond_to("password=")
+      expect(account.full_name).to eq('ruby ruby ruby')
+      expect(account).to respond_to('password=')
 
       expect(account.tenant).to be_a Stormpath::Resource::Tenant
       expect(account.directory).to be_a Stormpath::Resource::Directory
@@ -49,22 +43,10 @@ describe Stormpath::Resource::Account, :vcr do
   end
 
   describe 'account_associations' do
-    let(:app) { test_api_client.applications.create name: random_application_name, description: 'Dummy desc.' }
-    let(:application) { test_api_client.applications.get app.href }
-    let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-    before do
-      test_api_client.account_store_mappings.create({ application: app, account_store: directory,
-        list_index: 1, is_default_account_store: true, is_default_group_store: true })
-    end
-
-    let(:account) do
-      directory.accounts.create email: 'test@example.com',
-          givenName: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK',
-          username: 'rubysdk'
-    end
+    let(:application) { test_api_client.applications.create(build_application) }
+    let(:directory) { test_api_client.directories.create(build_directory) }
+    let(:account) { directory.accounts.create(build_account) }
+    before { map_account_store(application, directory, 1, true, true) }
 
     it 'should belong_to directory' do
       expect(account.directory).to eq(directory)
@@ -80,32 +62,15 @@ describe Stormpath::Resource::Account, :vcr do
     end
 
     describe 'linked accounts' do
-      let(:directory2) { test_api_client.directories.create name: 'ruby sdk dir 2' }
+      let(:directory2) { test_api_client.directories.create(build_directory) }
       before do
-        test_api_client.account_store_mappings.create(
-          application: app,
-          account_store: directory2,
-          list_index: 2,
-          is_default_account_store: false,
-          is_default_group_store: false
-        )
+        map_account_store(application, directory2, 2, false, false)
         account
       end
 
-      after do
-        directory2.delete
-      end
-
-      let!(:account2) do
-        directory2.accounts.create(
-          email: 'test2@example.com',
-          givenName: 'Ruby SDK',
-          password: 'P@$$w0rd',
-          surname: 'SDK',
-          username: 'rubysdk2'
-        )
-      end
+      after { directory2.delete }
 
+      let!(:account2) { directory2.accounts.create(build_account) }
       let!(:link_accounts) do
         test_api_client.account_links.create(
           left_account: {
@@ -130,20 +95,17 @@ describe Stormpath::Resource::Account, :vcr do
     end
   end
 
-  describe "#add_or_remove_group" do
-    context "given a group" do
-      let(:directory) { test_api_client.directories.create name: random_directory_name }
-
-      let(:group) { directory.groups.create name: 'testGroup' }
-
-      let(:account) { directory.accounts.create({ email: 'rubysdk@example.com', given_name: 'Ruby SDK', password: 'P@$$w0rd', surname: 'SDK' }) }
-
-      before { account.add_group group }
+  describe '#add_or_remove_group' do
+    context 'given a group' do
+      let(:directory) { test_api_client.directories.create(build_directory) }
+      let(:group) { directory.groups.create(build_group) }
+      let(:account) { directory.accounts.create(build_account) }
+      before { account.add_group(group) }
 
       after do
-        account.delete if account
-        group.delete if group
-        directory.delete if directory
+        account.delete
+        group.delete
+        directory.delete
       end
 
       it 'adds the group to the account' do
@@ -161,31 +123,26 @@ describe Stormpath::Resource::Account, :vcr do
 
         expect(account.groups).not_to include(group)
       end
-
     end
   end
 
   describe '#save' do
     context 'when property values have changed' do
-      let(:account) do
-        test_directory.accounts.create build_account
-      end
-      let(:account_uri) do
-        account.href
-      end
-      let(:new_surname) do
-        "NewSurname"
-      end
-      let(:reloaded_account) { test_api_client.accounts.get account_uri }
+      let(:directory) { test_api_client.directories.create(build_directory) }
+      let(:account) { directory.accounts.create(build_account) }
+      let(:account_uri) { account.href }
+      let(:new_surname) { 'NewSurname' }
+      let(:reloaded_account) { test_api_client.accounts.get(account_uri) }
 
       before do
-        account = test_api_client.accounts.get account_uri
+        account = test_api_client.accounts.get(account_uri)
         account.surname = new_surname
         account.save
       end
 
       after do
-        account.delete if account
+        account.delete
+        directory.delete
       end
 
       it 'saves changes to the account' do
@@ -193,5 +150,4 @@ describe Stormpath::Resource::Account, :vcr do
       end
     end
   end
-
 end