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

data/spec/resource/account_spec.rb

@@ -1,16 +1,13 @@
 require 'spec_helper'
-require 'pry-debugger'
 
 describe Stormpath::Resource::Account, :vcr do
 
-  describe "instances" do
-    let(:directory) { test_api_client.directories.create name: 'testDirectory' }
-    
+  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' }
-
-    subject(:account) do
+    let(:account) do
       directory.accounts.create email: 'test@example.com',
           given_name: given_name,
           password: 'P@$$w0rd',
@@ -19,36 +16,35 @@ describe Stormpath::Resource::Account, :vcr do
           username: 'rubysdk'
     end
 
-    [:given_name, :username, :middle_name, :surname, :email, :status].each do |property_accessor|
-      it { should respond_to property_accessor }
-      it { should respond_to "#{property_accessor}=" }
-      its(property_accessor) { should be_instance_of String }
-    end
-
-    it {should respond_to :full_name}
-    its(:full_name) { should be_instance_of String}
-    its(:full_name) { should eq("#{given_name} #{middle_name} #{surname}")}
-
-    it {should respond_to "password="}
-
-    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_nil }
-
-    its(:groups) { should be_instance_of Stormpath::Resource::Collection }
-    its(:group_memberships) { should be_instance_of Stormpath::Resource::Collection }
-
     after do
       account.delete if account
       directory.delete if directory
     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
+      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.tenant).to be_a Stormpath::Resource::Tenant
+      expect(account.directory).to be_a Stormpath::Resource::Directory
+      expect(account.custom_data).to be_a Stormpath::Resource::CustomData
+      expect(account.email_verification_token).to be_nil
+      expect(account.groups).to be_a Stormpath::Resource::Collection
+      expect(account.group_memberships).to be_a Stormpath::Resource::Collection
+    end
   end
 
   describe 'account_associations' do
-    let(:directory) { test_api_client.directories.create name: 'testDirectory' }
-    
+    let(:directory) { test_api_client.directories.create name: random_directory_name }
+
     let(:account) do
       directory.accounts.create email: 'test@example.com',
           givenName: 'Ruby SDK',
@@ -74,7 +70,7 @@ describe Stormpath::Resource::Account, :vcr do
 
   describe "#add_or_remove_group" do
     context "given a group" do
-      let(:directory) { test_api_client.directories.create name: 'testDirectory' }
+      let(:directory) { test_api_client.directories.create name: random_directory_name }
 
       let(:group) { directory.groups.create name: 'testGroup' }
 
@@ -93,7 +89,7 @@ describe Stormpath::Resource::Account, :vcr do
       end
 
       it 'has one group membership resource' do
-        expect(account.group_memberships).to have(1).item
+        expect(account.group_memberships.count).to eq(1)
       end
 
       it 'adds and removes the group from the account' do

data/spec/resource/account_store_mapping_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::AccountStoreMapping, :vcr do
-  
+
   def create_account_store_mapping(application, account_store, options={})
     test_api_client.account_store_mappings.create({
       application: application,
@@ -12,38 +12,41 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
      })
   end
 
-  let(:directory) { test_api_client.directories.create name: 'testDirectory', description: 'testDirectory for AccountStoreMappings' }
-  
-  let(:application) { test_api_client.applications.create name: 'testApplication', description: 'testApplication for AccountStoreMappings' }
-  
+  let(:directory_name) { random_directory_name }
+
+  let(:directory) { test_api_client.directories.create name: directory_name, description: 'testDirectory for AccountStoreMappings' }
+
+  let(:application) { test_api_client.applications.create name: random_application_name, description: 'testApplication for AccountStoreMappings' }
+
   after do
     application.delete if application
     directory.delete if directory
   end
-    
-  describe "instances" do
-    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 }
-      it { should respond_to "#{prop_accessor}=" }
-    end
 
-    [:default_account_store?, :default_group_store?].each do |prop_getter|
-      it { should respond_to prop_getter }
-    end
+  describe "instances" do
+    let(:account_store_mapping) {create_account_store_mapping(application,directory, is_default_account_store: true)}
 
-    its(:list_index) { should be_instance_of Fixnum }
+    it do
+      [:list_index, :is_default_account_store, :is_default_group_store, :default_account_store, :default_group_store ].each do |prop_accessor|
+        expect(account_store_mapping).to respond_to(prop_accessor)
+        expect(account_store_mapping).to respond_to("#{prop_accessor}=")
+      end
 
-    [:default_account_store, :default_group_store].each do |default_store_method|
-      [default_store_method, "is_#{default_store_method}", "#{default_store_method}?"].each do |specific_store_method|
-        its(specific_store_method) {should satisfy {|attribute| [TrueClass, FalseClass].include? attribute.class }}
+      [:default_account_store?, :default_group_store?].each do |prop_getter|
+        expect(account_store_mapping).to respond_to(prop_getter)
       end
-    end
 
-    its(:account_store) { should satisfy {|prop_reader| [Stormpath::Resource::Directory, Stormpath::Resource::Group].include? prop_reader.class }}
+      expect(account_store_mapping.list_index).to be_a Fixnum
+
+      [:default_account_store, :default_group_store].each do |default_store_method|
+        [default_store_method, "is_#{default_store_method}", "#{default_store_method}?"].each do |specific_store_method|
+          expect(account_store_mapping.send specific_store_method).to be_boolean
+        end
+      end
 
-    its(:application) { should be_instance_of Stormpath::Resource::Application }
+      expect(account_store_mapping.account_store).to be_a Stormpath::Resource::Directory
+      expect(account_store_mapping.application).to be_a Stormpath::Resource::Application
+    end
   end
 
 
@@ -159,7 +162,6 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
       account_store_mapping.save
       expect(reloaded_mapping.is_default_account_store).to eq(false)
     end
-
   end
 
   describe "given a mapping" do
@@ -171,16 +173,15 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
       account_store_mapping.delete
       expect(reloaded_application.account_store_mappings.count).to eq(0)
     end
-  
+
     it 'should be able to list its attributes' do
       reloaded_application.account_store_mappings.each do |account_store_mapping|
-        expect(account_store_mapping.account_store.name).to eq("testDirectory")
+        expect(account_store_mapping.account_store.name).to eq(directory_name)
         expect(account_store_mapping.list_index).to eq(0)
         expect(account_store_mapping.default_account_store?).to eq(true)
         expect(account_store_mapping.default_group_store?).to eq(false)
       end
     end
-
   end
 
 end

data/spec/resource/account_store_spec.rb

@@ -1,7 +1,7 @@
 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({
       application: application,
@@ -11,13 +11,13 @@ describe Stormpath::Resource::AccountStore, :vcr do
       is_default_group_store: is_default_group_store
      })
   end
-  
-  let(:application) { test_api_client.applications.create name: 'testApplication', description: 'testApplication for AccountStoreMappings' }
-  
-  let(:directory) { test_api_client.directories.create name: 'testDirectory', description: 'testDirectory for AccountStoreMappings' }
-  
+
+  let(:application) { test_api_client.applications.create name: random_application_name, description: 'testApplication for AccountStoreMappings' }
+
+  let(:directory) { test_api_client.directories.create name: random_directory_name, description: 'testDirectory for AccountStoreMappings' }
+
   let(:group) { directory.groups.create name: 'testGroup', description: 'testGroup for AccountStoreMappings' }
-  
+
   after do
     application.delete if application
     group.delete if group

data/spec/resource/application_spec.rb

@@ -1,30 +1,38 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::Application, :vcr do
-  let(:application) { test_application }
-  let(:directory) { test_directory }
+  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 }
 
-  describe "instances should respond to attribute property methods" do
-    subject(:application) { test_application }
+  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
 
-    it { should be_instance_of Stormpath::Resource::Application }
+  after do
+    application.delete if application
+    directory.delete if directory
+  end
 
-    [:name, :description, :status].each do |property_accessor|
-      it { should respond_to property_accessor }
-      it { should respond_to "#{property_accessor}="}
-      its(property_accessor) { should be_instance_of String }
-    end
+  it "instances should respond to attribute property methods" do
 
-    its(:tenant) { should be_instance_of Stormpath::Resource::Tenant }
-    its(:default_account_store_mapping) { should be_instance_of Stormpath::Resource::AccountStoreMapping }
-    its(:default_group_store_mapping) { should be_instance_of Stormpath::Resource::AccountStoreMapping }
+    expect(application).to be_a Stormpath::Resource::Application
 
-    its(:groups) { should be_instance_of Stormpath::Resource::Collection }
-    its(:accounts) { should be_instance_of Stormpath::Resource::Collection }
-    its(:password_reset_tokens) { should be_instance_of Stormpath::Resource::Collection }
-    its(:account_store_mappings) { should be_instance_of Stormpath::Resource::Collection }
+    [:name, :description, :status].each do |property_accessor|
+      expect(application).to respond_to(property_accessor)
+      expect(application).to respond_to("#{property_accessor}=")
+      expect(application.send property_accessor).to be_a String
+    end
 
+    expect(application.tenant).to be_a Stormpath::Resource::Tenant
+    expect(application.default_account_store_mapping).to be_a Stormpath::Resource::AccountStoreMapping
+    expect(application.default_group_store_mapping).to be_a Stormpath::Resource::AccountStoreMapping
 
+    expect(application.groups).to be_a Stormpath::Resource::Collection
+    expect(application.accounts).to be_a Stormpath::Resource::Collection
+    expect(application.password_reset_tokens).to be_a Stormpath::Resource::Collection
+    expect(application.account_store_mappings).to be_a Stormpath::Resource::Collection
   end
 
   describe '.load' do
@@ -69,7 +77,7 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context '#groups' do
-      let(:group) { application.groups.create name: "test_group"}
+      let(:group) { application.groups.create name: random_group_name }
 
       after do
         group.delete if group
@@ -86,7 +94,7 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
   end
-  
+
   describe '#authenticate_account' do
     let(:account) do
       directory.accounts.create build_account(password: 'P@$$w0rd')
@@ -132,10 +140,10 @@ describe Stormpath::Resource::Application, :vcr do
     after do
       account.delete if account
     end
-    
-    context 'given a proper directory' do 
+
+    context 'given a proper directory' do
       let(:account) { directory.accounts.create build_account(password: 'P@$$w0rd') }
-      
+
       let(:login_request) do
         Stormpath::Authentication::UsernamePasswordRequest.new account.username, password, account_store: directory
       end
@@ -149,7 +157,7 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'given a wrong directory' do
-      let(:new_directory) { test_api_client.directories.create name: 'test_account_store'}
+      let(:new_directory) { test_api_client.directories.create name: random_directory_name('new') }
 
       let(:account) { new_directory.accounts.create build_account(password: 'P@$$w0rd') }
 
@@ -167,7 +175,7 @@ describe Stormpath::Resource::Application, :vcr do
     end
 
     context 'given a group' do
-      let(:group) {directory.groups.create name: "test_group"}
+      let(:group) {directory.groups.create name: random_group_name }
 
       let(:account) { directory.accounts.create build_account(password: 'P@$$w0rd') }
 
@@ -229,11 +237,11 @@ describe Stormpath::Resource::Application, :vcr do
   describe '#verify_password_reset_token' do
     let(:account) do
       directory.accounts.create({
-        email: 'test@example.com',
+        email: random_email,
         given_name: 'Ruby SDK',
         password: 'P@$$w0rd',
         surname: 'SDK',
-        username: 'rubysdk'
+        username: random_user_name
       })
     end
 

data/spec/resource/collection_spec.rb

@@ -169,7 +169,7 @@ describe Stormpath::Resource::Collection, :vcr do
 
   context 'live examples' do
     context 'testing limits and offsets' do
-      let(:directory) {test_api_client.directories.create name: "Directory for pagination testing"}
+      let(:directory) {test_api_client.directories.create name: random_directory_name }
 
       let(:groups) do
         ('A'..'Z').map do |letter|
@@ -182,21 +182,21 @@ describe Stormpath::Resource::Collection, :vcr do
       end
 
       it 'should respond as expected with or without limits' do
-        expect(groups).to have(26).items
+        expect(groups.count).to eq(26)
 
-        expect(directory.groups.limit(3)).to have(26).items
+        expect(directory.groups.limit(3).count).to eq(26)
 
-        expect(directory.groups.offset(10).limit(3)).to have(16).items
+        expect(directory.groups.offset(10).limit(3).count).to eq(16)
 
-        expect(directory.groups.limit(3).offset(10)).to have(16).items
+        expect(directory.groups.limit(3).offset(10).count).to eq(16)
 
-        expect(directory.groups).to have(26).items
+        expect(directory.groups.count).to eq(26)
 
-        expect(directory.groups.limit(25)).to have(26).items
+        expect(directory.groups.limit(25).count).to eq(26)
 
-        expect(directory.groups.limit(26)).to have(26).items
+        expect(directory.groups.limit(26).count).to eq(26)
 
-        expect(directory.groups.limit(100)).to have(26).items
+        expect(directory.groups.limit(100).count).to eq(26)
 
         expect(directory.groups.limit(25)).to include(groups.last)
 
@@ -204,14 +204,14 @@ describe Stormpath::Resource::Collection, :vcr do
 
         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(25).count).to eq(1)
 
-        expect(directory.groups.offset(26)).to have(0).items
+        expect(directory.groups.offset(26).count).to eq(0)
       end
     end
 
     context 'testing limits and offsets with name checking' do
-      let(:directory) {test_api_client.directories.create name: "Directory for pagination testing"}
+      let(:directory) {test_api_client.directories.create name: random_directory_name }
 
       let!(:groups) do
         ('1'..'100').map do |number|
@@ -224,25 +224,25 @@ describe Stormpath::Resource::Collection, :vcr do
       end
 
       it 'should paginate properly' do
-        expect(directory.groups).to have(100).items
+        expect(directory.groups.count).to eq(100)
 
         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).count).to eq(100)
 
-        expect(directory.groups.limit(30).current_page.items).to have(30).items
+        expect(directory.groups.limit(30).current_page.items.count).to eq(30)
 
-        expect(directory.groups.limit(30).offset(30)).to have(70).items
+        expect(directory.groups.limit(30).offset(30).count).to eq(70)
 
-        expect(directory.groups.limit(30).offset(30).current_page.items).to have(30).items
+        expect(directory.groups.limit(30).offset(30).current_page.items.count).to eq(30)
 
-        expect(directory.groups.limit(30).offset(60)).to have(40).items
+        expect(directory.groups.limit(30).offset(60).count).to eq(40)
 
-        expect(directory.groups.limit(30).offset(60).current_page.items).to have(30).items
+        expect(directory.groups.limit(30).offset(60).current_page.items.count).to eq(30)
 
-        expect(directory.groups.limit(30).offset(90)).to have(10).items
+        expect(directory.groups.limit(30).offset(90).count).to eq(10)
 
-        expect(directory.groups.limit(30).offset(90).current_page.items).to have(10).items
+        expect(directory.groups.limit(30).offset(90).current_page.items.count).to eq(10)
 
         expect(directory.groups.limit(30).map {|group| group.name }).to eq(('1'..'100').to_a.sort)
 
@@ -273,7 +273,7 @@ describe Stormpath::Resource::Collection, :vcr do
     end
 
     context '#wild characters search' do
-      let(:directory) {test_api_client.directories.create name: "Test directory"}
+      let(:directory) {test_api_client.directories.create name: random_directory_name }
 
       # !@#$%^&*()_-+=?><:]}[{'
       # 'jlpicard/!@$%^*()_-+&=?><:]}[{'
@@ -292,24 +292,24 @@ describe Stormpath::Resource::Collection, :vcr do
       end
 
       it 'should search accounts by username' do
-        expect(directory.accounts.search(username: username)).to have(1).items
+        expect(directory.accounts.search(username: username).count).to eq(1)
       end
 
       it 'should search accounts by any column (aiming at username)' do
-        expect(directory.accounts.search(username)).to have(1).items
+        expect(directory.accounts.search(username).count).to eq(1)
       end
 
       it 'should search accounts by email' do
-        expect(directory.accounts.search(email: "capt@enterprise.com")).to have(1).items
+        expect(directory.accounts.search(email: "capt@enterprise.com").count).to eq(1)
       end
 
       it 'should search accounts by any column (aiming at email)' do
-        expect(directory.accounts.search("capt@enterprise.com")).to have(1).items
+        expect(directory.accounts.search("capt@enterprise.com").count).to eq(1)
       end
     end
 
     context '#asterisk search on one attribute' do
-      let(:directory) {test_api_client.directories.create name: "Test directory"}
+      let(:directory) {test_api_client.directories.create name: random_directory_name }
 
       let!(:account) do
         directory.accounts.create username: "jlpicard",
@@ -324,20 +324,20 @@ describe Stormpath::Resource::Collection, :vcr do
       end
 
       it 'should search accounts by username with asterisk at the beginning' do
-        expect(directory.accounts.search(username: "*card")).to have(1).items
+        expect(directory.accounts.search(username: "*card").count).to eq(1)
       end
 
       it 'should search accounts by username with asterisk at the end' do
-        expect(directory.accounts.search(username: "jl*")).to have(1).items
+        expect(directory.accounts.search(username: "jl*").count).to eq(1)
       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
+        expect(directory.accounts.search(username: "*pic*").count).to eq(1)
       end
     end
 
     context '#asterisk search on multiple attribute' do
-      let(:directory) {test_api_client.directories.create name: "Test directory"}
+      let(:directory) {test_api_client.directories.create name: random_directory_name }
 
       let!(:account) do
         directory.accounts.create username: "jlpicard",
@@ -352,15 +352,15 @@ describe Stormpath::Resource::Collection, :vcr do
       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
+        expect(directory.accounts.search(username: "*card", email: "*enterprise.com").count).to eq(1)
       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
+        expect(directory.accounts.search(username: "jl*", email: "capt*").count).to eq(1)
       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
+        expect(directory.accounts.search(username: "*pic*", email: "*enterprise*").count).to eq(1)
       end
     end