stormpath-sdk 1.0.0.beta.5 → 1.0.0.beta.6

data/spec/data_store_spec.rb

@@ -8,6 +8,7 @@ describe Stormpath::DataStore do
   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' }
+  let(:default_base_url) { Stormpath::DataStore::DEFAULT_BASE_URL }
 
   after do
     application_cache.clear
@@ -15,16 +16,31 @@ describe Stormpath::DataStore do
 
   describe '.region_for' do
     it 'pulls resource name from href' do
-      region = data_store.send :region_for, 'https://api.stormpath.com/v1/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, 'https://api.stormpath.com/v1/accounts/7jWpcEVSgawKkAZp8XDIEw/customData'
+      region = data_store.send :region_for, default_base_url+"/v1/accounts/7jWpcEVSgawKkAZp8XDIEw/customData"
       expect(region).to eq('customData')
     end
   end
 
+  describe 'custom data regex matchers' 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)
+      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)
+      end
+    end
+  end
+
   describe '#delete' do
     before do
       resource = factory.resource 'application', 1, %w(tenant groups)

data/spec/resource/account_spec.rb

@@ -34,7 +34,7 @@ describe Stormpath::Resource::Account, :vcr do
     its(:tenant) { should be_instance_of Stormpath::Resource::Tenant }
     its(:directory) { should be_instance_of Stormpath::Resource::Directory } 
     its(:custom_data) { should be_instance_of Stormpath::Resource::CustomData }
-    its(:email_verification_token) { should be_instance_of Stormpath::Resource::EmailVerificationToken }
+    its(:email_verification_token) { should be_nil }
 
     its(:groups) { should be_instance_of Stormpath::Resource::Collection }
     its(:group_memberships) { should be_instance_of Stormpath::Resource::Collection }

data/spec/resource/account_store_mapping_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe Stormpath::Resource::AccountStoreMapping, :vcr do
   
-  def create_account_store_mapping(application, account_store, is_default_group_store=false)
+  def create_account_store_mapping(application, account_store, options={})
     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
+      list_index: options[:list_index] || 0,
+      is_default_account_store: options[:is_default_account_store] || false,
+      is_default_group_store: options[:is_default_group_store] || false
      })
   end
 
@@ -22,7 +22,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   end
     
   describe "instances" do
-    subject(:account_store_mapping) {create_account_store_mapping(application,directory)}
+    subject(:account_store_mapping) {create_account_store_mapping(application,directory, is_default_account_store: true)}
    
     [:list_index, :is_default_account_store, :is_default_group_store, :default_account_store, :default_group_store ].each do |prop_accessor|
       it { should respond_to prop_accessor }
@@ -48,15 +48,71 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
 
 
   describe 'given an application' do
-    let!(:account_store_mapping) {create_account_store_mapping(application,directory,true)}
     let(:reloaded_application) { test_api_client.applications.get application.href}
-    it 'should retrive a default account store mapping' do
+
+    context 'on application creation' do
+      it 'there should be no default account/group store' do
+        expect(application.default_account_store_mapping).to eq(nil)
+        expect(application.default_group_store_mapping).to eq(nil)
+      end
+    end
+
+    it 'should retrive a default account store mapping one is created' do
+      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true, is_default_group_store: true)
+      expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
+    end
+
+    it 'should retrive a default group store mapping when one is created' do
+      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true, is_default_group_store: true)
+      expect(reloaded_application.default_group_store_mapping).to eq(account_store_mapping)
+    end
+
+    it 'change the default account store mapping, the application needs to be reloaded' do
+      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true)
+      expect(application.default_account_store_mapping).to eq(nil)
       expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
     end
 
-    it 'should retrive a default group store mapping' do
+    it 'change the default group store mapping, the application needs to be reloaded' do
+      account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true, is_default_group_store: true)
+      expect(application.default_group_store_mapping).to eq(nil)
       expect(reloaded_application.default_group_store_mapping).to eq(account_store_mapping)
     end
+
+    context 'remove the added default account/group store mapping' do
+      let(:re_reloaded_application) { test_api_client.applications.get application.href}
+
+      it 'there should not be a default account store mapping in the beginning and the end' do
+        expect(application.default_account_store_mapping).to eq(nil)
+        account_store_mapping = create_account_store_mapping(application,directory, is_default_account_store: true)
+
+        expect(application.default_account_store_mapping).to eq(nil)
+        expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
+
+        account_store_mapping.is_default_account_store = false
+        account_store_mapping.save
+
+        expect(application.default_account_store_mapping).to eq(nil)
+        expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
+        expect(re_reloaded_application.default_account_store_mapping).to eq(nil)
+      end
+
+      it 'there should not be a default group store mapping in the beginning and the end' do
+        expect(application.default_account_store_mapping).to eq(nil)
+        account_store_mapping = create_account_store_mapping(application,directory, is_default_group_store: true)
+
+        expect(application.default_group_store_mapping).to eq(nil)
+        expect(reloaded_application.default_group_store_mapping).to eq(account_store_mapping)
+
+        account_store_mapping.is_default_group_store = false
+        account_store_mapping.save
+
+        expect(application.default_group_store_mapping).to eq(nil)
+        expect(reloaded_application.default_group_store_mapping).to eq(account_store_mapping)
+        expect(re_reloaded_application.default_group_store_mapping).to eq(nil)
+      end
+    end
+
   end
 
   describe "given a directory" do
@@ -69,17 +125,32 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
 
   describe "given a group" do
     let(:group) { directory.groups.create name: 'testGroup', description: 'testGroup for AccountStoreMappings' }
+    let(:reloaded_application) { test_api_client.applications.get application.href }
 
-    before { create_account_store_mapping(application, group) }
-    after { group.delete if group }
+    after do
+      group.delete if group
+    end
+
+    context 'add an account store mapping' do
+      it 'being a default account store' do
+        account_store_mapping = create_account_store_mapping(application, group, is_default_account_store: true)
+        expect(application.default_account_store_mapping).to eq(nil)
+        expect(application.account_store_mappings.count).to eq(1)
+        expect(reloaded_application.default_account_store_mapping).to eq(account_store_mapping)
+      end
+
+      it 'being a default group store, should raise an error' do
+        expect do
+          create_account_store_mapping(application, group, is_default_group_store: true)
+        end.to raise_error Stormpath::Error
+      end
 
-    it 'add an account store mapping' do
-      expect(application.account_store_mappings.count).to eq(1)
     end
+
   end
 
   describe "update attribute default_group_store" do
-    let(:account_store_mapping) { create_account_store_mapping(application, directory) }
+    let(:account_store_mapping) { create_account_store_mapping(application, directory, is_default_account_store: true) }
     let(:reloaded_mapping){ application.account_store_mappings.get account_store_mapping.href }
 
     it 'should go from true to false' do
@@ -92,7 +163,7 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   end
 
   describe "given a mapping" do
-    let!(:account_store_mapping) { create_account_store_mapping(application, directory) }
+    let!(:account_store_mapping) { create_account_store_mapping(application, directory, is_default_account_store: true) }
     let(:reloaded_application) { test_api_client.applications.get application.href}
 
     it 'function delete should destroy it' do

data/spec/resource/collection_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Stormpath::Resource::Collection do
+describe Stormpath::Resource::Collection, :vcr do
   let(:href) do
     'http://example.com'
   end
@@ -166,4 +166,204 @@ describe Stormpath::Resource::Collection do
       end
     end
   end
+
+  context 'live examples' do
+    context 'testing limits and offsets' do
+      let(:directory) {test_api_client.directories.create name: "Directory for pagination testing"}
+
+      let(:groups) do
+        ('A'..'Z').map do |letter|
+          directory.groups.create name: "#{letter}. pagination testing group "
+        end
+      end
+
+      after do
+        directory.delete
+      end
+
+      it 'should respond as expected with or without limits' do
+        expect(groups).to have(26).items
+
+        expect(directory.groups.limit(3)).to have(26).items
+
+        expect(directory.groups.offset(10).limit(3)).to have(16).items
+
+        expect(directory.groups.limit(3).offset(10)).to have(16).items
+
+        expect(directory.groups).to have(26).items
+
+        expect(directory.groups.limit(25)).to have(26).items
+
+        expect(directory.groups.limit(26)).to have(26).items
+
+        expect(directory.groups.limit(100)).to have(26).items
+
+        expect(directory.groups.limit(25)).to include(groups.last)
+
+        expect(directory.groups.offset(1).limit(25)).to include(groups.last)
+
+        expect(directory.groups.offset(1).limit(25)).not_to include(groups.first)
+
+        expect(directory.groups.offset(25)).to have(1).items
+
+        expect(directory.groups.offset(26)).to have(0).items
+      end
+    end
+
+    context 'testing limits and offsets with name checking' do
+      let(:directory) {test_api_client.directories.create name: "Directory for pagination testing"}
+
+      let!(:groups) do
+        ('1'..'100').map do |number|
+          directory.groups.create name: number
+        end
+      end
+
+      after do
+        directory.delete
+      end
+
+      it 'should paginate properly' do
+        expect(directory.groups).to have(100).items
+
+        expect(directory.groups.map {|group| group.name }).to eq(('1'..'100').to_a.sort)
+
+        expect(directory.groups.limit(30)).to have(100).items
+
+        expect(directory.groups.limit(30).current_page.items).to have(30).items
+
+        expect(directory.groups.limit(30).offset(30)).to have(70).items
+
+        expect(directory.groups.limit(30).offset(30).current_page.items).to have(30).items
+
+        expect(directory.groups.limit(30).offset(60)).to have(40).items
+
+        expect(directory.groups.limit(30).offset(60).current_page.items).to have(30).items
+
+        expect(directory.groups.limit(30).offset(90)).to have(10).items
+
+        expect(directory.groups.limit(30).offset(90).current_page.items).to have(10).items
+
+        expect(directory.groups.limit(30).map {|group| group.name }).to eq(('1'..'100').to_a.sort)
+
+        expect(directory.groups.limit(30).current_page.items.map {|group| group.name }).to eq(('1'..'100').to_a.sort.first(30))
+
+        expect(directory.groups.limit(30).offset(30).map {|group| group.name }).to eq(('1'..'100').to_a.sort.drop(30))
+
+        expect(directory.groups.limit(30).offset(30).current_page.items.map {|group| group.name }).to eq(('1'..'100').to_a.sort.drop(30).first(30))
+
+        expect(directory.groups.limit(30).offset(60).map {|group| group.name }).to eq(('1'..'100').to_a.sort.drop(60))
+
+        expect(directory.groups.limit(30).offset(60).current_page.items.map {|group| group.name }).to eq(('1'..'100').to_a.sort.drop(60).first(30))
+
+        expect(directory.groups.limit(30).offset(90).map {|group| group.name }).to eq(('1'..'100').to_a.sort.drop(90))
+
+        expect(directory.groups.limit(30).offset(90).current_page.items.map {|group| group.name }).to eq(('1'..'100').to_a.sort.drop(90).first(30))
+
+        expect(directory.groups.limit(30).offset(90).current_page.items.map {|group| group.name }).to eq(('1'..'100').to_a.sort.drop(90).first(10))
+
+        group_count = 0
+        directory.groups.each do |group|
+          group_count += 1
+          expect(('1'..'100').to_a).to include(group.name)
+        end
+
+        expect(group_count).to eq(100)
+      end
+    end
+
+    context '#wild characters search' do
+      let(:directory) {test_api_client.directories.create name: "Test directory"}
+
+      # !@#$%^&*()_-+=?><:]}[{'
+      # 'jlpicard/!@$%^*()_-+&=?><:]}[{'
+      let(:username) { 'jlpicard/!@$%^ *()_-+=?><:]}[{' }
+
+      let!(:account) do
+        directory.accounts.create username: username,
+           email: "capt@enterprise.com",
+           givenName: "Jean-Luc",
+           surname: "Picard",
+           password: "hakunaMatata179Enterprise"
+      end
+
+      after do
+        directory.delete
+      end
+
+      it 'should search accounts by username' do
+        expect(directory.accounts.search(username: username)).to have(1).items
+      end
+
+      it 'should search accounts by any column (aiming at username)' do
+        expect(directory.accounts.search(username)).to have(1).items
+      end
+
+      it 'should search accounts by email' do
+        expect(directory.accounts.search(email: "capt@enterprise.com")).to have(1).items
+      end
+
+      it 'should search accounts by any column (aiming at email)' do
+        expect(directory.accounts.search("capt@enterprise.com")).to have(1).items
+      end
+    end
+
+    context '#asterisk search on one attribute' do
+      let(:directory) {test_api_client.directories.create name: "Test directory"}
+
+      let!(:account) do
+        directory.accounts.create username: "jlpicard",
+           email: "capt@enterprise.com",
+           givenName: "Jean-Luc",
+           surname: "Picard",
+           password: "hakunaMatata179Enterprise"
+      end
+
+      after do
+        directory.delete
+      end
+
+      it 'should search accounts by username with asterisk at the beginning' do
+        expect(directory.accounts.search(username: "*card")).to have(1).items
+      end
+
+      it 'should search accounts by username with asterisk at the end' do
+        expect(directory.accounts.search(username: "jl*")).to have(1).items
+      end
+
+      it 'should search accounts by username with asterisk at the beginning and the end' do
+        expect(directory.accounts.search(username: "*pic*")).to have(1).items
+      end
+    end
+
+    context '#asterisk search on multiple attribute' do
+      let(:directory) {test_api_client.directories.create name: "Test directory"}
+
+      let!(:account) do
+        directory.accounts.create username: "jlpicard",
+           email: "capt@enterprise.com",
+           givenName: "Jean-Luc",
+           surname: "Picard",
+           password: "hakunaMatata179Enterprise"
+      end
+
+      after do
+        directory.delete
+      end
+
+      it 'should search accounts by username with asterisk at the beginning' do
+        expect(directory.accounts.search(username: "*card", email: "*enterprise.com")).to have(1).items
+      end
+
+      it 'should search accounts by username with asterisk at the end' do
+        expect(directory.accounts.search(username: "jl*", email: "capt*")).to have(1).items
+      end
+
+      it 'should search accounts by username with asterisk at the beginning and the end' do
+        expect(directory.accounts.search(username: "*pic*", email: "*enterprise*")).to have(1).items
+      end
+    end
+
+  end
+
 end

data/spec/resource/custom_data_spec.rb

@@ -1,198 +1,25 @@
- # test_api_client.accounts.get "https://api.stormpath.com/v1/accounts/1SmmWv659tY9Eeb4qKZqr0"
 require 'spec_helper'
 
 describe Stormpath::Resource::CustomData, :vcr do
-
-  RESERVED_FIELDS = %w( created_at modified_at meta sp_meta spmeta ion_meta ionmeta )
-
-  describe "#for accounts" do
-    let(:directory) { test_api_client.directories.create name: 'test_directory' }
-
-    let(:account) do
-      directory.accounts.create username: "jlpicard",
-         email: "capt@enterprise.com",
-         givenName: "Jean-Luc",
-         surname: "Picard",
-         password: "uGhd%a8Kl!"
-    end
-
-    let(:reloaded_account) { test_api_client.accounts.get account.href }
-
-    after do
-      account.delete if account
-      directory.delete if directory
-    end
-    
-    it 'read reserved data' do
-      expect(account.custom_data["href"]).not_to eq(nil)
-      expect(account.custom_data["created_at"]).not_to eq(nil)
-      expect(account.custom_data["modified_at"]).not_to eq(nil)
-    end
-
-    RESERVED_FIELDS.each do |reserved_field|
-      it "set reserved data #{reserved_field} should raise error" do
-        account.custom_data[reserved_field] = 12
-        expect{ account.custom_data.save }.to raise_error
-      end
-    end
-
-    it 'set custom data' do
-      account.custom_data[:rank] = "Captain"
-      expect(account.custom_data[:rank]).to eq("Captain")
-      account.custom_data.save
-      expect(reloaded_account.custom_data[:rank]).to eq("Captain")
-    end
-
-    it 'set nested custom data' do
-      account.custom_data[:special_rank] = "Captain"
-      account.custom_data[:permissions] = {"crew_quarters" => "93-601"}
-      expect(account.custom_data[:permissions]).to eq({"crew_quarters" => "93-601"})
-      account.custom_data.save
-      expect(reloaded_account.custom_data[:special_rank]).to eq("Captain")
-      expect(reloaded_account.custom_data[:permissions]).to eq({"crew_quarters" => "93-601"})
-    end
-
-    it 'not raise errors when saving a empty properties array' do
-      account.custom_data.save
-    end
-
-    it 'trigger custom data saving on account.save' do
-      account.custom_data[:rank] = "Captain"
-      account.surname = "Picard!"
-      account.save
-      expect(reloaded_account.surname).to eq("Picard!")
-      expect(reloaded_account.custom_data[:rank]).to eq("Captain")
-    end
-
-    it 'delete all custom data' do
-      account.custom_data[:rank] = "Captain"
-      account.custom_data.save
-      expect(account.custom_data[:rank]).to eq("Captain")
-      account.custom_data.delete
-      expect(reloaded_account.custom_data[:rank]).to eq(nil)
-    end
-
-    it 'delete a specific custom data field' do
-      account.custom_data[:rank] = "Captain"
-      account.custom_data["favorite_drink"] = "Earl Grey Tea"
-      account.custom_data.save
-      
-      account.custom_data.delete(:rank)
-      account.custom_data.save
-
-      expect(reloaded_account.custom_data[:rank]).to eq(nil)
-      expect(reloaded_account.custom_data["favorite_drink"]).to eq("Earl Grey Tea")
-    end
-
-    context 'should respond to' do
-      it '#has_key?' do
-        expect(account.custom_data.has_key? "created_at").to be_true
-      end
-
-      it '#include?' do
-        expect(account.custom_data.include? "created_at").to be_true
-      end
-
-      it '#has_value?' do
-        account.custom_data[:rank] = "Captain"
-        account.custom_data.save
-        expect(reloaded_account.custom_data.has_value? "Captain").to be_true
-      end
-
-      it '#store' do
-        account.custom_data.store(:rank, "Captain")
-        account.custom_data.save
-        expect(reloaded_account.custom_data[:rank]).to eq("Captain")
-      end
-
-      it '#keys' do
-        expect(account.custom_data.keys).to be_kind_of(Array)
-        expect(account.custom_data.keys).to have_at_least(3).items
-        expect(account.custom_data.keys.map {|key| key.to_s.camelize :lower}).to eq(account.custom_data.properties.keys)
-      end
-
-      it '#values' do
-        account.custom_data[:permissions] = {"crew_quarters" => "93-601"}
-        account.custom_data.save
-        expect(reloaded_account.custom_data.values).to include({"crew_quarters" => "93-601"})
-        expect(reloaded_account.custom_data.values).to eq(reloaded_account.custom_data.properties.values)
-      end
-    end
-
+  after do
+    directory.delete if directory
   end
 
-  describe "#for groups" do
+  context 'wuth caching regions' do
     let(:directory) { test_api_client.directories.create name: 'test_directory' }
 
-    let(:group) { directory.groups.create name: 'test_group' }
-
-    let(:reloaded_group) { test_api_client.groups.get group.href }
-
-    after do
-      group.delete if group
-      directory.delete if directory
-    end
-    
-    it 'read reserved data' do
-      expect(group.custom_data["href"]).not_to eq(nil)
-      expect(group.custom_data["created_at"]).not_to eq(nil)
-      expect(group.custom_data["modified_at"]).not_to eq(nil)
-    end
-
-    RESERVED_FIELDS.each do |reserved_field|
-      it "set reserved data #{reserved_field} should raise error" do
-        group.custom_data[reserved_field] = 12
-        expect{ group.custom_data.save }.to raise_error
-      end
-    end
-
-    it 'set custom data' do
-      group.custom_data[:series] = "Enterprise"
-      expect(group.custom_data[:series]).to eq("Enterprise")
-      group.custom_data.save
-      expect(reloaded_group.custom_data[:series]).to eq("Enterprise")
-    end
-
-    it 'set nested custom data' do
-      group.custom_data[:special_rank] = "Captain"
-      group.custom_data[:permissions] = {"crew_quarters" => "93-601"}
-      expect(group.custom_data[:permissions]).to eq({"crew_quarters" => "93-601"})
-      group.custom_data.save
-      expect(reloaded_group.custom_data[:special_rank]).to eq("Captain")
-      expect(reloaded_group.custom_data[:permissions]).to eq({"crew_quarters" => "93-601"})
-    end
-
-    it 'not raise errors when saving a empty properties array' do
-      group.custom_data.save
-    end
-
-    it 'trigger custom data saving on group.save' do
-      group.custom_data[:series] = "Enterprise"
-      group.description = "founded on the twin principles of joy and service"
-      group.save
-      expect(reloaded_group.description).to eq("founded on the twin principles of joy and service")
-      expect(reloaded_group.custom_data[:series]).to eq("Enterprise")
-    end
+    it_behaves_like 'account_custom_data'
+    it_behaves_like 'group_custom_data'
+  end
 
-    it 'delete all custom data' do
-      group.custom_data["series"] = "Enterprise"
-      group.custom_data.save
-      expect(group.custom_data["series"]).to eq("Enterprise")
-      group.custom_data.delete
-      expect(reloaded_group.custom_data["series"]).to eq(nil)
+  context 'without caching regions' do
+    let(:disabled_cache_client) do
+      @disabled_cache_client ||= Stormpath::Client.new({api_key: test_api_key, cache: { store: Stormpath::Cache::DisabledCacheStore }})
     end
 
-    it 'delete a specific custom data field' do
-      group.custom_data["series"] = "Enterprise"
-      group.custom_data["favorite_drink"] = "Earl Grey Tea"
-      group.custom_data.save
-      
-      group.custom_data.delete("series")
-      group.custom_data.save
+    let(:directory) { disabled_cache_client.directories.create name: 'test_directory' }
 
-      expect(reloaded_group.custom_data["series"]).to eq(nil)
-      expect(reloaded_group.custom_data["favorite_drink"]).to eq("Earl Grey Tea")
-    end
+    it_behaves_like 'account_custom_data'
+    it_behaves_like 'group_custom_data'
   end
-
 end