stormpath-sdk 1.1.5 → 1.2.0

data/spec/auth/http_bearer_authentication_spec.rb

@@ -0,0 +1,86 @@
+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(:password_grant_request) do
+    Stormpath::Oauth::PasswordGrantRequest.new('test@example.com', '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(:authenticate_locally) do
+    Stormpath::Authentication::HttpBearerAuthentication.new(application,
+                                                            bearer_authorization_header,
+                                                            local: true).authenticate!
+  end
+  let(:authenticate_remotely) do
+    Stormpath::Authentication::HttpBearerAuthentication.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
+  end
+
+  after do
+    account.delete
+    directory.delete
+    application.delete
+  end
+
+  describe 'remote authentication' do
+    context 'with a valid bearer authorization header' do
+      it 'should return VerifyTokenResult' do
+        expect(authenticate_remotely).to be_kind_of(Stormpath::Oauth::VerifyTokenResult)
+        expect(authenticate_remotely.account).to eq(account)
+      end
+
+      it 'should contain the account' do
+        expect(authenticate_remotely.account).to eq(account)
+      end
+    end
+
+    context 'with no bearer authorization header' do
+      let(:bearer_authorization_header) { nil }
+
+      it 'should raise error' do
+        expect do
+          authenticate_remotely
+        end.to raise_error(Stormpath::Error)
+      end
+    end
+
+    context 'with invalid authorization header type' do
+      let(:bearer_authorization_header) { "Basic #{access_token}" }
+
+      it 'should raise error' do
+        expect do
+          authenticate_remotely
+        end.to raise_error(Stormpath::Error)
+      end
+    end
+  end
+
+  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.account).to eq(account)
+      end
+    end
+  end
+end

data/spec/data_store_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
-describe Stormpath::DataStore do
+shared_examples 'a data store' do
   let(:factory)           { Stormpath::Test::ResourceFactory.new }
   let(:request_executor)  { Stormpath::Test::TestRequestExecutor.new }
-  let(:store)             { Stormpath::Cache::RedisStore }
-  let(:data_store)        { Stormpath::DataStore.new request_executor, test_api_key, {store: store}, nil, nil }
+  let(:data_store) do
+    Stormpath::DataStore.new(request_executor, test_api_key, { store: store }, nil)
+  end
   let(:application_cache) { data_store.cache_manager.get_cache 'applications' }
   let(:tenant_cache)      { data_store.cache_manager.get_cache 'tenants' }
   let(:group_cache)       { data_store.cache_manager.get_cache 'groups' }
@@ -16,12 +17,13 @@ describe Stormpath::DataStore do
 
   describe '.region_for' do
     it 'pulls resource name from href' do
-      region = data_store.send :region_for, default_base_url+"/directories/4NykYrYH0OBiOOVOg8LXQ5"
+      region = data_store.send :region_for, "#{default_base_url}/directories/4NykYrYH0OBiOOVOg8LXQ5"
       expect(region).to eq('directories')
     end
 
     it 'pulls resource name from href if its custom data also' do
-      region = data_store.send :region_for, default_base_url+"/v1/accounts/7jWpcEVSgawKkAZp8XDIEw/customData"
+      region = data_store.send(:region_for,
+                               "#{default_base_url}/v1/accounts/7jWpcEVSgawKkAZp8XDIEw/customData")
       expect(region).to eq('customData')
     end
   end
@@ -30,13 +32,19 @@ describe Stormpath::DataStore do
     let(:custom_data_delete_field_url_regex) { data_store.send :custom_data_delete_field_url_regex }
     context 'CUSTOM_DATA_DELETE_FIELD_REGEX' do
       it 'should match custom data field href' do
-        expect(default_base_url+"/accounts/2f8U7r5JweVf1ZTtcJ08L8/customData/rank").to match(custom_data_delete_field_url_regex)
-        expect(default_base_url+"/groups/4x6vwucf1w9wjHvt7paGoY/customData/rank").to match(custom_data_delete_field_url_regex)
+        expect("#{default_base_url}/accounts/2f8U7r5JweVf1ZTtcJ08L8/customData/rank")
+          .to match(custom_data_delete_field_url_regex)
+
+        expect("#{default_base_url}/groups/4x6vwucf1w9wjHvt7paGoY/customData/rank")
+          .to match(custom_data_delete_field_url_regex)
       end
 
       it 'should not match custom data resource href' do
-        expect(default_base_url+"/accounts/2f8U7r5JweVf1ZTtcJ08L8/customData").not_to match(custom_data_delete_field_url_regex)
-        expect(default_base_url+"/groups/4x6vwucf1w9wjHvt7paGoY/customData").not_to match(custom_data_delete_field_url_regex)
+        expect("#{default_base_url}/accounts/2f8U7r5JweVf1ZTtcJ08L8/customData")
+          .not_to match(custom_data_delete_field_url_regex)
+
+        expect("#{default_base_url}/groups/4x6vwucf1w9wjHvt7paGoY/customData")
+          .not_to match(custom_data_delete_field_url_regex)
       end
     end
   end
@@ -79,7 +87,7 @@ describe Stormpath::DataStore do
       end
 
       it 'misses the cache on the get' do
-        expect(application_cache.stats.hits).to eq(1)  # this hit is when we grab @cached
+        expect(application_cache.stats.hits).to eq(1) # this hit is when we grab @cached
         expect(application_cache.stats.misses).to eq(1)
       end
 
@@ -146,24 +154,40 @@ describe Stormpath::DataStore do
         expect(group_cache.size).to eq(4)
       end
     end
-
   end
 
   context '#apply_default_user_agent' do
     let(:request) do
-      Stormpath::Http::Request.new 'get', 'http://example.com/resources/abc123', nil, Hash.new, nil, test_api_key
+      Stormpath::Http::Request.new('get',
+                                   'http://example.com/resources/abc123',
+                                   nil,
+                                   {},
+                                   nil,
+                                   test_api_key)
     end
 
     before do
-      allow(Gem::Platform.local).to receive(:os) { "darwin" } 
-      allow(Gem::Platform.local).to receive(:version) { "14" } 
+      allow(Gem::Platform.local).to receive(:os) { 'darwin' }
+      allow(Gem::Platform.local).to receive(:version) { '14' }
 
       data_store.send(:apply_default_user_agent, request)
     end
 
     it 'adds User-Agent to header' do
-      expect(request.http_headers["User-Agent"]).to include("darwin")
-      expect(request.http_headers["User-Agent"]).to include("14")
+      expect(request.http_headers['User-Agent']).to include('darwin')
+      expect(request.http_headers['User-Agent']).to include('14')
     end
   end
 end
+
+describe Stormpath::DataStore do
+  context 'redis store' do
+    let(:store) { Stormpath::Cache::RedisStore }
+    it_should_behave_like 'a data store'
+  end
+
+  context 'memcached store' do
+    let(:store) { Stormpath::Cache::MemcachedStore }
+    it_should_behave_like 'a data store'
+  end
+end

data/spec/oauth/access_token_authentication_result_spec.rb

@@ -22,6 +22,10 @@ describe Stormpath::Oauth::AccessTokenAuthenticationResult, :vcr do
     expect(jwt_authentication_result.account).to eq(account)
   end
 
+  it 'jwt access token should contain the stt header' do
+    expect(jwt_authentication_result.access_token).to have_stt_in_header('access')
+  end
+
   it 'should be able to delete the access token' do
     jwt_authentication_result
 
@@ -36,6 +40,10 @@ describe Stormpath::Oauth::AccessTokenAuthenticationResult, :vcr do
     expect(account.access_tokens.count).to eq(0)
   end
 
+  it 'jwt refresh token should contain the stt header' do
+    expect(jwt_authentication_result.refresh_token).to have_stt_in_header('refresh')
+  end
+
   it 'should be able to delete the refresh token' do
     jwt_authentication_result
 

data/spec/resource/account_creation_policy_spec.rb

@@ -1,10 +1,28 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::AccountCreationPolicy, :vcr do
-  describe "instances should respond to attribute property methods" 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(:account_creation_policy) { directory.account_creation_policy }
+    let(:create_valid_account) do
+      directory.accounts.create(
+        username: 'cilim',
+        email: 'cilim@infinum.co',
+        given_name: 'Marko',
+        surname: 'Cilimkovic',
+        password: 'wonderfulWeatherIsntIt2'
+      )
+    end
+    let(:create_invalid_account) do
+      directory.accounts.create(
+        username: 'cilim',
+        email: 'cilim@infinum.hr',
+        given_name: 'Marko',
+        surname: 'Cilimkovic',
+        password: 'wonderfulWeatherIsntIt2'
+      )
+    end
 
     before do
       test_api_client.account_store_mappings.create(
@@ -23,7 +41,9 @@ describe Stormpath::Resource::AccountCreationPolicy, :vcr do
 
       [:welcome_email_status,
        :verification_email_status,
-       :verification_success_email_status].each do |property_accessor|
+       :verification_success_email_status,
+       :email_domain_whitelist,
+       :email_domain_blacklist].each do |property_accessor|
         expect(account_creation_policy).to respond_to(property_accessor)
         expect(account_creation_policy).to respond_to("#{property_accessor}=")
       end
@@ -57,5 +77,108 @@ describe Stormpath::Resource::AccountCreationPolicy, :vcr do
       account_creation_policy.save
       expect(directory.account_creation_policy.verification_success_email_status).to eq('ENABLED')
     end
+
+    it 'can change whitelisted email domains' do
+      whitelisted = ['*infinum.co', '*infinum.hr']
+      account_creation_policy.email_domain_whitelist = whitelisted
+      account_creation_policy.save
+      expect(directory.account_creation_policy.email_domain_whitelist).to eq whitelisted
+
+      account_creation_policy.email_domain_whitelist = ['*infinum.hr']
+      account_creation_policy.save
+      expect(directory.account_creation_policy.email_domain_whitelist).to include '*infinum.hr'
+      expect(directory.account_creation_policy.email_domain_whitelist).not_to include '*infinum.co'
+    end
+
+    it 'can change blacklisted email domains' do
+      blacklisted = ['*spam.com', '*e1ppe.ro']
+      account_creation_policy.email_domain_blacklist = blacklisted
+      account_creation_policy.save
+      expect(directory.account_creation_policy.email_domain_blacklist).to eq blacklisted
+
+      account_creation_policy.email_domain_blacklist = ['*spam.com']
+      account_creation_policy.save
+      expect(directory.account_creation_policy.email_domain_blacklist).to include '*spam.com'
+      expect(directory.account_creation_policy.email_domain_blacklist).not_to include '*e1ppe.ro'
+    end
+
+    context 'when domain not string' do
+      it 'should raise error' do
+        blacklisted = ['*spam.com', 12345]
+        account_creation_policy.email_domain_blacklist = blacklisted
+        expect do
+          account_creation_policy.save
+        end.to raise_error(Stormpath::Error, /is an invalid type./)
+      end
+    end
+
+    context 'when domain invalid' do
+      it 'should raise error' do
+        blacklisted = ['*spam.com', '*youre@jiberish']
+        account_creation_policy.email_domain_blacklist = blacklisted
+        expect do
+          account_creation_policy.save
+        end.to raise_error(Stormpath::Error, /It is not a valid domain./)
+      end
+    end
+
+    describe 'create account' do
+      context 'when whitelisted domains exist' do
+        before do
+          whitelisted = ['*infinum.co']
+          account_creation_policy.email_domain_whitelist = whitelisted
+          account_creation_policy.save
+        end
+
+        context 'when account whitelisted' do
+          it 'should successfully create the account' do
+            account = create_valid_account
+            expect(account).to be_a Stormpath::Resource::Account
+            expect(account.username).to eq('cilim')
+          end
+        end
+
+        context 'when account not whitelisted' do
+          it 'should raise error' do
+            expect do
+              create_invalid_account
+            end.to raise_error(Stormpath::Error, "Cannot create the Account because your email's domain is not allowed.")
+          end
+        end
+      end
+
+      context 'when blacklisted domains exist' do
+        context 'when account email blacklisted' do
+          it 'should not create the account' do
+            blacklisted = ['*spam.com']
+            account_creation_policy.email_domain_blacklist = blacklisted
+            account_creation_policy.save
+
+            expect do
+              @account = directory.accounts.create(
+                username: 'cilim',
+                email: 'cilim@spam.com',
+                given_name: 'Marko',
+                surname: 'Cilimkovic',
+                password: 'wonderfulWeatherIsntIt2'
+              )
+            end.to raise_error(Stormpath::Error, "Cannot create the Account because your email's domain is not allowed.")
+          end
+        end
+      end
+
+      context 'when account email in blacklisted and whitelisted domains' do
+        it 'should not create the account' do
+          bothlisted = ['*infinum.hr']
+          account_creation_policy.email_domain_blacklist = bothlisted
+          account_creation_policy.email_domain_whitelist = bothlisted
+          account_creation_policy.save
+
+          expect do
+            create_invalid_account
+          end.to raise_error(Stormpath::Error, "Cannot create the Account because your email's domain is not allowed.")
+        end
+      end
+    end
   end
 end

data/spec/resource/account_store_spec.rb

@@ -1,49 +1,76 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::AccountStore, :vcr do
-
-  def create_account_store_mapping(application, account_store, is_default_group_store=false)
-    test_api_client.account_store_mappings.create({
+  def create_account_store_mapping(application, account_store, is_default_group_store = false)
+    test_api_client.account_store_mappings.create(
       application: application,
       account_store: account_store,
       list_index: 0,
       is_default_account_store: true,
       is_default_group_store: is_default_group_store
-     })
+    )
+  end
+
+  let(:application) do
+    test_api_client.applications.create name: random_application_name,
+                                        description: 'testApplication for AccountStoreMappings'
   end
 
-  let(:application) { test_api_client.applications.create name: random_application_name, description: 'testApplication for AccountStoreMappings' }
+  let(:directory) do
+    test_api_client.directories.create name: random_directory_name,
+                                       description: 'testDirectory for AccountStoreMappings'
+  end
 
-  let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'testDirectory for AccountStoreMappings' }
+  let(:group) do
+    directory.groups.create name: 'testGroup', description: 'testGroup for AccountStoreMappings'
+  end
 
-  let(:group) { directory.groups.create name: 'testGroup', description: 'testGroup for AccountStoreMappings' }
+  let(:organization) do
+    test_api_client.organizations.create name: 'testOrganization', name_key: 'test-organization'
+  end
 
   after do
     application.delete if application
     group.delete if group
     directory.delete if directory
+    organization.delete if organization
   end
 
   describe 'given an account_store_mapping and a directory' do
-    let!(:account_store_mapping) {create_account_store_mapping(application,directory,true)}
-    let(:reloaded_mapping){ application.account_store_mappings.get account_store_mapping.href }
+    let!(:account_store_mapping) { create_account_store_mapping(application, directory, true) }
+    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)
       expect(reloaded_mapping.account_store).to eq(directory)
     end
-
   end
 
-    describe 'given an account_store_mapping and a group' do
-    let!(:account_store_mapping) {create_account_store_mapping(application,group)}
-    let(:reloaded_mapping){ application.account_store_mappings.get account_store_mapping.href }
+  describe 'given an account_store_mapping and a group' do
+    let!(:account_store_mapping) { create_account_store_mapping(application, group) }
+    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)
       expect(reloaded_mapping.account_store).to eq(group)
     end
+  end
+
+  describe 'given an account_store_mapping and an organization' do
+    let!(:account_store_mapping) { create_account_store_mapping(application, organization) }
+    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)
+      expect(reloaded_mapping.account_store).to eq(organization)
+    end
   end
 
+  describe 'given an undefined account_store_mapping' do
+    it 'should raise an error' do
+      expect do
+        create_account_store_mapping(application, 'undefined')
+      end.to raise_error
+    end
+  end
 end