stormpath-sdk 0.4.0 → 1.0.0.beta

data/lib/stormpath-sdk/util/assert.rb

@@ -14,35 +14,25 @@
 # limitations under the License.
 #
 module Stormpath
-
   module Util
-
     module Assert
 
-      def assert_not_nil object, message
-
+      def assert_not_nil(object, message)
         raise ArgumentError, message, caller unless !object.nil?
-
       end
 
-      def assert_kind_of clazz, object, message
-
+      def assert_kind_of(clazz, object, message)
         raise ArgumentError, message, caller unless object.kind_of? clazz
-
       end
 
-      def assert_true arg, message
-
+      def assert_true(arg, message)
         raise ArgumentError, message, caller unless arg
-
       end
 
-      def assert_false arg, message
-
+      def assert_false(arg, message)
         raise ArgumentError, message, caller unless !arg
-
       end
 
     end
   end
-end
+end

data/lib/stormpath-sdk/version.rb

@@ -14,6 +14,6 @@
 # limitations under the License.
 #
 module Stormpath
-  VERSION = '0.4.0'
-  VERSION_DATE = '2012-10-26'
-end
+  VERSION = '1.0.0.beta'
+  VERSION_DATE = '2013-06-12'
+end

data/spec/api_key_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Stormpath::ApiKey do
+  describe '.new' do
+    context 'given an id and secret' do
+      id = 'an_api_id'
+      secret = 'a_secret'
+      let(:apiKey) { Stormpath::ApiKey.new(id, secret) }
+
+      it 'sets the id' do
+        expect(apiKey.id).to eq(id)
+      end
+
+      it 'sets the secret' do
+        expect(apiKey.secret).to eq(secret)
+      end
+    end
+  end
+end

data/spec/auth/basic_authenticator_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe "BasicAuthenticator" do
+  context "given an instance of BasicAuthenticator" do
+
+    before do
+      ds = Stormpath::DataStore.new "", {}, ""
+      allow(test_api_client).to receive(:data_store).and_return(ds)
+      auth_result = Stormpath::Authentication::AuthenticationResult.new({}, test_api_client)
+      allow(ds).to receive(:create).and_return(auth_result)
+
+      @ba = Stormpath::Authentication::BasicAuthenticator.new ds
+    end
+
+    context "when authenticating" do
+      before do
+        @response = @ba.authenticate "foo/bar", Stormpath::Authentication::UsernamePasswordRequest.new("fake-username", "fake-password")
+      end
+
+      it "an AuthenticationResult is returned" do
+        expect(@response).to be_a Stormpath::Authentication::AuthenticationResult
+      end
+    end
+  end
+end

data/spec/auth/sauthc1_signer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Stormpath::Http::Authc::Sauthc1Signer do
+  let(:fake_uuid_generator) do
+    Proc.new { 'fake-uuid' }
+  end
+  let(:signer) do
+    Stormpath::Http::Authc::Sauthc1Signer.new fake_uuid_generator
+  end
+
+  after do
+    Timecop.return
+  end
+
+  describe '#sign_request' do
+    context 'for two GET requests to the same URL' do
+      context 'with one request using the query_string hash' do
+        let(:fake_api_key) { Stormpath::ApiKey.new('foo', 'bar') }
+
+        let(:empty_query_hash_request) do
+          Stormpath::Http::Request.new 'get', 'http://example.com/resources/abc123?q=red blue', nil, Hash.new, nil
+        end
+
+        let(:filled_query_hash_request) do
+          Stormpath::Http::Request.new 'get', 'http://example.com/resources/abc123', {'q' => 'red blue'}, Hash.new, nil
+        end
+
+        before do
+          Timecop.freeze(Time.now)
+          signer.sign_request empty_query_hash_request, fake_api_key
+          signer.sign_request filled_query_hash_request, fake_api_key
+        end
+
+        it 'assigns identical headers to both requests' do
+          expect(empty_query_hash_request.http_headers['Host']).to eq(filled_query_hash_request.http_headers['Host'])
+          expect(empty_query_hash_request.http_headers['Authorization']).to eq(filled_query_hash_request.http_headers['Authorization'])
+        end
+      end
+    end
+  end
+end

data/spec/cache/cache_entry_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Stormpath::Cache::CacheEntry do
+  after do
+    Timecop.return
+  end
+
+  context 'by default' do
+    let(:cache_entry) do
+      Stormpath::Cache::CacheEntry.new 'foo'
+    end
+
+    let(:now) { Time.now }
+    before { Timecop.freeze now }
+
+    it 'initializes the value' do
+      expect(cache_entry.value).to eq 'foo'
+    end
+
+    it 'initializes the creation time to now' do
+      expect(cache_entry.created_at).to eq now
+    end
+
+    it 'initializes the last accessed time to now' do
+      expect(cache_entry.last_accessed_at).to eq now
+    end
+  end
+
+  describe '#touch' do
+    let(:cache_entry) do
+      Stormpath::Cache::CacheEntry.new 'foo'
+    end
+
+    let(:now) { Time.now }
+
+    before do
+      Timecop.freeze now
+      cache_entry.touch
+    end
+
+    it 'updates the last accessed at time' do
+      expect(cache_entry.last_accessed_at).to eq now
+    end
+  end
+
+  describe '#expired?=' do
+    let(:now) { Time.now }
+
+    let(:ttl_seconds) { 300 }
+    let(:tti_seconds) { 300 }
+
+    context 'has not expired' do
+      let(:cache_entry) do
+        Stormpath::Cache::CacheEntry.new 'foo'
+      end
+
+      let(:expired) do
+        cache_entry.expired? ttl_seconds, tti_seconds
+      end
+
+      it 'returns false' do
+        expect(expired).to be_false
+      end
+    end
+
+    context 'when TTL has expired' do
+      before do
+        cache_entry = Stormpath::Cache::CacheEntry.new 'foo'
+        Timecop.freeze now + ttl_seconds + 1
+
+        @expired = cache_entry.expired? ttl_seconds, tti_seconds
+      end
+
+      it 'returns true' do
+        expect(@expired).to be_true
+      end
+    end
+
+    context 'when TTI has expired' do
+      before do
+        cache_entry = Stormpath::Cache::CacheEntry.new 'foo'
+        Timecop.freeze now + tti_seconds + 1
+
+        @expired = cache_entry.expired? ttl_seconds, tti_seconds
+      end
+
+      it 'returns true' do
+        expect(@expired).to be_true
+      end
+    end
+  end
+
+  describe '#to_h' do
+    let(:cache_entry) do
+      Stormpath::Cache::CacheEntry.new 'foo'
+    end
+
+    let(:now) { Time.now }
+    before { Timecop.freeze now }
+
+    it 'returns a hash of the attributes' do
+      expect(cache_entry.to_h).to eq({
+        'value' => cache_entry.value,
+        'created_at' => cache_entry.created_at,
+        'last_accessed_at' => cache_entry.last_accessed_at
+      })
+    end
+  end
+
+  describe '.from_h=' do
+    let(:hash) do
+      {
+        "value" =>
+          {
+            "href" => "https://api.stormpath.com/v1/applications/app1",
+            "name" => "application app1",
+            "tenant" => {
+              "href" => "https://api.stormpath.com/v1/tenants/ten2"
+            },
+            "groups" =>
+              {"href" => "https://api.stormpath.com/v1/applications/app3/groups",
+               "items" =>
+                 [{"href" => "https://api.stormpath.com/v1/groups/gro4"},
+                 {"href" => "https://api.stormpath.com/v1/groups/gro5"}]
+              }
+            },
+        "created_at" => "2013-06-05T10:01:31-07:00",
+        "last_accessed_at" => "2013-06-05T10:01:31-07:00"
+      }
+    end
+
+    let(:cache_entry) do
+      Stormpath::Cache::CacheEntry.from_h(hash)
+    end
+
+    let(:created_at) do
+      Time.parse(hash['created_at'])
+    end
+
+    let(:last_accessed_at) do
+      Time.parse(hash['last_accessed_at'])
+    end
+
+    it 'returns a cache entry' do
+      expect(cache_entry).to be_kind_of Stormpath::Cache::CacheEntry
+    end
+
+    it 'sets created at' do
+      expect(cache_entry.created_at).to eq created_at
+    end
+
+    it 'sets the last accessed at' do
+      expect(cache_entry.last_accessed_at).to eq last_accessed_at
+    end
+  end
+end

data/spec/cache/cache_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Stormpath::Cache::Cache do
+  let(:cache) { Stormpath::Cache::Cache.new ttl_seconds: 7, tti_seconds: 3 }
+  let(:now)   { Time.now }
+
+  before do
+    cache.put 'foo', 'bar'
+  end
+
+  after do
+    Timecop.return
+  end
+
+  describe '#put' do
+    it 'adds entry to the cache' do
+      expect(cache.size).to eq(1)
+      expect(cache.stats.summary).to eq [1, 0, 0, 0, 1]
+    end
+  end
+
+  describe '#get' do
+    context 'miss' do
+      before do
+        @foo = cache.get 'not-foo'
+      end
+
+      it 'gets nil' do
+        expect(@foo).not_to be
+        expect(cache.stats.summary).to eq [1, 0, 1, 0, 1]
+      end
+    end
+
+    context 'live before tti' do
+      before do
+        Timecop.freeze now + 2
+        @foo = cache.get 'foo'
+      end
+
+      it 'gets bar' do
+        expect(@foo).to eq('bar')
+        expect(cache.stats.summary).to eq [1, 1, 0, 0, 1]
+      end
+    end
+
+    context 'live after tti' do
+      before do
+        Timecop.freeze now + 2
+        cache.get 'foo'
+        Timecop.freeze now + 5
+        @foo = cache.get 'foo'
+      end
+
+      it 'gets bar' do
+        expect(@foo).to eq('bar')
+        expect(cache.stats.summary).to eq [1, 2, 0, 0, 1]
+      end
+    end
+
+    context 'expired by tti' do
+      before do
+        Timecop.freeze now + 4
+        @foo = cache.get 'foo'
+      end
+
+      it 'gets nil' do
+        expect(@foo).not_to be
+        expect(cache.stats.summary).to eq [1, 0, 1, 1, 1]
+      end
+    end
+
+    context 'expired by ttl' do
+      before do
+        Timecop.freeze now + 2
+        cache.get 'foo'
+        Timecop.freeze now + 5
+        cache.get 'foo'
+        Timecop.freeze now + 8
+        @foo = cache.get 'foo'
+      end
+
+      it 'gets nil' do
+        expect(@foo).not_to be
+        expect(cache.stats.summary).to eq [1, 2, 1, 1, 1]
+      end
+    end
+  end
+end

data/spec/cache/cache_stats_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Stormpath::Cache::CacheStats do
+  let(:cache_stats) do
+    Stormpath::Cache::CacheStats.new
+  end
+
+  context 'by default' do
+    it 'intializes counters' do
+      expect(cache_stats.puts).to eq 0
+      expect(cache_stats.hits).to eq 0
+      expect(cache_stats.misses).to eq 0
+      expect(cache_stats.expirations).to eq 0
+      expect(cache_stats.size).to eq 0
+    end
+  end
+
+  describe '#put' do
+    before { cache_stats.put }
+
+    it 'increments puts' do
+      expect(cache_stats.puts).to eq 1
+    end
+
+    it 'increments size' do
+      expect(cache_stats.puts).to eq 1
+    end
+
+    it 'updates summary' do
+      expect(cache_stats.summary).to eq [1, 0, 0, 0, 1]
+    end
+  end
+
+  describe '#hit' do
+    before { cache_stats.hit }
+
+    it 'increments hits' do
+      expect(cache_stats.hits).to eq 1
+    end
+
+    it 'updates summary' do
+      expect(cache_stats.summary).to eq [0, 1, 0, 0, 0]
+    end
+  end
+
+  describe '#miss=' do
+    context 'expired is true' do
+      before { cache_stats.miss true }
+
+      it 'increments misses' do
+        expect(cache_stats.misses).to eq 1
+      end
+
+      it 'increments expirations' do
+        expect(cache_stats.expirations).to eq 1
+      end
+
+      it 'updates summary' do
+        expect(cache_stats.summary).to eq [0, 0, 1, 1, 0]
+      end
+    end
+
+    context 'expired is true' do
+      before { cache_stats.miss false }
+
+      it 'increments misses' do
+        expect(cache_stats.misses).to eq 1
+      end
+
+      it 'does not increment expirations' do
+        expect(cache_stats.expirations).to eq 0
+      end
+
+      it 'updates summary' do
+        expect(cache_stats.summary).to eq [0, 0, 1, 0, 0]
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when size is greater than zero' do
+      before do
+        3.times { cache_stats.put }
+        cache_stats.delete
+      end
+
+      it 'decrements size' do
+        expect(cache_stats.size).to eq 2
+      end
+
+      it 'updates summary' do
+        expect(cache_stats.summary).to eq [3, 0, 0, 0, 2]
+      end
+    end
+
+    context 'when size is zero' do
+      before do
+        cache_stats.delete
+      end
+
+      it 'does nothing' do
+        expect(cache_stats.size).to eq 0
+      end
+    end
+  end
+end