stormpath-sdk 0.4.0 → 1.0.0.beta

data/spec/data_store_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe Stormpath::DataStore 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, {store: store}, nil, nil }
+  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' }
+
+  after do
+    application_cache.clear
+ 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
+      expect(region).to eq('directories')
+    end
+  end
+
+  describe '#delete' do
+    before do
+      resource = factory.resource 'application', 1, %w(tenant groups)
+      href = resource['href']
+      request_executor.response = MultiJson.dump resource
+      application = data_store.get_resource href, Stormpath::Resource::Application
+      expect(application_cache.size).to eq(1)
+      data_store.delete application
+    end
+
+    it 'removes the resource from the cache' do
+      expect(application_cache.size).to be(0)
+    end
+  end
+
+  describe '#get_resource' do
+    context 'shallow resource' do
+      before do
+        resource = factory.resource 'application', 1, %w(tenant groups)
+        href = resource['href']
+        request_executor.response = MultiJson.dump resource
+        data_store.get_resource href, Stormpath::Resource::Application
+        @cached = application_cache.get href
+      end
+
+      it 'caches a shallow resource' do
+        expect(@cached).to be
+        expect(@cached).to be_resource
+        expect(@cached['tenant']).to be_link
+        expect(@cached['groups']).to be_link_collection
+      end
+
+      it 'caches no associations' do
+        expect(tenant_cache.size).to eq(0)
+        expect(group_cache.size).to eq(0)
+      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.misses).to eq(1)
+      end
+
+      context 'retrieved twice' do
+        before do
+          data_store.get_resource @cached['href'], Stormpath::Resource::Application
+        end
+
+        it 'hits the cache on the get' do
+          expect(application_cache.stats.hits).to eq(2)
+          expect(application_cache.stats.misses).to eq(1)
+        end
+      end
+    end
+
+    context 'deep resource' do
+      before do
+        resource = factory.resource 'application', 2, %w(tenant groups)
+        href = resource['href']
+        request_executor.response = MultiJson.dump resource
+        data_store.get_resource href, Stormpath::Resource::Application
+        @cached = application_cache.get href
+      end
+
+      it 'caches a shallow resource' do
+        expect(@cached).to be
+        expect(@cached).to be_resource
+        expect(@cached['tenant']).to be_link
+        expect(@cached['groups']).to be_link_collection
+      end
+
+      it 'caches shallow associations' do
+        expect(tenant_cache.size).to eq(1)
+        expect(group_cache.size).to eq(2)
+      end
+    end
+
+    context 'shallow collection' do
+      before do
+        resource = factory.collection 'tenant', 'application', 1, %w(tenant groups)
+        href = resource['href']
+        request_executor.response = MultiJson.dump resource
+        data_store.get_resource href, Stormpath::Resource::Application
+      end
+
+      it 'caches collection resources only' do
+        expect(application_cache.size).to eq(2)
+        expect(tenant_cache.size).to eq(0)
+        expect(group_cache.size).to eq(0)
+      end
+    end
+
+    context 'deep collection' do
+      before do
+        resource = factory.collection 'tenant', 'application', 2, %w(tenant groups)
+        href = resource['href']
+        request_executor.response = MultiJson.dump resource
+        data_store.get_resource href, Stormpath::Resource::Application
+      end
+
+      it 'caches collection resources and associations' do
+        expect(application_cache.size).to eq(2)
+        expect(tenant_cache.size).to eq(2)
+        expect(group_cache.size).to eq(4)
+      end
+    end
+
+  end
+end

data/spec/resource/account_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Stormpath::Resource::Account, :vcr do
+  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',
+          givenName: 'Ruby SDK',
+          password: 'P@$$w0rd',
+          surname: 'SDK',
+          username: 'rubysdk'
+      end
+
+      let(:reloaded_account) do
+        test_api_client.accounts.get account.href
+      end
+
+      before do
+        account.add_group group
+      end
+
+      after do
+        account.delete if account
+        group.delete if group
+        directory.delete if directory
+      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
+      end
+    end
+  end
+
+  describe '#save' do
+    context 'when property values have changed' do
+      let(:account) do
+        test_directory.accounts.create build_account
+      end
+      let(:account_uri) do
+        account.href
+      end
+      let(:new_surname) do
+        "NewSurname"
+      end
+      let(:reloaded_account) { test_api_client.accounts.get account_uri }
+
+      before do
+        account = test_api_client.accounts.get account_uri
+        account.surname = new_surname
+        account.save
+      end
+
+      after do
+        account.delete if account
+      end
+
+      it 'saves changes to the account' do
+        expect(reloaded_account.surname).to eq(new_surname)
+      end
+    end
+  end
+end

data/spec/resource/application_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe Stormpath::Resource::Application, :vcr do
+  let(:application) { test_application }
+  let(:directory) { test_directory }
+
+  describe '.load' do
+    let(:url) do
+      uri = URI(application.href)
+      credentialed_uri = URI::HTTPS.new(
+        uri.scheme, "#{test_api_key_id}:#{test_api_key_secret}", uri.host,
+        uri.port, uri.registry, uri.path, uri.query, uri.opaque, uri.fragment
+      )
+      credentialed_uri.to_s
+    end
+
+    it "raises a LoadError with an invalid url" do
+      expect {
+        Stormpath::Resource::Application.load 'this is an invalid url'
+      }.to raise_error(Stormpath::Resource::Application::LoadError)
+    end
+
+    it "instantiates client and application objects from a composite URL" do
+      loaded_application = Stormpath::Resource::Application.load(url)
+      expect(loaded_application).to eq(application)
+    end
+  end
+
+  describe '#authenticate_account' do
+    let(:account) do
+      directory.accounts.create build_account(password: 'P@$$w0rd')
+    end
+
+    let(:login_request) do
+      Stormpath::Authentication::UsernamePasswordRequest.new account.username, password
+    end
+
+    let(:authentication_result) do
+      application.authenticate_account login_request
+    end
+
+    after do
+      account.delete if account
+    end
+
+    context 'given a valid username and password' do
+      let(:password) {'P@$$w0rd' }
+
+      it 'returns 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 an invalid username and password' do
+      let(:password) { 'b@dP@$$w0rd' }
+
+      it 'raises 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
+        let(:account) { directory.accounts.create build_account  }
+
+        let(:sent_to_account) { application.send_password_reset_email account.email }
+
+        after do
+          account.delete if account
+        end
+
+        it 'sends a password reset request of the account' do
+          expect(sent_to_account).to be
+          expect(sent_to_account).to be_kind_of Stormpath::Resource::Account
+          expect(sent_to_account.email).to eq(account.email)
+        end
+      end
+
+      context 'of a non exisitng account' do
+        it 'raises an exception' do
+          expect do
+            application.send_password_reset_email "test@example.com"
+          end.to raise_error Stormpath::Error
+        end
+      end
+    end
+  end
+
+  describe '#verify_password_reset_token' do
+    let(:account) do
+      directory.accounts.create({
+        email: 'test@example.com',
+        given_name: 'Ruby SDK',
+        password: 'P@$$w0rd',
+        surname: 'SDK',
+        username: 'rubysdk'
+      })
+    end
+
+    let(:password_reset_token) do
+      application.password_reset_tokens.create(email: account.email).token
+    end
+
+    let(:reset_password_account) do
+      application.verify_password_reset_token password_reset_token
+    end
+
+    after do
+      account.delete if account
+    end
+
+    it 'retrieves the account with the reset password' do
+      expect(reset_password_account).to be
+      expect(reset_password_account.email).to eq(account.email)
+    end
+
+    context 'and if the password is changed' do
+      let(:new_password) { 'N3wP@$$w0rd' }
+
+      let(:login_request) do
+        Stormpath::Authentication::UsernamePasswordRequest.new account.username, new_password
+      end
+
+      let(:expected_email) { 'test2@example.com' }
+
+      let(:authentication_result) do
+        application.authenticate_account login_request
+      end
+
+      before do
+        reset_password_account.password = new_password
+        reset_password_account.save
+      end
+
+      it 'can be successfully authenticated' 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
+  end
+end

data/spec/resource/base_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Stormpath::Resource::Base do
+  describe '.prop_accessor' do
+    context 'given property names' do
+      class TestResource < Stormpath::Resource::Base
+        prop_accessor :username, :given_name
+      end
+
+      let(:resource) do
+        TestResource.new({
+          'username' => 'bar',
+          'givenName' => 'foo'
+        }, nil)
+      end
+
+      it 'generates a getter method for each property' do
+        expect(resource.username).to eq('bar')
+        expect(resource.given_name).to eq('foo')
+      end
+
+      it 'generates a setter for each property' do
+        resource.username = 'foo'
+        resource.given_name = 'bar'
+        expect(resource.properties).to include('username' => 'foo')
+        expect(resource.properties).to include('givenName' => 'bar')
+      end
+    end
+  end
+
+  describe '.non_printable' do
+    context 'given property names' do
+      class TestResource < Stormpath::Resource::Base
+        prop_non_printable :password
+      end
+
+      let(:resource) do
+        TestResource.new({
+          'username' => 'bar',
+          'password' => 'P@$$w0rd'
+        }, nil)
+      end
+
+      it 'marks that property as not being printable' do
+        expect(resource.inspect).to include('username')
+        expect(resource.inspect).to_not include('password')
+      end
+    end
+  end
+
+  describe '.get_property' do
+    context 'given the name of a dirty property' do
+      class TestResource < Stormpath::Resource::Base
+        prop_accessor :username
+      end
+
+      let(:resource) do
+        TestResource.new('http://foo.com/test/123', nil).tap do |resource|
+          resource.username = 'foo'
+        end
+      end
+
+      it 'does NOT attempt to materialize the entire resource' do
+        expect(resource.username).to eq('foo')
+      end
+    end
+  end
+
+  describe '#==' do
+    class TestResource < Stormpath::Resource::Base; end
+
+    context 'compared against an object of the same class' do
+      let(:resource) do
+        TestResource.new('http://foo.com/test/123')
+      end
+
+      context 'href matches' do
+        let(:other) do
+          TestResource.new('http://foo.com/test/123')
+        end
+
+        it 'passes' do
+          expect(resource).to eq(other)
+        end
+      end
+
+      context 'href does not match' do
+        let(:other) do
+          TestResource.new('http://foo.com/test/456')
+        end
+
+        it 'fails' do
+          expect(resource).to_not eq(other)
+        end
+      end
+    end
+
+    context 'compared against an object of another class' do
+      class NotAResource; end
+
+      let(:resource) do
+        TestResource.new('http://foo.com/test/123')
+      end
+
+      let(:other) do
+        NotAResource.new
+      end
+
+      it 'fails' do
+        expect(resource).to_not eq(other)
+      end
+    end
+  end
+end