stormpath-sdk 1.3.1 → 1.4.0

data/spec/auth/http_basic_authentication_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe 'HttpBasicAuthentication', vcr: true do
-  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(:application) { test_api_client.applications.create(application_attrs) }
+  let(:directory) { test_api_client.directories.create(directory_attrs) }
+  let(:account) { application.accounts.create(account_attrs) }
   let(:api_key) { account.api_keys.create({}) }
   let(:api_key_id) { api_key.id }
   let(:api_key_secret) { api_key.secret }

data/spec/auth/http_bearer_authentication_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe 'HttpBearerAuthentication', vcr: true do
-  let(:application) { test_api_client.applications.create(build_application) }
-  let(:directory) { test_api_client.directories.create(build_directory) }
+  let(:application) { test_api_client.applications.create(application_attrs) }
+  let(:directory) { test_api_client.directories.create(directory_attrs) }
   let(:password_grant_request) do
     Stormpath::Oauth::PasswordGrantRequest.new("test#{default_domain}", 'P@$$w0rd')
   end
@@ -19,7 +19,7 @@ describe 'HttpBearerAuthentication', vcr: true do
   end
   before { map_account_store(application, directory, 1, true, true) }
   let!(:account) do
-    application.accounts.create(build_account(email: 'test', password: 'P@$$w0rd'))
+    application.accounts.create(account_attrs(email: 'test', password: 'P@$$w0rd'))
   end
 
   after do

data/spec/client_spec.rb

@@ -275,7 +275,7 @@ properties
     context 'by default' do
       let(:applications) { test_api_client.applications }
 
-      let(:application) { applications.create(build_application) }
+      let(:application) { applications.create(application_attrs) }
 
       it 'returns the collection' do
         expect(applications).to be_kind_of(Stormpath::Resource::Collection)
@@ -290,7 +290,7 @@ properties
     context 'pagination' do
       let!(:applications) do
         (0..2).to_a.map do |index|
-          test_api_client.applications.create(build_application(name: "ruby-sdk-test-#{index}"))
+          test_api_client.applications.create(application_attrs(name: "ruby-sdk-test-#{index}"))
         end
       end
 
@@ -309,9 +309,9 @@ properties
       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) }
+      let(:directory) { client.directories.create(directory_attrs) }
+      let(:group) { directory.groups.create(group_attrs) }
+      let(:account) { directory.accounts.create(account_attrs) }
 
       before { group.add_account(account) }
 
@@ -338,7 +338,7 @@ 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) { directory.groups.create(group_attrs) }
 
         before { client.data_store.initialize_cache({}) }
 
@@ -352,8 +352,8 @@ properties
     context 'search' do
       let!(:applications) do
         [
-          test_api_client.applications.create(build_application(name: 'rubytestapp1')),
-          test_api_client.applications.create(build_application(name: 'rubytestapp2'))
+          test_api_client.applications.create(application_attrs(name: 'rubytestapp1')),
+          test_api_client.applications.create(application_attrs(name: 'rubytestapp2'))
         ]
       end
 
@@ -413,7 +413,7 @@ properties
           let(:options) { { createDirectory: true } }
           let!(:account) do
             application.accounts.create(
-              build_account(username: 'johnsmith2', password: '4P@$$w0rd!')
+              account_attrs(username: 'johnsmith2', password: '4P@$$w0rd!')
             )
           end
           let(:auth_request) do
@@ -496,7 +496,7 @@ properties
   describe '#directories' do
     context 'given a collection' do
       let(:directories) { test_api_client.directories }
-      let(:directory) { directories.create(build_directory) }
+      let(:directory) { directories.create(directory_attrs) }
 
       it 'returns the collection' do
         expect(directories).to be_kind_of(Stormpath::Resource::Collection)
@@ -507,8 +507,8 @@ properties
     end
 
     context 'given a collection with a limit' do
-      let!(:directory_1) { test_api_client.directories.create(build_directory) }
-      let!(:directory_2) { test_api_client.directories.create(build_directory) }
+      let!(:directory_1) { test_api_client.directories.create(directory_attrs) }
+      let!(:directory_2) { test_api_client.directories.create(directory_attrs) }
 
       after do
         directory_1.delete
@@ -522,7 +522,7 @@ properties
 
     describe '.create' do
       let(:directory) do
-        test_api_client.directories.create(build_directory(name: 'ruby', description: 'ruby'))
+        test_api_client.directories.create(directory_attrs(name: 'ruby', description: 'ruby'))
       end
 
       it 'creates that application' do
@@ -538,7 +538,7 @@ properties
   describe '#organization' do
     context 'search' do
       let!(:organization) do
-        test_api_client.organizations.create(build_organization(name: 'ruby-org'))
+        test_api_client.organizations.create(organization_attrs(name: 'ruby-org'))
       end
 
       context 'by any attribute' do
@@ -563,7 +563,7 @@ properties
     end
 
     context 'given a collection' do
-      let(:organization) { test_api_client.organizations.create(build_organization) }
+      let(:organization) { test_api_client.organizations.create(organization_attrs) }
 
       it 'returns the collection' do
         expect(test_api_client.organizations).to be_kind_of(Stormpath::Resource::Collection)
@@ -574,8 +574,8 @@ properties
     end
 
     context 'given a collection with a limit' do
-      let!(:organization_1) { test_api_client.organizations.create(build_organization) }
-      let!(:organization_2) { test_api_client.organizations.create(build_organization) }
+      let!(:organization_1) { test_api_client.organizations.create(organization_attrs) }
+      let!(:organization_2) { test_api_client.organizations.create(organization_attrs) }
 
       after do
         organization_1.delete
@@ -589,7 +589,7 @@ properties
 
     describe '.create' do
       let(:organization) do
-        test_api_client.organizations.create(build_organization(name: 'ruby',
+        test_api_client.organizations.create(organization_attrs(name: 'ruby',
                                                                 name_key: 'ruby-org',
                                                                 description: 'ruby-org'))
       end
@@ -606,8 +606,8 @@ properties
   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(:organization) { test_api_client.organizations.create(organization_attrs) }
+    let(:directory) { test_api_client.directories.create(directory_attrs) }
 
     let(:organization_account_store_mappings) { map_organization_store(directory, organization) }
 
@@ -627,9 +627,9 @@ properties
 
   describe '#accounts.verify_account_email' do
     context 'given a verfication token of an account' do
-      let(:application) { test_api_client.applications.create(build_application) }
+      let(:application) { test_api_client.applications.create(application_attrs) }
       let(:directory_with_verification) do
-        test_api_client.directories.create(build_directory(description: 'verification enabled'))
+        test_api_client.directories.create(directory_attrs(description: 'verification enabled'))
       end
 
       before do
@@ -644,7 +644,7 @@ properties
       end
 
       let(:account) do
-        directory_with_verification.create_account(Stormpath::Resource::Account.new(build_account))
+        directory_with_verification.create_account(Stormpath::Resource::Account.new(account_attrs))
       end
       let(:verification_token) { account.email_verification_token.token }
 
@@ -675,10 +675,10 @@ properties
     end
 
     let!(:account1) do
-      directory1.accounts.create(build_account(email: 'jekyll', username: 'jekyll'))
+      directory1.accounts.create(account_attrs(email: 'jekyll', username: 'jekyll'))
     end
     let!(:account2) do
-      directory2.accounts.create(build_account(email: 'hyde', username: 'hyde'))
+      directory2.accounts.create(account_attrs(email: 'hyde', username: 'hyde'))
     end
 
     let(:link_accounts) do

data/spec/oauth/access_token_authentication_result_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe Stormpath::Oauth::AccessTokenAuthenticationResult, :vcr do
-  let(:application) { test_api_client.applications.create(build_application) }
-  let(:directory) { test_api_client.directories.create(build_directory) }
+  let(:application) { test_api_client.applications.create(application_attrs) }
+  let(:directory) { test_api_client.directories.create(directory_attrs) }
   before { map_account_store(application, directory, 1, true, false) }
   let!(:account) do
-    application.accounts.create(build_account(email: 'ruby25', password: 'P@$$w0rd'))
+    application.accounts.create(account_attrs(email: 'ruby25', password: 'P@$$w0rd'))
   end
   let(:password_grant_request) do
     Stormpath::Oauth::PasswordGrantRequest.new("ruby25#{default_domain}", 'P@$$w0rd')

data/spec/provider/provider_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Stormpath::Provider::Provider, :vcr do
-  let(:application) { test_api_client.applications.create(build_application) }
+  let(:application) { test_api_client.applications.create(application_attrs) }
   let(:account_store_mapping) { map_account_store(application, directory, 0, false, false) }
   let(:directory) { test_api_client.directories.create(directory_hash) }
 
@@ -96,7 +96,7 @@ describe Stormpath::Provider::Provider, :vcr do
     it_behaves_like 'a provider directory'
 
     it 'should be able to retrieve provider data from a regular account' do
-      account = directory.accounts.create(build_account)
+      account = directory.accounts.create(account_attrs)
 
       expect(account.provider_data).to be_kind_of(Stormpath::Provider::ProviderData)
       expect(account.provider_data.provider_id).to eq(provider_id)

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_api_client.applications.create(build_application) }
-    let(:directory) { test_api_client.directories.create(build_directory) }
+    let(:application) { test_api_client.applications.create(application_attrs) }
+    let(:directory) { test_api_client.directories.create(directory_attrs) }
     let(:account_creation_policy) { directory.account_creation_policy }
     let(:create_valid_account) do
       directory.accounts.create(

data/spec/resource/account_link_spec.rb

@@ -17,10 +17,10 @@ describe Stormpath::Resource::AccountLink, :vcr do
   end
 
   let!(:account1) do
-    directory1.accounts.create(build_account(email: 'jekyll', username: 'jekyll'))
+    directory1.accounts.create(account_attrs(email: 'jekyll', username: 'jekyll'))
   end
   let!(:account2) do
-    directory2.accounts.create(build_account(email: 'hyde', username: 'hyde'))
+    directory2.accounts.create(account_attrs(email: 'hyde', username: 'hyde'))
   end
 
   let!(:account_link) do

data/spec/resource/account_spec.rb

@@ -2,9 +2,9 @@ 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(build_directory) }
+    let(:directory) { test_api_client.directories.create(directory_attrs) }
     let(:account) do
-      directory.accounts.create(build_account(email: 'ruby',
+      directory.accounts.create(account_attrs(email: 'ruby',
                                               given_name: 'ruby',
                                               surname: 'ruby',
                                               middle_name: 'ruby'))
@@ -39,13 +39,15 @@ describe Stormpath::Resource::Account, :vcr do
       expect(account.groups).to be_a Stormpath::Resource::Collection
       expect(account.group_memberships).to be_a Stormpath::Resource::Collection
       expect(account.applications).to be_a Stormpath::Resource::Collection
+      expect(account.phones).to be_a Stormpath::Resource::Collection
+      expect(account.factors).to be_a Stormpath::Resource::Collection
     end
   end
 
   describe 'account_associations' do
-    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) }
+    let(:application) { test_api_client.applications.create(application_attrs) }
+    let(:directory) { test_api_client.directories.create(directory_attrs) }
+    let(:account) { directory.accounts.create(account_attrs) }
     before { map_account_store(application, directory, 1, true, true) }
 
     it 'should belong_to directory' do
@@ -62,7 +64,7 @@ describe Stormpath::Resource::Account, :vcr do
     end
 
     describe 'linked accounts' do
-      let(:directory2) { test_api_client.directories.create(build_directory) }
+      let(:directory2) { test_api_client.directories.create(directory_attrs) }
       before do
         map_account_store(application, directory2, 2, false, false)
         account
@@ -70,7 +72,7 @@ describe Stormpath::Resource::Account, :vcr do
 
       after { directory2.delete }
 
-      let!(:account2) { directory2.accounts.create(build_account) }
+      let!(:account2) { directory2.accounts.create(account_attrs) }
       let!(:link_accounts) do
         test_api_client.account_links.create(
           left_account: {
@@ -97,9 +99,9 @@ describe Stormpath::Resource::Account, :vcr do
 
   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) }
+      let(:directory) { test_api_client.directories.create(directory_attrs) }
+      let(:group) { directory.groups.create(group_attrs) }
+      let(:account) { directory.accounts.create(account_attrs) }
       before { account.add_group(group) }
 
       after do
@@ -126,10 +128,192 @@ describe Stormpath::Resource::Account, :vcr do
     end
   end
 
+  describe 'managing phones' do
+    let(:application) { test_api_client.applications.create(application_attrs) }
+    let(:directory) { test_api_client.directories.create(directory_attrs) }
+
+    before do
+      map_account_store(application, directory, 1, true, true)
+      phone
+    end
+
+    let(:account) { directory.accounts.create(account_attrs) }
+    let(:phone) do
+      account.phones.create(
+        number: '+12025550173',
+        name: 'test phone',
+        description: 'this is a testing phone number'
+      )
+    end
+
+    it 'can fetch phones' do
+      expect(account.phones).to include(phone)
+    end
+
+    it 'can fetch a specific phone' do
+      expect(account.phones.get(phone.href)).to be_a Stormpath::Resource::Phone
+    end
+
+    it 'raises error if phone with same number created' do
+      expect do
+        account.phones.create(
+          number: '+12025550173',
+          name: 'test duplicate phone'
+        )
+      end.to raise_error(Stormpath::Error, 'An existing phone with that number already exists for this Account.')
+    end
+
+    after do
+      application.delete if application
+      directory.delete if directory
+      account.delete if account
+    end
+  end
+
+  describe 'managing factors' do
+    let(:application) { test_api_client.applications.create(application_attrs) }
+    let(:directory) { test_api_client.directories.create(directory_attrs) }
+
+    before { map_account_store(application, directory, 1, true, true) }
+
+    let(:account) { directory.accounts.create(account_attrs) }
+
+    context 'sms type' do
+      let!(:factor) do
+        account.factors.create(
+          type: 'SMS',
+          phone: {
+            number: '+12025550173',
+            name: 'test phone',
+            description: 'this is a testing phone number'
+          }
+        )
+      end
+
+      it 'can fetch factors' do
+        expect(account.factors).to include(factor)
+      end
+
+      it 'can fetch a specific factor' do
+        expect(account.factors.get(factor.href)).to be_a Stormpath::Resource::Factor
+      end
+
+      it 'creates a phone with a factor' do
+        expect(account.phones.count).to eq 1
+      end
+    end
+
+    context 'google-authenticator type' do
+      let!(:factor) do
+        account.factors.create(
+          type: 'google-authenticator',
+          account_name: "marko.cilimkovic#{default_domain}",
+          issuer: 'ACME',
+          status: 'ENABLED'
+        )
+      end
+
+      it 'can fetch factors' do
+        expect(account.factors).to include(factor)
+      end
+    end
+
+    after do
+      directory.delete if directory
+      application.delete if application
+    end
+  end
+
+  describe '#create_factor' do
+    let(:application) { test_api_client.applications.create(application_attrs) }
+    let(:directory) { test_api_client.directories.create(directory_attrs) }
+    let(:account) { directory.accounts.create(account_attrs) }
+    before { map_account_store(application, directory, 1, true, true) }
+
+    context 'type sms' do
+      before do
+        stub_request(:post, "#{account.href}/factors?challenge=true")
+          .to_return(body: Stormpath::Test.mocked_factor_response)
+      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: ' })
+      end
+
+      it 'factor should be created' do
+        expect(factor).to be_kind_of Stormpath::Resource::Factor
+      end
+    end
+
+    context 'type google-authenticator' do
+      let(:factor) do
+        account.create_factor(:google_authenticator, options)
+      end
+
+      context 'with account_name' do
+        let(:account_name) { "marko.cilimkovic#{default_domain}" }
+        let(:options) do
+          {
+            custom_options: {
+              account_name: account_name,
+              issuer: 'ACME',
+              status: 'ENABLED'
+            }
+          }
+        end
+
+        it 'should create factor with custom account_name' do
+          expect(factor.account_name).to eq account_name
+        end
+      end
+
+      context 'with account_name not set' do
+        let(:options) do
+          {
+            custom_options: {
+              issuer: 'ACME',
+              status: 'ENABLED'
+            }
+          }
+        end
+
+        it 'should create factor with account_name set to username' do
+          expect(factor.account_name).to eq account.username
+        end
+      end
+
+      context 'without custom options' do
+        let(:options) { {} }
+        it 'should create factor with account_name set to username' do
+          expect(factor.account_name).to eq account.username
+        end
+      end
+    end
+
+    context 'with bad type set' do
+      let(:factor) do
+        account.create_factor(:invalid_type)
+      end
+
+      it 'should raise error' do
+        expect { factor }.to raise_error(Stormpath::Error)
+      end
+    end
+
+    after do
+      directory.delete if directory
+      application.delete if application
+    end
+  end
+
   describe '#save' do
     context 'when property values have changed' do
-      let(:directory) { test_api_client.directories.create(build_directory) }
-      let(:account) { directory.accounts.create(build_account) }
+      let(:directory) { test_api_client.directories.create(directory_attrs) }
+      let(:account) { directory.accounts.create(account_attrs) }
       let(:account_uri) { account.href }
       let(:new_surname) { 'NewSurname' }
       let(:reloaded_account) { test_api_client.accounts.get(account_uri) }