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

data/spec/resource/custom_data_spec.rb

@@ -0,0 +1,198 @@
+ # 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
+
+  end
+
+  describe "#for groups" 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 '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)
+    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
+
+      expect(reloaded_group.custom_data["series"]).to eq(nil)
+      expect(reloaded_group.custom_data["favorite_drink"]).to eq("Earl Grey Tea")
+    end
+  end
+
+end

data/spec/resource/directory_spec.rb

@@ -1,30 +1,213 @@
 require 'spec_helper'
 
 describe Stormpath::Resource::Directory, :vcr do
+
+  describe "instances should respond to attribute property methods" do
+    subject(:directory) { test_api_client.directories.create name: 'some_test_directory', description: 'description_for_some_test_directory' }
+
+    it { should be_instance_of Stormpath::Resource::Directory }
+
+    [: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
+
+    its(:tenant) { should be_instance_of Stormpath::Resource::Tenant }
+    its(:groups) { should be_instance_of Stormpath::Resource::Collection }
+    its(:accounts) { should be_instance_of Stormpath::Resource::Collection }
+
+    after do
+      directory.delete if directory
+    end
+  end
+
+  describe 'directory_associations' do
+    let(:directory) { test_directory }
+
+    context '#accounts' do
+      let(:account) { directory.accounts.create build_account}
+
+      after do
+        account.delete if account
+      end
+
+      it 'should be able to create an account' do
+        expect(directory.accounts).to include(account)
+      end
+
+      it 'should be able to create and fetch the account' do
+        expect(directory.accounts.get account.href).to be
+      end
+    end
+
+    context '#groups' do
+      let(:group) { directory.groups.create name: "test_group"}
+
+      after do
+        group.delete if group
+      end
+
+      it 'should be able to create a group' do
+        expect(directory.groups).to include(group)
+      end
+
+      it 'should be able to create and get a group' do
+        expect(directory.groups.get group.href).to be
+      end
+    end
+
+  end
+
   describe '#create_account' do
     let(:directory) { test_directory }
 
-    context 'given a valid account' do
-      let(:account) do
-        Stormpath::Resource::Account.new({
+    let(:account) do
+      Stormpath::Resource::Account.new({
+        email: "test@example.com",
+        given_name: 'Ruby SDK',
+        password: 'P@$$w0rd',
+        surname: 'SDK',
+        username: "username"
+      })
+    end
+
+    context 'without registration workflow' do
+
+      let(:created_account) { directory.create_account account }
+
+      after do
+        created_account.delete if created_account
+      end
+
+      it 'creates an account with status ENABLED' do
+        expect(created_account).to be
+        expect(created_account.username).to eq(account.username)
+        expect(created_account).to eq(account)
+        expect(created_account.status).to eq("ENABLED")
+        expect(created_account.email_verification_token.href).not_to be
+      end
+    end
+
+    context 'with registration workflow' do
+
+      let(:created_account_with_reg_workflow) { test_directory_with_verification.create_account account }
+
+      after do
+        created_account_with_reg_workflow.delete if created_account_with_reg_workflow
+      end
+
+      it 'creates an account with status UNVERIFIED' do
+        expect(created_account_with_reg_workflow).to be
+        expect(created_account_with_reg_workflow.username).to eq(account.username)
+        expect(created_account_with_reg_workflow).to eq(account)
+        expect(created_account_with_reg_workflow.status).to eq("UNVERIFIED")
+        expect(created_account_with_reg_workflow.email_verification_token.href).to be
+      end
+
+    end
+
+    context 'with registration workflow but set it to false on account creation' do
+
+      let(:created_account_with_reg_workflow) { test_directory_with_verification.create_account account, false }
+
+      after do
+        created_account_with_reg_workflow.delete if created_account_with_reg_workflow
+      end
+
+      it 'creates an account with status ENABLED' do
+        expect(created_account_with_reg_workflow).to be
+        expect(created_account_with_reg_workflow.username).to eq(account.username)
+        expect(created_account_with_reg_workflow).to eq(account)
+        expect(created_account_with_reg_workflow.status).to eq("ENABLED")
+        expect(created_account_with_reg_workflow.email_verification_token.href).not_to be
+      end
+
+    end
+
+  end
+
+  describe '#create_account_with_custom_data' do
+    let(:directory) { test_directory }
+
+      it 'creates an account with custom data' do
+        account =  Stormpath::Resource::Account.new({
           email: "test@example.com",
           given_name: 'Ruby SDK',
           password: 'P@$$w0rd',
           surname: 'SDK',
           username: "username"
         })
-      end
 
-      let(:created_account) { directory.create_account account, false }
+        account.custom_data["birth_date"] = "2305-07-13"
 
-      after do
-        created_account.delete if created_account
-      end
+        created_account = directory.create_account account
 
-      it 'creates an account' do
         expect(created_account).to be
         expect(created_account.username).to eq(account.username)
+        expect(created_account).to eq(account)
+        expect(created_account.custom_data["birth_date"]).to eq("2305-07-13")
+        created_account.delete
+    end
+  end
+
+  describe '#create_group' do
+    let(:directory) { test_directory }
+
+    context 'given a valid group' do
+      let(:group_name) { "valid_test_group" }
+
+      let(:created_group) { directory.groups.create name: group_name }
+
+      after do
+        created_group.delete if created_group
+      end
+
+      it 'creates a group' do
+        expect(created_group).to be
+        expect(created_group.name).to eq(group_name)
       end
     end
   end
+
+  describe '#delete_directory' do
+
+    let(:directory) { test_api_client.directories.create name: 'test_directory' }
+
+    let(:application) { test_api_client.applications.create name: 'test_application' }
+
+    let!(:group) { directory.groups.create name: 'someGroup' }
+
+    let!(:account) { directory.accounts.create({ email: 'rubysdk@example.com', given_name: 'Ruby SDK', password: 'P@$$w0rd',surname: 'SDK' }) }
+
+    let!(:account_store_mapping) do
+      test_api_client.account_store_mappings.create({ application: application, account_store: directory })
+    end
+
+    after do
+      application.delete if application
+    end
+
+    it 'and all of its associations' do
+      expect(directory.groups).to have(1).item
+      expect(directory.accounts).to have(1).item
+
+      expect(application.account_store_mappings.first.account_store).to eq(directory)
+
+      expect(application.accounts).to include(account)
+      expect(application.groups).to include(group)
+
+      expect(application.account_store_mappings).to have(1).item
+
+      directory.delete
+
+      expect(application.account_store_mappings).to have(0).item
+
+      expect(application.accounts).not_to include(account)
+      expect(application.groups).not_to include(group)
+    end
+
+  end
+
+
 end

data/spec/resource/group_membership_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Stormpath::Resource::GroupMembership, :vcr do
+  it "should be the same as AccountMembership" do
+    expect(Stormpath::Resource::GroupMembership).to eq(Stormpath::Resource::AccountMembership)
+  end
+
+  describe '#add_account' do
+    context "given an account and a group" do
+
+      let(:directory) { test_api_client.directories.create name: 'testDirectory' }
+
+      let(:group) { directory.groups.create name: 'someGroup' }
+
+      let(:account) { directory.accounts.create({ email: 'rubysdk@example.com', given_name: 'Ruby SDK', password: 'P@$$w0rd', surname: 'SDK' }) }
+
+      before { group.add_account account }
+
+      after do
+        group.delete if group
+        directory.delete if directory
+        account.delete if account
+      end
+
+      it ", group membership and account membership should correspond to each other" do
+        expect(group.account_memberships).to have(1).item
+        expect(account.group_memberships).to have(1).item
+        expect(group.accounts).to include(account)
+        expect(account.groups).to include(group)
+        expect(group.account_memberships.first).to be_a(Stormpath::Resource::GroupMembership)
+        expect(account.group_memberships.first).to be_a(Stormpath::Resource::GroupMembership)
+      end
+    end
+  end
+end