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

data/lib/stormpath-sdk/resource/custom_data_storage.rb

@@ -0,0 +1,39 @@
+#
+# Copyright 2014 Stormpath, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module Stormpath::Resource::CustomDataStorage
+  extend ActiveSupport::Concern
+
+  CUSTOM_DATA = "custom_data"
+
+  included do
+
+    def save
+      apply_custom_data_updates_if_necessary
+      super
+    end
+
+    def apply_custom_data_updates_if_necessary
+      if custom_data.send :has_removed_properties?
+        custom_data.send :delete_removed_properties
+      end
+      if custom_data.send :has_new_properties?
+        self.set_property CUSTOM_DATA, custom_data.properties
+      end
+    end
+
+  end
+
+end

data/lib/stormpath-sdk/resource/directory.rb

@@ -20,15 +20,15 @@ class Stormpath::Resource::Directory < Stormpath::Resource::Instance
 
   belongs_to :tenant
 
-  has_many :accounts, can: :create
-  has_many :groups, can: :create
+  has_many :accounts, can: [:get, :create]
+  has_many :groups, can: [:get, :create]
 
   def create_account account, registration_workflow_enabled=nil
     href = accounts.href
-    unless registration_workflow_enabled.nil?
+    if registration_workflow_enabled == false
       href += "?registrationWorkflowEnabled=#{registration_workflow_enabled.to_s}"
     end
-
+    account.apply_custom_data_updates_if_necessary
     data_store.create href, account, Stormpath::Resource::Account
   end
 end

data/lib/stormpath-sdk/resource/expansion.rb

@@ -1,3 +1,18 @@
+#
+# Copyright 2013 Stormpath, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
 class Stormpath::Resource::Expansion
   attr_reader :query
 

data/lib/stormpath-sdk/resource/group.rb

@@ -15,6 +15,7 @@
 #
 class Stormpath::Resource::Group < Stormpath::Resource::Instance
   include Stormpath::Resource::Status
+  include Stormpath::Resource::CustomDataStorage
 
   prop_accessor :name, :description
 
@@ -22,8 +23,17 @@ class Stormpath::Resource::Group < Stormpath::Resource::Instance
   belongs_to :directory
 
   has_many :accounts
+  has_many :account_memberships
+
+  has_one :custom_data
 
   def add_account account
     client.group_memberships.create group: self, account: account
   end
+
+  def remove_account account
+    account_membership = account_memberships.find {|account_membership| account_membership.account.href == account.href }
+    account_membership.delete if account_membership
+  end
+  
 end

data/lib/stormpath-sdk/resource/status.rb

@@ -1,3 +1,18 @@
+#
+# Copyright 2013 Stormpath, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
 module Stormpath::Resource::Status
 
   ENABLED = 'ENABLED'
@@ -11,11 +26,7 @@ module Stormpath::Resource::Status
 
   def status
     value = get_property STATUS
-
-    if !value.nil?
-      value = value.upcase
-    end
-
+    value.upcase! if value
     value
   end
 

data/lib/stormpath-sdk/version.rb

@@ -14,6 +14,6 @@
 # limitations under the License.
 #
 module Stormpath
-  VERSION = '1.0.0.beta.4'
-  VERSION_DATE = '2013-12-10'
+  VERSION = '1.0.0.beta.5'
+  VERSION_DATE = '2014-03-03'
 end

data/spec/client_spec.rb

@@ -172,7 +172,12 @@ properties
       end
 
       context 'with a base url' do
-        it 'creates a client that connects to that base'
+        context 'creates a client that connects to that base' do
+          let(:api_key) { Stormpath::ApiKey.new(test_api_key_id, test_api_key_secret) }
+          let(:client) { Stormpath::Client.new(api_key: api_key, base_url: "https://api.stormpath.com/v1") }
+
+          it_behaves_like 'a valid client'
+        end
       end
 
       context 'with an api key' do

data/spec/data_store_spec.rb

@@ -11,13 +11,18 @@ describe Stormpath::DataStore do
 
   after do
     application_cache.clear
- end
+  end
 
   describe '.region_for' do
-    let(:region) { data_store.send(:region_for, 'https://api.stormpath.com/v1/directories/4NykYrYH0OBiOOVOg8LXQ5') }
     it 'pulls resource name from href' do
+      region = data_store.send :region_for, 'https://api.stormpath.com/v1/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'
+      expect(region).to eq('customData')
+    end
   end
 
   describe '#delete' do

data/spec/resource/account_spec.rb

@@ -1,20 +1,43 @@
 require 'spec_helper'
+require 'pry-debugger'
 
 describe Stormpath::Resource::Account, :vcr do
+
   describe "instances" do
     let(:directory) { test_api_client.directories.create name: 'testDirectory' }
+    
+    let(:given_name) { 'Ruby SDK' }
+    let(:middle_name) { 'Gruby' }
+    let(:surname) { 'SDK' }
+
     subject(:account) do
       directory.accounts.create email: 'test@example.com',
-          givenName: 'Ruby SDK',
+          given_name: given_name,
           password: 'P@$$w0rd',
-          surname: 'SDK',
+          middle_name: middle_name,
+          surname: surname,
           username: 'rubysdk'
     end
 
-    it { should respond_to :given_name }
-    it { should respond_to :username }
-    it { should respond_to :surname }
-    it { should respond_to :full_name }
+    [: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_instance_of Stormpath::Resource::EmailVerificationToken }
+
+    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
@@ -23,31 +46,41 @@ describe Stormpath::Resource::Account, :vcr do
 
   end
 
-  describe "#add_group" do
-    context "given a group" do
-      let(:directory) do
-        test_api_client.directories.create name: 'testDirectory'
-      end
-
-      let(:group) do
-        directory.groups.create name: 'testGroup'
-      end
-
-      let(:account) do
-        directory.accounts.create email: 'test@example.com',
+  describe 'account_associations' do
+    let(:directory) { test_api_client.directories.create name: 'testDirectory' }
+    
+    let(:account) do
+      directory.accounts.create email: 'test@example.com',
           givenName: 'Ruby SDK',
           password: 'P@$$w0rd',
           surname: 'SDK',
           username: 'rubysdk'
-      end
+    end
 
-      let(:reloaded_account) do
-        test_api_client.accounts.get account.href
-      end
+    it 'should belong_to directory' do
+      expect(account.directory).to eq(directory)
+    end
 
-      before do
-        account.add_group group
-      end
+    it 'should belong_to tenant' do
+      expect(account.tenant).to be
+      expect(account.tenant).to eq(account.directory.tenant)
+    end
+
+    after do
+      account.delete if account
+      directory.delete if directory
+    end
+  end
+
+  describe "#add_or_remove_group" do
+    context "given a group" do
+      let(:directory) { test_api_client.directories.create name: 'testDirectory' }
+
+      let(:group) { directory.groups.create name: 'testGroup' }
+
+      let(:account) { directory.accounts.create({ email: 'rubysdk@example.com', given_name: 'Ruby SDK', password: 'P@$$w0rd', surname: 'SDK' }) }
+
+      before { account.add_group group }
 
       after do
         account.delete if account
@@ -56,12 +89,21 @@ describe Stormpath::Resource::Account, :vcr do
       end
 
       it 'adds the group to the account' do
-        group_added = false
-        reloaded_account.groups.each do |g|
-          group_added = true if g.href == group.href
-        end
-        expect(group_added).to be_true
+        expect(account.groups).to include(group)
+      end
+
+      it 'has one group membership resource' do
+        expect(account.group_memberships).to have(1).item
+      end
+
+      it 'adds and removes the group from the account' do
+        expect(account.groups).to include(group)
+
+        account.remove_group group
+
+        expect(account.groups).not_to include(group)
       end
+
     end
   end
 
@@ -93,4 +135,5 @@ describe Stormpath::Resource::Account, :vcr do
       end
     end
   end
+
 end

data/spec/resource/account_store_mapping_spec.rb

@@ -24,11 +24,26 @@ describe Stormpath::Resource::AccountStoreMapping, :vcr do
   describe "instances" do
     subject(:account_store_mapping) {create_account_store_mapping(application,directory)}
    
-    it { should respond_to(:account_store) }
-    it { should respond_to(:list_index) }
-    it { should respond_to(:is_default_group_store) }
-    it { should respond_to(:is_default_account_store) }
-    it { should respond_to(:application) }
+    [: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
+
+    its(:list_index) { should be_instance_of 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|
+        its(specific_store_method) {should satisfy {|attribute| [TrueClass, FalseClass].include? attribute.class }}
+      end
+    end
+
+    its(:account_store) { should satisfy {|prop_reader| [Stormpath::Resource::Directory, Stormpath::Resource::Group].include? prop_reader.class }}
+
+    its(:application) { should be_instance_of Stormpath::Resource::Application }
   end
 
 

data/spec/resource/application_spec.rb

@@ -4,6 +4,29 @@ describe Stormpath::Resource::Application, :vcr do
   let(:application) { test_application }
   let(:directory) { test_directory }
 
+  describe "instances should respond to attribute property methods" do
+    subject(:application) { test_application }
+
+    it { should be_instance_of Stormpath::Resource::Application }
+
+    [: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(:default_account_store_mapping) { should be_instance_of Stormpath::Resource::AccountStoreMapping }
+    its(:default_group_store_mapping) { should be_instance_of Stormpath::Resource::AccountStoreMapping }
+
+    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 }
+
+
+  end
+
   describe '.load' do
     let(:url) do
       uri = URI(application.href)
@@ -26,6 +49,44 @@ describe Stormpath::Resource::Application, :vcr do
     end
   end
 
+  describe 'application_associations' do
+
+    context '#accounts' do
+      let(:account) { application.accounts.create build_account}
+
+      after do
+        account.delete if account
+      end
+
+      it 'should be able to create an account' do
+        expect(application.accounts).to include(account)
+        expect(application.default_account_store_mapping.account_store.accounts).to include(account)
+      end
+
+      it 'should be able to create and fetch the account' do
+        expect(application.accounts.get account.href).to be
+      end
+    end
+
+    context '#groups' do
+      let(:group) { application.groups.create name: "test_group"}
+
+      after do
+        group.delete if group
+      end
+
+      it 'should be able to create a group' do
+        expect(application.groups).to include(group)
+        expect(application.default_group_store_mapping.account_store.groups).to include(group)
+      end
+
+      it 'should be able to create and fetch a group' do
+        expect(application.groups.get group.href).to be
+      end
+    end
+
+  end
+  
   describe '#authenticate_account' do
     let(:account) do
       directory.accounts.create build_account(password: 'P@$$w0rd')
@@ -63,6 +124,80 @@ describe Stormpath::Resource::Application, :vcr do
     end
   end
 
+  describe '#authenticate_account_with_an_account_store_specified' do
+    let(:password) {'P@$$w0rd' }
+
+    let(:authentication_result) { application.authenticate_account login_request }
+
+    after do
+      account.delete if account
+    end
+    
+    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
+
+      it 'should return an authentication result' do
+        expect(authentication_result).to be
+        expect(authentication_result.account).to be
+        expect(authentication_result.account).to be_kind_of Stormpath::Resource::Account
+        expect(authentication_result.account.email).to eq(account.email)
+      end
+    end
+
+    context 'given a wrong directory' do
+      let(:new_directory) { test_api_client.directories.create name: 'test_account_store'}
+
+      let(:account) { new_directory.accounts.create build_account(password: 'P@$$w0rd') }
+
+      let(:login_request) do
+        Stormpath::Authentication::UsernamePasswordRequest.new account.username, password, account_store: directory
+      end
+
+      after do
+        new_directory.delete if new_directory
+      end
+
+      it 'raises an error' do
+        expect { authentication_result }.to raise_error Stormpath::Error
+      end
+    end
+
+    context 'given a group' do
+      let(:group) {directory.groups.create name: "test_group"}
+
+      let(:account) { directory.accounts.create build_account(password: 'P@$$w0rd') }
+
+      let(:login_request) do
+        Stormpath::Authentication::UsernamePasswordRequest.new account.username, password, account_store: group
+      end
+
+      before do
+        test_api_client.account_store_mappings.create({ application: application, account_store: group })
+      end
+
+      after do
+        group.delete if group
+      end
+
+      it 'and assigning the account to it, should return a authentication result' do
+        group.add_account account
+        expect(authentication_result).to be
+        expect(authentication_result.account).to be
+        expect(authentication_result.account).to be_kind_of Stormpath::Resource::Account
+        expect(authentication_result.account.email).to eq(account.email)
+      end
+
+      it 'but not assigning the account to, it should raise an error' do
+        expect { authentication_result }.to raise_error Stormpath::Error
+      end
+    end
+
+  end
+
   describe '#send_password_reset_email' do
     context 'given an email' do
       context 'of an exisiting account on the application' do