aws-sessionstore-dynamodb 1.0.0 → 2.0.0

data/spec/aws/session_store/dynamo_db/error/default_error_handler_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"). You
@@ -11,7 +13,6 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-
 require 'spec_helper'
 
 describe Aws::SessionStore::DynamoDB do
@@ -20,43 +21,44 @@ describe Aws::SessionStore::DynamoDB do
   instance_exec(&ConstantHelpers)
 
   before do
-    @options = { :dynamo_db_client => client, :secret_key => 'meltingbutter' }
+    @options = { dynamo_db_client: client, secret_key: 'meltingbutter' }
   end
 
   let(:base_app) { MultiplierApplication.new }
   let(:app) { Aws::SessionStore::DynamoDB::RackMiddleware.new(base_app, @options) }
   let(:client) { double('Aws::DynamoDB::Client') }
 
-  context "Error handling for Rack Middleware with default error handler" do
-    it "raises error for missing secret key" do
-      client.stub(:update_item).and_raise(missing_key_error)
-      lambda { get "/" }.should raise_error(missing_key_error)
+  context 'Error handling for Rack Middleware with default error handler' do
+    it 'raises error for missing secret key' do
+      allow(client).to receive(:update_item).and_raise(missing_key_error)
+      expect { get '/' }.to raise_error(missing_key_error)
     end
 
-    it "catches exception for inaccurate table name and raises error " do
-      client.stub(:update_item).and_raise(resource_error)
-      lambda { get "/" }.should raise_error(resource_error)
+    it 'catches exception for inaccurate table name and raises error ' do
+      allow(client).to receive(:update_item).and_raise(resource_error)
+      expect { get '/' }.to raise_error(resource_error)
     end
 
-    it "catches exception for inaccurate table key" do
-      client.stub(:update_item).and_raise(key_error)
-      client.stub(:get_item).and_raise(key_error)
-      get "/"
-      last_request.env["rack.errors"].string.should include(key_error_msg)
+    it 'catches exception for inaccurate table key' do
+      allow(client).to receive(:update_item).and_raise(key_error)
+      allow(client).to receive(:get_item).and_raise(key_error)
+
+      get '/'
+      expect(last_request.env['rack.errors'].string).to include(key_error_msg)
     end
   end
 
-  context "Test ExceptionHandler with true as return value for handle_error" do
-    it "raises all errors" do
+  context 'Test ExceptionHandler with true as return value for handle_error' do
+    it 'raises all errors' do
       @options[:raise_errors] = true
-      client.stub(:update_item).and_raise(client_error)
-      lambda { get "/" }.should raise_error(client_error)
+      allow(client).to receive(:update_item).and_raise(client_error)
+      expect { get '/' }.to raise_error(client_error)
     end
 
-    it "catches exception for inaccurate table key and raises error" do
+    it 'catches exception for inaccurate table key and raises error' do
       @options[:raise_errors] = true
-      client.stub(:update_item).and_raise(key_error)
-      lambda { get "/" }.should raise_error(key_error)
+      allow(client).to receive(:update_item).and_raise(key_error)
+      expect { get '/' }.to raise_error(key_error)
     end
   end
 end

data/spec/aws/session_store/dynamo_db/garbage_collection_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"). You
@@ -14,80 +16,79 @@
 require 'spec_helper'
 
 describe Aws::SessionStore::DynamoDB::GarbageCollection do
-  def member(min,max)
-    member = []
-    for i in min..max
-      member << {"session_id"=>{:s=>"#{i}"}}
+  def items(min, max)
+    items = []
+    (min..max).each do |i|
+      items << { 'session_id' => { s: i.to_s } }
     end
-    member
+    items
   end
 
   def format_scan_result
-    member = []
-    for i in 31..49
-      member << {"session_id"=>{:s=>"#{i}"}}
+    items = []
+    (31..49).each do |i|
+      items << { 'session_id' => { s: i.to_s } }
     end
 
-    member.inject([]) do |rqst_array, item|
-      rqst_array << {:delete_request => {:key => item}}
-      rqst_array
+    items.each_with_object([]) do |item, rqst_array|
+      rqst_array << { delete_request: { key: item } }
     end
   end
 
   def collect_garbage
-    options = { :dynamo_db_client => dynamo_db_client, :max_age => 100, :max_stale => 100 }
+    options = { dynamo_db_client: dynamo_db_client, max_age: 100, max_stale: 100 }
     Aws::SessionStore::DynamoDB::GarbageCollection.collect_garbage(options)
   end
 
-  let(:scan_resp1){
+  let(:scan_resp1) do
     resp = {
-      :member => member(0, 49),
-      :count => 50,
-      :scanned_count => 1000,
-      :last_evaluated_key => {}
+      items: items(0, 49),
+      count: 50,
+      scanned_count: 1000,
+      last_evaluated_key: {}
     }
-  }
+  end
 
-  let(:scan_resp2){
+  let(:scan_resp2) do
     {
-      :member => member(0, 31),
-      :last_evaluated_key => {"session_id"=>{:s=>"31"}}
+      items: items(0, 31),
+      last_evaluated_key: { 'session_id' => { s: '31' } }
     }
-  }
+  end
 
-  let(:scan_resp3){
+  let(:scan_resp3) do
     {
-      :member => member(31,49),
-      :last_evaluated_key => {}
+      items: items(31, 49),
+      last_evaluated_key: {}
     }
-  }
+  end
 
-  let(:write_resp1){
+  let(:write_resp1) do
     {
-      :unprocessed_items => {}
+      unprocessed_items: {}
     }
-  }
+  end
 
-  let(:write_resp2){
+  let(:write_resp2) do
     {
-      :unprocessed_items => {
-        "sessions" => [
+      unprocessed_items: {
+        'sessions' => [
           {
-            :delete_request => {
-              :key => {
-                "session_id" =>
+            delete_request: {
+              key: {
+                'session_id' =>
                 {
-                  :s => "1"
+                  s: '1'
                 }
               }
             }
           },
           {
-            :delete_request => {
-              :key => {
-                "session_id" =>
+            delete_request: {
+              key: {
+                'session_id' =>
                 {
-                  :s => "17"
+                  s: '17'
                 }
               }
             }
@@ -95,64 +96,62 @@ describe Aws::SessionStore::DynamoDB::GarbageCollection do
         ]
       }
     }
-  }
+  end
 
   let(:dynamo_db_client) {Aws::DynamoDB::Client.new}
 
-  context "Mock DynamoDB client with garbage collection" do
-
-    it "processes scan result greater than 25 and deletes in batches of 25" do
-      dynamo_db_client.should_receive(:scan).
-        exactly(1).times.and_return(scan_resp1)
-      dynamo_db_client.should_receive(:batch_write_item).
+  context 'Mock DynamoDB client with garbage collection' do
+    it 'processes scan result greater than 25 and deletes in batches of 25' do
+      expect(dynamo_db_client).to receive(:scan)
+        .exactly(1).times.and_return(scan_resp1)
+      expect(dynamo_db_client).to receive(:batch_write_item).
         exactly(2).times.and_return(write_resp1)
       collect_garbage
     end
 
-    it "gets scan results then returns last evaluated key and resumes scanning" do
-      dynamo_db_client.should_receive(:scan).
+    it 'gets scan results then returns last evaluated key and resumes scanning' do
+      expect(dynamo_db_client).to receive(:scan).
         exactly(1).times.and_return(scan_resp2)
-      dynamo_db_client.should_receive(:scan).
+      expect(dynamo_db_client).to receive(:scan).
         exactly(1).times.with(hash_including(exclusive_start_key: scan_resp2[:last_evaluated_key])).
         and_return(scan_resp3)
-      dynamo_db_client.should_receive(:batch_write_item).
+      expect(dynamo_db_client).to receive(:batch_write_item).
         exactly(3).times.and_return(write_resp1)
-        collect_garbage
+      collect_garbage
     end
 
-    it "it formats unprocessed_items and then batch deletes them" do
-      dynamo_db_client.should_receive(:scan).
+    it 'it formats unprocessed_items and then batch deletes them' do
+      expect(dynamo_db_client).to receive(:scan).
         exactly(1).times.and_return(scan_resp3)
-      dynamo_db_client.should_receive(:batch_write_item).ordered.
-        with(:request_items => {"sessions" => format_scan_result}).
+      expect(dynamo_db_client).to receive(:batch_write_item).ordered.
+        with(request_items: { 'sessions' => format_scan_result }).
         and_return(write_resp2)
-      dynamo_db_client.should_receive(:batch_write_item).ordered.with(
-        :request_items =>
-        {
-          "sessions" => [
+      expect(dynamo_db_client).to receive(:batch_write_item).ordered.with(
+        request_items: {
+          'sessions' => [
             {
-              :delete_request => {
-                :key => {
-                  "session_id" =>
+              delete_request: {
+                key: {
+                  'session_id' =>
                   {
-                    :s => "1"
+                    s: '1'
                   }
                 }
               }
             },
             {
-              :delete_request => {
-                :key => {
-                  "session_id" =>
+              delete_request: {
+                key: {
+                  'session_id' =>
                   {
-                    :s => "17"
+                    s: '17'
                   }
                 }
               }
             }
           ]
         }
-        ).and_return(write_resp1)
+      ).and_return(write_resp1)
       collect_garbage
     end
   end

data/spec/aws/session_store/dynamo_db/locking/threaded_sessions_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"). You
@@ -11,7 +13,6 @@
 # ANY KIND, either express or implied. See the License for the specific
 # language governing permissions and limitations under the License.
 
-
 require 'spec_helper'
 
 describe Aws::SessionStore::DynamoDB::RackMiddleware do
@@ -20,17 +21,17 @@ describe Aws::SessionStore::DynamoDB::RackMiddleware do
   def thread(mul_val, time, check)
     Thread.new do
       sleep(time)
-      get "/"
-      last_request.session[:multiplier].should eq(mul_val) if check
+      get '/'
+      expect(last_request.session[:multiplier]).to eq(mul_val) if check
     end
   end
 
   def thread_exception(error)
-    Thread.new { expect { get "/" }.to raise_error(error) }
+    Thread.new { expect { get '/' }.to raise_error(error) }
   end
 
   def update_item_mock(options, update_method)
-    if options[:return_values] == "UPDATED_NEW" && options.has_key?(:expected)
+    if options[:return_values] == 'UPDATED_NEW' && options.key?(:expected)
       sleep(0.50)
       update_method.call(options)
     else
@@ -41,23 +42,23 @@ describe Aws::SessionStore::DynamoDB::RackMiddleware do
   let(:base_app) { MultiplierApplication.new }
   let(:app) { Aws::SessionStore::DynamoDB::RackMiddleware.new(base_app, @options) }
 
-  context "Mock Multiple Threaded Sessions", :integration => true do
+  context 'Mock Multiple Threaded Sessions', integration: true do
     before do
       @options = Aws::SessionStore::DynamoDB::Configuration.new.to_hash
       @options[:enable_locking] = true
       @options[:secret_key] = 'watermelon_smiles'
 
       update_method = @options[:dynamo_db_client].method(:update_item)
-      @options[:dynamo_db_client].should_receive(:update_item).at_least(:once) do |options|
+      expect(@options[:dynamo_db_client]).to receive(:update_item).at_least(:once) do |options|
         update_item_mock(options, update_method)
       end
     end
 
-    it "should wait for lock" do
+    it 'should wait for lock' do
       @options[:lock_expiry_time] = 2000
 
-      get "/"
-      last_request.session[:multiplier].should eq(1)
+      get '/'
+      expect(last_request.session[:multiplier]).to eq(1)
 
       t1 = thread(2, 0, false)
       t2 = thread(4, 0.25, true)
@@ -65,11 +66,11 @@ describe Aws::SessionStore::DynamoDB::RackMiddleware do
       t2.join
     end
 
-    it "should bust lock" do
+    it 'should bust lock' do
       @options[:lock_expiry_time] = 100
 
-      get "/"
-      last_request.session[:multiplier].should eq(1)
+      get '/'
+      expect(last_request.session[:multiplier]).to eq(1)
 
       t1 = thread_exception(Aws::DynamoDB::Errors::ConditionalCheckFailedException)
       t2 = thread(2, 0.25, true)
@@ -77,13 +78,13 @@ describe Aws::SessionStore::DynamoDB::RackMiddleware do
       t2.join
     end
 
-    it "should throw exceeded time spent aquiring lock error" do
+    it 'should throw exceeded time spent aquiring lock error' do
       @options[:lock_expiry_time] = 1000
       @options[:lock_retry_delay] = 100
       @options[:lock_max_wait_time] = 0.25
 
-      get "/"
-      last_request.session[:multiplier].should eq(1)
+      get '/'
+      expect(last_request.session[:multiplier]).to eq(1)
 
       t1 = thread(2, 0, false)
       sleep(0.25)

data/spec/aws/session_store/dynamo_db/rack_middleware_database_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License"). You
@@ -22,28 +24,28 @@ module Aws
         instance_exec(&ConstantHelpers)
 
         before do
-          @options = { :secret_key => 'watermelon_cherries' }
+          @options = { secret_key: 'watermelon_cherries' }
         end
 
         # Table options for client
         def table_opts(sid)
           {
-            :table_name => Configuration::DEFAULTS[:table_name],
-            :key => { Configuration::DEFAULTS[:table_key] => sid }
+            table_name: Configuration::DEFAULTS[:table_name],
+            key: { Configuration::DEFAULTS[:table_key] => sid }
           }
         end
 
         # Attributes to be retrieved via client
         def attr_opts
           {
-            :attributes_to_get => ["data", "created_at", "locked_at"],
-            :consistent_read => true
+            attributes_to_get: %w[data created_at locked_at],
+            consistent_read: true
           }
         end
 
         def extract_time(sid)
           options = table_opts(sid).merge(attr_opts)
-          Time.at((client.get_item(options)[:item]["created_at"]).to_f)
+          Time.at((client.get_item(options)[:item]['created_at']).to_f)
         end
 
         let(:base_app) { MultiplierApplication.new }
@@ -51,76 +53,75 @@ module Aws
         let(:config) { Configuration.new }
         let(:client) { config.dynamo_db_client }
 
-        context "Testing best case session storage", :integration => true do
-          it "stores session data in session object" do
-            get "/"
-            last_request.session[:multiplier].should eq(1)
+        context 'Testing best case session storage', integration: true do
+          it 'stores session data in session object' do
+            get '/'
+            expect(last_request.session[:multiplier]).to eq(1)
           end
 
-          it "creates a new HTTP cookie when Cookie not supplied" do
-            get "/"
-            last_response.body.should eq('All good!')
-            last_response['Set-Cookie'].should be_truthy
+          it 'creates a new HTTP cookie when Cookie not supplied' do
+            get '/'
+            expect(last_response.body).to eq('All good!')
+            expect(last_response['Set-Cookie']).to be_truthy
           end
 
-          it "does not rewrite Cookie if cookie previously/accuarately set" do
-            get "/"
-            last_response['Set-Cookie'].should_not be_nil
-
+          it 'does not rewrite Cookie if cookie previously/accuarately set' do
+            get '/'
+            expect(last_response['Set-Cookie']).not_to be_nil
 
-            get "/"
-            last_response['Set-Cookie'].should be_nil
+            get '/'
+            expect(last_response['Set-Cookie']).to be_nil
           end
 
-          it "does not set cookie when defer option is specifed" do
+          it 'does not set cookie when defer option is specified' do
             @options[:defer] = true
-            get "/"
-            last_response['Set-Cookie'].should be_nil
+            get '/'
+            expect(last_response['Set-Cookie']).to be_nil
           end
 
-          it "creates new sessopm with false/nonexistant http-cookie id" do
-            get "/", {}, invalid_cookie.merge(invalid_session_data)
-            last_response['Set-Cookie'].should_not eq("rack.session=ApplePieBlueberries")
-            last_response['Set-Cookie'].should_not be_nil
+          it 'creates new session with false/nonexistant http-cookie id' do
+            get '/', {}, invalid_cookie.merge(invalid_session_data)
+            expect(last_response['Set-Cookie']).not_to eq('rack.session=ApplePieBlueberries')
+            expect(last_response['Set-Cookie']).not_to be_nil
           end
 
-          it "expires after specified time and sets date for cookie to expire" do
+          it 'expires after specified time and sets date for cookie to expire' do
             @options[:expire_after] = 1
-            get "/"
+            get '/'
             session_cookie = last_response['Set-Cookie']
             sleep(1.2)
 
-            get "/"
-            last_response['Set-Cookie'].should_not be_nil
-            last_response['Set-Cookie'].should_not eq(session_cookie)
+            get '/'
+            expect(last_response['Set-Cookie']).not_to be_nil
+            expect(last_response['Set-Cookie']).not_to eq(session_cookie)
           end
 
-          it "will not set a session cookie when defer is true" do
+          it 'will not set a session cookie when defer is true' do
             @options[:defer] = true
-            get "/"
-            last_response['Set-Cookie'].should eq(nil)
+            get '/'
+            expect(last_response['Set-Cookie']).to be_nil
           end
 
-          it "adds the created at attribute for a new session" do
-            get "/"
-            last_request.env["dynamo_db.new_session"].should eq("true")
+          it 'adds the created at attribute for a new session' do
+            get '/'
+            expect(last_request.env['dynamo_db.new_session']).to eq('true')
             sid = last_response['Set-Cookie'].split(/[;\=]/)[1]
             time = extract_time(sid)
-            time.should be_within(2).of(Time.now)
+            expect(time).to be_within(2).of(Time.now)
 
-            get "/"
-            last_request.env['dynamo_db.new_session'].should be(nil)
+            get '/'
+            expect(last_request.env['dynamo_db.new_session']).to be_nil
           end
 
-          it "releases pessimistic lock at finish of transaction" do
+          it 'releases pessimistic lock at finish of transaction' do
             @options[:enable_locking] = true
-            get "/"
-            last_request.env["dynamo_db.new_session"].should eq("true")
+            get '/'
+            expect(last_request.env['dynamo_db.new_session']).to eq('true')
             sid = last_response['Set-Cookie'].split(/[;\=]/)[1]
 
-            get "/"
+            get '/'
             options = table_opts(sid).merge(attr_opts)
-            client.get_item(options)[:item]["locked_at"].should be_nil
+            expect(client.get_item(options)[:item]['locked_at']).to be_nil
           end
         end
       end