fake_sqs 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04b7e156149ca16643c8fde1933bca20aea7434b
-  data.tar.gz: be9d4103aa2987ddbb43839c15f3ef85955b8e18
+  metadata.gz: 5160588ed7c7aea6fa2b5bd7d724b188068eec6e
+  data.tar.gz: 39d0c2eda9bb4c9f7182e4de0ca66e906fd4aa42
 SHA512:
-  metadata.gz: 4ffeacbcc77e857c5c125d90c3eaafdb4bbc068c4f8fc8b11d705d4f3c0e0fa26ef82bd5427cd882ef02e317375b8f35bcdb8399aa3c8bd88aa27763c28e7a89
-  data.tar.gz: 2a8dc5a14fbb7317e7ae6d44e9f79983568a3d204b74359d0cc2932dadd283b9a5ee79008ecb5dc1e649b596afc5ca4d658455cb6e508a420142a706a44e0983
+  metadata.gz: 8a560e5b111974eb836fd19f73d53615e5701e73000ebfbef51952705555b67e11c001caaa46057174482732463ac11d44ff82c01189023105cff5fe2dee491f
+  data.tar.gz: c921ba2c535b4897c777644bf5c96108a6a94ec6a09382a93fcb1b9eba61e99a3d6a348367dd6a18fd2dd31be7af2f92c8e79cc371f2808605a99d4a26da4d1d

data/.rspec

@@ -1,3 +1,4 @@
 --format documentation
 --color
 --order random
+--require spec_helper

data/fake_sqs.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "aws-sdk"
+  gem.add_development_dependency "aws-sdk", "~> 2.0"
   gem.add_development_dependency "faraday"
   gem.add_development_dependency "thin"
   gem.add_development_dependency "verbose_hash_fetch"

data/lib/fake_sqs.rb

@@ -20,8 +20,10 @@ module FakeSQS
     app = FakeSQS::WebInterface
 
     if (log = options[:log])
-      $stdout.reopen(log, "w:utf-8")
-      $stderr.reopen(log, "w:utf-8")
+      file = File.new(log, "a+")
+      file.sync = true
+      app.use Rack::CommonLogger, file
+      app.set :log_file, file
       app.enable :logging
     end
 

data/lib/fake_sqs/show_output.rb

@@ -1,4 +1,5 @@
-require 'rack/request'
+require 'rack'
+require 'yaml'
 
 module FakeSQS
   class ShowOutput
@@ -12,7 +13,7 @@ module FakeSQS
       result = @app.call(env)
       puts request.params.to_yaml
       puts
-      puts *result.last
+      puts(*result.last)
       result
     end
 

data/lib/fake_sqs/test_integration.rb

@@ -50,6 +50,10 @@ module FakeSQS
       "http://#{host}:#{port}"
     end
 
+    def uri
+      URI(url)
+    end
+
     def up?
       @pid && connection.get("/").code.to_s == "200"
     rescue Errno::ECONNREFUSED
@@ -59,7 +63,7 @@ module FakeSQS
     private
 
     def option(key)
-      options.fetch(key) { AWS.config.public_send(key) }
+      options.fetch(key)
     end
 
     def database

data/lib/fake_sqs/version.rb

@@ -1,3 +1,3 @@
 module FakeSQS
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/acceptance/message_actions_spec.rb

@@ -1,99 +1,211 @@
-require "spec_helper"
+require "integration_spec_helper"
+require "securerandom"
 
-describe "Actions for Messages", :sqs do
+RSpec.describe "Actions for Messages", :sqs do
+
+  QUEUE_NAME = "test"
 
   before do
-    sqs.queues.create("test")
+    sqs.config.endpoint = $fake_sqs.uri
+    sqs.create_queue(queue_name: QUEUE_NAME)
   end
 
-  let(:sqs) { AWS::SQS.new }
-  let(:queue) { sqs.queues.named("test") }
+  let(:sqs) { Aws::SQS::Client.new }
+
+  let(:queue_url) { sqs.get_queue_url(queue_name: QUEUE_NAME).queue_url }
 
   specify "SendMessage" do
     msg = "this is my message"
-    result = queue.send_message(msg)
-    result.md5.should eq Digest::MD5.hexdigest(msg)
+
+    result = sqs.send_message(
+      queue_url: queue_url,
+      message_body: msg,
+    )
+
+    expect(result.md5_of_message_body).to eq Digest::MD5.hexdigest(msg)
+    expect(result.message_id.size).to eq 36
   end
 
   specify "ReceiveMessage" do
     body = "test 123"
-    queue.send_message(body)
-    message = queue.receive_message
-    message.body.should eq body
+
+    sqs.send_message(
+      queue_url: queue_url,
+      message_body: body
+    )
+
+    response = sqs.receive_message(
+      queue_url: queue_url,
+    )
+
+    expect(response.messages.size).to eq 1
+
+    expect(response.messages.first.body).to eq body
   end
 
   specify "DeleteMessage" do
-    queue.send_message("test")
+    sqs.send_message(
+      queue_url: queue_url,
+      message_body: "test",
+    )
 
-    message1 = queue.receive_message
-    message1.delete
+    message1 = sqs.receive_message(
+      queue_url: queue_url,
+    ).messages.first
+
+    sqs.delete_message(
+      queue_url: queue_url,
+      receipt_handle: message1.receipt_handle,
+    )
 
     let_messages_in_flight_expire
 
-    message2 = queue.receive_message
-    message2.should be_nil
+    response = sqs.receive_message(
+      queue_url: queue_url,
+    )
+    expect(response.messages.size).to eq 0
   end
 
   specify "DeleteMessageBatch" do
-    queue.send_message("test1")
-    queue.send_message("test2")
-
-    message1 = queue.receive_message
-    message2 = queue.receive_message
-    queue.batch_delete(message1, message2)
+    sqs.send_message(
+      queue_url: queue_url,
+      message_body: "test1"
+    )
+    sqs.send_message(
+      queue_url: queue_url,
+      message_body: "test2"
+    )
+
+    messages_response = sqs.receive_message(
+      queue_url: queue_url,
+      max_number_of_messages: 2,
+    )
+
+    entries = messages_response.messages.map { |msg|
+      {
+        id: SecureRandom.uuid,
+        receipt_handle: msg.receipt_handle,
+      }
+    }
+
+    sqs.delete_message_batch(
+      queue_url: queue_url,
+      entries: entries,
+    )
 
     let_messages_in_flight_expire
 
-    message3 = queue.receive_message
-    message3.should be_nil
+    response = sqs.receive_message(
+      queue_url: queue_url,
+    )
+    expect(response.messages.size).to eq 0
   end
 
   specify "SendMessageBatch" do
     bodies = %w(a b c)
-    queue.batch_send(*bodies)
 
-    messages = queue.receive_message(:limit => 10)
-    messages.map(&:body).should match_array bodies
+    sqs.send_message_batch(
+      queue_url: queue_url,
+      entries: bodies.map { |bd|
+        {
+          id: SecureRandom.uuid,
+          message_body: bd,
+        }
+      }
+    )
+
+    messages_response = sqs.receive_message(
+      queue_url: queue_url,
+      max_number_of_messages: 3,
+    )
+
+    expect(messages_response.messages.map(&:body)).to match_array bodies
   end
 
   specify "set message timeout to 0" do
     body = 'some-sample-message'
-    queue.send_message(body)
-    message = queue.receive_message
-    message.body.should == body
-    message.visibility_timeout = 0
 
-    same_message = queue.receive_message
-    same_message.body.should == body
+    sqs.send_message(
+      queue_url: queue_url,
+      message_body: body,
+    )
+
+    message = sqs.receive_message(
+      queue_url: queue_url,
+    ).messages.first
+
+    expect(message.body).to eq body
+
+    sqs.change_message_visibility(
+      queue_url: queue_url,
+      receipt_handle: message.receipt_handle,
+      visibility_timeout: 0
+    )
+
+    same_message = sqs.receive_message(
+      queue_url: queue_url,
+    ).messages.first
+    expect(same_message.body).to eq body
   end
 
   specify 'set message timeout and wait for message to come' do
 
     body = 'some-sample-message'
-    queue.send_message(body)
-    message = queue.receive_message
-    message.body.should == body
-    message.visibility_timeout = 3
-
-    nothing = queue.receive_message
-    nothing.should be_nil
-
-    sleep(10)
 
-    same_message = queue.receive_message
-    same_message.body.should == body
+    sqs.send_message(
+      queue_url: queue_url,
+      message_body: body,
+    )
+
+    message = sqs.receive_message(
+      queue_url: queue_url,
+    ).messages.first
+    expect(message.body).to eq body
+
+    sqs.change_message_visibility(
+      queue_url: queue_url,
+      receipt_handle: message.receipt_handle,
+      visibility_timeout: 2
+    )
+
+    nothing = sqs.receive_message(
+      queue_url: queue_url,
+    )
+    expect(nothing.messages.size).to eq 0
+
+    sleep(5)
+
+    same_message = sqs.receive_message(
+      queue_url: queue_url,
+    ).messages.first
+    expect(same_message.body).to eq body
   end
 
   specify 'should fail if trying to update the visibility_timeout for a message that is not in flight' do
     body = 'some-sample-message'
-    queue.send_message(body)
-    message = queue.receive_message
-    message.body.should == body
-    message.visibility_timeout = 0
-
-    expect do
-      message.visibility_timeout = 30
-    end.to raise_error(AWS::SQS::Errors::MessageNotInflight)
+    sqs.send_message(
+      queue_url: queue_url,
+      message_body: body,
+    )
+
+    message = sqs.receive_message(
+      queue_url: queue_url,
+    ).messages.first
+    expect(message.body).to eq body
+
+    sqs.change_message_visibility(
+      queue_url: queue_url,
+      receipt_handle: message.receipt_handle,
+      visibility_timeout: 0
+    )
+
+    expect {
+      sqs.change_message_visibility(
+        queue_url: queue_url,
+        receipt_handle: message.receipt_handle,
+        visibility_timeout: 30
+      )
+    }.to raise_error(Aws::SQS::Errors::MessageNotInflight)
   end
 
   def let_messages_in_flight_expire

data/spec/acceptance/queue_actions_spec.rb

@@ -1,61 +1,67 @@
-require "spec_helper"
+require "integration_spec_helper"
+require "pry"
 
-describe "Actions for Queues", :sqs do
+RSpec.describe "Actions for Queues", :sqs do
 
-  let(:sqs) { AWS::SQS.new }
+  let(:sqs) { Aws::SQS::Client.new }
+  before do
+    sqs.config.endpoint = $fake_sqs.uri
+  end
 
   specify "CreateQueue" do
-    queue = sqs.queues.create("test-create-queue")
-    queue.url.should eq "http://0.0.0.0:4568/test-create-queue"
-    queue.arn.should match %r"arn:aws:sqs:us-east-1:.+:test-create-queue"
+    response = sqs.create_queue(queue_name: "test-create-queue")
+    expect(response.queue_url).to eq "http://0.0.0.0:4568/test-create-queue"
+    response2 = sqs.get_queue_attributes(queue_url: response.queue_url)
+    expect(response2.attributes.fetch("QueueArn")).to match %r"arn:aws:sqs:us-east-1:.+:test-create-queue"
   end
 
   specify "GetQueueUrl" do
-    sqs.queues.create("test-get-queue-url")
-    queue = sqs.queues.named("test-get-queue-url")
-    queue.url.should eq "http://0.0.0.0:4568/test-get-queue-url"
+    sqs.create_queue(queue_name: "test-get-queue-url")
+    response = sqs.get_queue_url(queue_name: "test-get-queue-url")
+    expect(response.queue_url).to eq "http://0.0.0.0:4568/test-get-queue-url"
   end
 
   specify "ListQueues" do
-    sqs.queues.create("test-list-1")
-    sqs.queues.create("test-list-2")
-    sqs.queues.map(&:url).should eq [
+    sqs.create_queue(queue_name: "test-list-1")
+    sqs.create_queue(queue_name: "test-list-2")
+    expect(sqs.list_queues.queue_urls).to eq [
       "http://0.0.0.0:4568/test-list-1",
       "http://0.0.0.0:4568/test-list-2"
     ]
   end
 
   specify "ListQueues with prefix" do
-    sqs.queues.create("test-list-1")
-    sqs.queues.create("test-list-2")
-    sqs.queues.create("other-list-3")
-    sqs.queues.with_prefix("test").map(&:url).should eq [
+    sqs.create_queue(queue_name: "test-list-1")
+    sqs.create_queue(queue_name: "test-list-2")
+    sqs.create_queue(queue_name: "other-list-3")
+    expect(sqs.list_queues(queue_name_prefix: "test").queue_urls).to eq [
       "http://0.0.0.0:4568/test-list-1",
       "http://0.0.0.0:4568/test-list-2",
     ]
   end
 
   specify "DeleteQueue" do
-    url = sqs.queues.create("test-delete").url
-    sqs.should have(1).queues
-    sqs.queues[url].delete
-    sqs.should have(0).queues
+    url = sqs.create_queue(queue_name: "test-delete").queue_url
+    expect(sqs.list_queues.queue_urls.size).to eq 1
+    sqs.delete_queue(queue_url: url)
+    expect(sqs.list_queues.queue_urls.size).to eq 0
   end
 
   specify "SetQueueAttributes / GetQueueAttributes" do
+    queue_url = sqs.create_queue(queue_name: "my-queue").queue_url
 
-    policy = AWS::SQS::Policy.new
-    policy.allow(
-      :actions => ['s3:PutObject'],
-      :resources => "arn:aws:s3:::mybucket/mykey/*",
-      :principals => :any
-    ).where(:acl).is("public-read")
 
-    queue = sqs.queues.create("my-queue")
-    queue.policy = policy
+    sqs.set_queue_attributes(
+      queue_url: queue_url,
+      attributes: {
+        "DelaySeconds" => "900"
+      }
+    )
 
-    reloaded_queue = sqs.queues.named("my-queue")
-    reloaded_queue.policy.should eq policy
+    response = sqs.get_queue_attributes(
+      queue_url: queue_url,
+    )
+    expect(response.attributes.fetch("DelaySeconds")).to eq "900"
   end
 
 end

data/spec/integration_spec_helper.rb

@@ -0,0 +1,29 @@
+require "aws-sdk"
+require "fake_sqs/test_integration"
+
+# Aws.config[:credentials] = {
+#   :use_ssl           => false,
+#   :sqs_endpoint      => "localhost",
+#   :sqs_port          => 4568,
+#   :access_key_id     => "fake access key",
+#   :secret_access_key => "fake secret key",
+# }
+Aws.config.update(
+  region: "us-east-1",
+  credentials: Aws::Credentials.new("fake", "fake"),
+)
+
+db = ENV["SQS_DATABASE"] || ":memory:"
+puts "\n\e[34mRunning specs with database \e[33m#{db}\e[0m"
+
+$fake_sqs = FakeSQS::TestIntegration.new(
+  database: db,
+  sqs_endpoint: "localhost",
+  sqs_port: 4568,
+)
+
+RSpec.configure do |config|
+  config.before(:each, :sqs) { $fake_sqs.start }
+  config.before(:each, :sqs) { $fake_sqs.reset }
+  config.after(:suite) { $fake_sqs.stop }
+end

data/spec/spec_helper.rb

@@ -1,23 +1,3 @@
-require "aws-sdk"
-require "fake_sqs/test_integration"
-
-AWS.config(
-  :use_ssl           => false,
-  :sqs_endpoint      => "localhost",
-  :sqs_port          => 4568,
-  :access_key_id     => "fake access key",
-  :secret_access_key => "fake secret key",
-)
-
-db = ENV["SQS_DATABASE"] || ":memory:"
-puts "\n\e[34mRunning specs with database \e[33m#{db}\e[0m"
-$fake_sqs = FakeSQS::TestIntegration.new(database: db)
-
 RSpec.configure do |config|
-
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.before(:each, :sqs) { $fake_sqs.start }
-  config.before(:each, :sqs) { $fake_sqs.reset }
-  config.after(:suite) { $fake_sqs.stop }
-
+  config.disable_monkey_patching!
 end

data/spec/unit/api_spec.rb

@@ -12,7 +12,7 @@ class FakeSQS::Actions::TheAction
 
 end
 
-describe FakeSQS::API do
+RSpec.describe FakeSQS::API do
 
   it "delegates actions to classes" do
     queues = double :queues
@@ -21,8 +21,8 @@ describe FakeSQS::API do
 
     response = api.call("TheAction", {:foo => "bar"})
 
-    response[:options].should eq :queues => queues
-    response[:params].should eq :foo => "bar"
+    expect(response[:options]).to eq :queues => queues
+    expect(response[:params]).to eq :foo => "bar"
   end
 
   it "raises InvalidAction for unknown actions" do
@@ -37,14 +37,14 @@ describe FakeSQS::API do
   it "resets queues" do
     queues = double :queues
     api = FakeSQS::API.new(:queues => queues)
-    queues.should_receive(:reset)
+    expect(queues).to receive(:reset)
     api.reset
   end
 
   it "expires messages in queues" do
     queues = double :queues
     api = FakeSQS::API.new(:queues => queues)
-    queues.should_receive(:expire)
+    expect(queues).to receive(:expire)
     api.expire
   end
 

data/spec/unit/catch_errors_spec.rb

@@ -1,6 +1,6 @@
 require 'fake_sqs/catch_errors'
 
-describe FakeSQS::CatchErrors do
+RSpec.describe FakeSQS::CatchErrors do
 
   let(:app) { double :app }
   let(:error_response) { double :error_response, :status => 500, :body => "X" }
@@ -10,10 +10,10 @@ describe FakeSQS::CatchErrors do
   context "when the app behaves normally" do
 
     let(:normal_response) { double :normal_response }
-    before { app.stub(:call => normal_response) }
+    before { allow(app).to receive(:call).and_return(normal_response) }
 
     it "doesn't modify normal responses" do
-      catch_errors.call({}).should eq normal_response
+      expect(catch_errors.call({})).to eq normal_response
     end
 
   end
@@ -21,21 +21,21 @@ describe FakeSQS::CatchErrors do
   context "when the app raises an exception" do
 
     let(:error) { RuntimeError.new("it went wrong") }
-    before { app.stub(:call).and_raise(error) }
+    before { allow(app).to receive(:call).and_raise(error) }
 
     it "cathes and processes errors" do
-      response.should_receive(:new).with(error)
+      expect(response).to receive(:new).with(error)
       catch_errors.call({})
     end
 
     it "sets the status determined by the error response" do
-      error_response.stub(:status => 123)
-      catch_errors.call({}).fetch(0).should eq 123
+      allow(error_response).to receive(:status).and_return(123)
+      expect(catch_errors.call({}).fetch(0)).to eq 123
     end
 
     it "set the body determined by the error response" do
-      error_response.stub(:body => "foobar")
-      catch_errors.call({}).fetch(2).should eq ["foobar"]
+      allow(error_response).to receive(:body).and_return("foobar")
+      expect(catch_errors.call({}).fetch(2)).to eq ["foobar"]
     end
 
   end

data/spec/unit/collection_view_spec.rb

@@ -1,6 +1,6 @@
 require 'fake_sqs/collection_view'
 
-describe FakeSQS::CollectionView do
+RSpec.describe FakeSQS::CollectionView do
 
   def wrap(collection)
     FakeSQS::CollectionView.new(collection)
@@ -9,33 +9,33 @@ describe FakeSQS::CollectionView do
   it 'should correctly wrap an array' do
     array = %w{one two three four}
     view = wrap(array)
-    view[0].should == 'one'
-    view[1].should == 'two'
-    view[2].should == 'three'
-    view[3].should == 'four'
+    expect(view[0]).to eq 'one'
+    expect(view[1]).to eq 'two'
+    expect(view[2]).to eq 'three'
+    expect(view[3]).to eq 'four'
   end
 
   it 'should correctly wrap a hash' do
     hash = { :one => 1, :two => 2, :three => 3 }
     view = wrap(hash)
-    view[:one].should == 1
-    view[:two].should == 2
-    view[:three].should == 3
+    expect(view[:one]).to eq 1
+    expect(view[:two]).to eq 2
+    expect(view[:three]).to eq 3
   end
 
   it 'should respond to empty correctly' do
-    wrap([]).should be_empty
-    wrap({'one' => 1}).should_not be_empty
+    expect(wrap([])).to be_empty
+    expect(wrap({'one' => 1})).to_not be_empty
   end
 
   it 'should be enumerable' do
     result = wrap([1, 2, 3]).map { |i| i * i }
-    result.should == [1, 4, 9]
+    expect(result).to eq [1, 4, 9]
   end
 
   it 'should respond to size/length' do
-    wrap([1, 2, 3]).size.should == 3
-    wrap([]).length.should == 0
+    expect(wrap([1, 2, 3]).size).to eq 3
+    expect(wrap([]).size).to eq 0
   end
 
-end
+end

data/spec/unit/error_response_spec.rb

@@ -2,7 +2,7 @@ require 'fake_sqs/error_response'
 require 'active_support/core_ext/hash'
 require 'verbose_hash_fetch'
 
-describe FakeSQS::ErrorResponse do
+RSpec.describe FakeSQS::ErrorResponse do
 
   module FakeSQS
     MissingCredentials = Class.new(RuntimeError)
@@ -14,13 +14,13 @@ describe FakeSQS::ErrorResponse do
     it "picks the right error status" do
       error = FakeSQS::MissingCredentials.new("message")
       response = FakeSQS::ErrorResponse.new(error)
-      response.status.should eq 401
+      expect(response.status).to eq 401
     end
 
     it "uses 400 as default status" do
       error = ErrorUnknownToSQS.new("message")
       response = FakeSQS::ErrorResponse.new(error)
-      response.status.should eq 500
+      expect(response.status).to eq 500
     end
 
   end
@@ -32,32 +32,32 @@ describe FakeSQS::ErrorResponse do
     let(:data) { Hash.from_xml(response.body) }
 
     it "uses the error class name as error code" do
-      data.fetch("ErrorResponse").fetch("Error").fetch("Code").should eq "MissingCredentials"
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Code")).to eq "MissingCredentials"
     end
 
     it "uses InternalError as code for unknown errors" do
       error = ErrorUnknownToSQS.new("the message")
       response = FakeSQS::ErrorResponse.new(error)
       data = Hash.from_xml(response.body)
-      data.fetch("ErrorResponse").fetch("Error").fetch("Code").should eq "InternalError"
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Code")).to eq "InternalError"
     end
 
     it "uses the to_s of the error as message" do
-      data.fetch("ErrorResponse").fetch("Error").fetch("Message").should eq "the message"
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Message")).to eq "the message"
     end
 
     it "has a request id" do
-      data.fetch("ErrorResponse").fetch("RequestId").should have(36).characters
+      expect(data.fetch("ErrorResponse").fetch("RequestId").size).to eq 36
     end
 
     it "uses Sender as type for 4xx responses" do
-      response.stub(:status => 400)
-      data.fetch("ErrorResponse").fetch("Error").fetch("Type").should eq "Sender"
+      allow(response).to receive(:status).and_return(400)
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Type")).to eq "Sender"
     end
 
     it "uses Receiver as type for 5xx responses" do
-      response.stub(:status => 500)
-      data.fetch("ErrorResponse").fetch("Error").fetch("Type").should eq "Receiver"
+      allow(response).to receive(:status).and_return(500)
+      expect(data.fetch("ErrorResponse").fetch("Error").fetch("Type")).to eq "Receiver"
     end
 
   end

data/spec/unit/message_spec.rb

@@ -1,12 +1,12 @@
 require 'fake_sqs/message'
 
-describe FakeSQS::Message do
+RSpec.describe FakeSQS::Message do
 
   describe "#body" do
 
     it "is extracted from the MessageBody" do
       message = create_message("MessageBody" => "abc")
-      message.body.should eq "abc"
+      expect(message.body).to eq "abc"
     end
 
   end
@@ -15,7 +15,7 @@ describe FakeSQS::Message do
 
     it "is calculated from body" do
       message = create_message("MessageBody" => "abc")
-      message.md5.should eq "900150983cd24fb0d6963f7d28e17f72"
+      expect(message.md5).to eq "900150983cd24fb0d6963f7d28e17f72"
     end
 
   end
@@ -24,7 +24,7 @@ describe FakeSQS::Message do
 
     it "is generated" do
       message = create_message
-      message.id.should have(36).characters
+      expect(message.id.size).to eq 36
     end
 
   end
@@ -36,26 +36,26 @@ describe FakeSQS::Message do
     end
 
     it 'should default to nil' do
-      message.visibility_timeout.should be_nil
+      expect(message.visibility_timeout).to eq nil
     end
 
     it 'should be expired when it is nil' do
-      message.should be_expired
+      expect(message).to be_expired
     end
 
     it 'should be expired if set to a previous time' do
       message.visibility_timeout = Time.now - 1
-      message.should be_expired
+      expect(message).to be_expired
     end
 
     it 'should not be expired at a future date' do
       message.visibility_timeout = Time.now + 1
-      message.should_not be_expired
+      expect(message).not_to be_expired
     end
 
     it 'should not be expired when set to expire at a future date' do
       message.expire_at(5)
-      message.visibility_timeout.should be >=(Time.now + 4)
+      expect(message.visibility_timeout).to be >=(Time.now + 4)
     end
 
   end

data/spec/unit/queue_factory_spec.rb

@@ -1,12 +1,12 @@
 require 'fake_sqs/queue_factory'
 
-describe FakeSQS::QueueFactory do
+RSpec.describe FakeSQS::QueueFactory do
 
   it "builds queues with a message factory" do
     message_factory = double :message_factory
     queue = double :queue
     queue_factory = FakeSQS::QueueFactory.new(message_factory: message_factory, queue: queue)
-    queue.should_receive(:new).with(message_factory: message_factory, name: "Foo")
+    expect(queue).to receive(:new).with(message_factory: message_factory, name: "Foo")
     queue_factory.new(name: "Foo")
   end
 

data/spec/unit/queue_spec.rb

@@ -1,7 +1,7 @@
 require 'fake_sqs/queue'
 require 'fake_sqs/message'
 
-describe FakeSQS::Queue do
+RSpec.describe FakeSQS::Queue do
 
   class MessageFactory
     def new(options = {})
@@ -15,20 +15,20 @@ describe FakeSQS::Queue do
   describe "#send_message" do
 
     it "adds a message" do
-      queue.should have(0).messages
+      expect(queue.messages.size).to eq 0
       send_message
-      queue.should have(1).messages
+      expect(queue.messages.size).to eq 1
     end
 
     it "returns the message" do
       message = double.as_null_object
-      message_factory.stub(:new).and_return(message)
-      send_message.should eq message
+      allow(message_factory).to receive(:new).and_return(message)
+      expect(send_message).to eq message
     end
 
     it "uses the message factory" do
       options = { "MessageBody" => "abc" }
-      message_factory.should_receive(:new).with(options)
+      expect(message_factory).to receive(:new).with(options)
       send_message(options)
     end
 
@@ -39,7 +39,7 @@ describe FakeSQS::Queue do
     it "gets the message" do
       sent = send_message
       received = receive_message
-      received.values.first.should eq sent
+      expect(received.values.first).to eq sent
     end
 
     it "gets you a random message" do
@@ -60,10 +60,10 @@ describe FakeSQS::Queue do
         reset_queue
       end
 
-      (indexes[:first] + indexes[:second]).should eq sample_group
+      expect(indexes[:first] + indexes[:second]).to eq sample_group
 
-      indexes[:first].should be_within(ten_percent).of(half_sample_group)
-      indexes[:second].should be_within(ten_percent).of(half_sample_group)
+      expect(indexes[:first]).to be_within(ten_percent).of(half_sample_group)
+      expect(indexes[:second]).to be_within(ten_percent).of(half_sample_group)
     end
 
     it "cannot get received messages" do
@@ -75,9 +75,9 @@ describe FakeSQS::Queue do
         received_first  = receive_message.values.first
 
         if received_first == sent_first
-          receive_message.values.first.should eq sent_second
+          expect(receive_message.values.first).to eq sent_second
         else
-          receive_message.values.first.should eq sent_first
+          expect(receive_message.values.first).to eq sent_first
         end
         reset_queue
       end
@@ -87,23 +87,23 @@ describe FakeSQS::Queue do
 
       send_message
 
-      queue.should have(0).messages_in_flight
-      queue.attributes["ApproximateNumberOfMessagesNotVisible"].should eq 0
-      queue.attributes["ApproximateNumberOfMessages"].should eq 1
+      expect(queue.messages_in_flight.size).to eq 0
+      expect(queue.attributes["ApproximateNumberOfMessagesNotVisible"]).to eq 0
+      expect(queue.attributes["ApproximateNumberOfMessages"]).to eq 1
 
       receive_message
 
-      queue.should have(1).messages_in_flight
-      queue.attributes["ApproximateNumberOfMessagesNotVisible"].should eq 1
-      queue.attributes["ApproximateNumberOfMessages"].should eq 0
+      expect(queue.messages_in_flight.size).to eq 1
+      expect(queue.attributes["ApproximateNumberOfMessagesNotVisible"]).to eq 1
+      expect(queue.attributes["ApproximateNumberOfMessages"]).to eq 0
     end
 
     it "gets multiple message" do
       sent_first  = send_message
       sent_second = send_message
       messages = receive_message("MaxNumberOfMessages" => "2")
-      messages.size.should eq 2
-      messages.values.should match_array [ sent_first, sent_second ]
+      expect(messages.size).to eq 2
+      expect(messages.values).to match_array [ sent_first, sent_second ]
     end
 
     it "won't accept more than 10 message" do
@@ -113,7 +113,7 @@ describe FakeSQS::Queue do
     end
 
     it "won't error on empty queues" do
-      receive_message.should eq({})
+      expect(receive_message).to eq({})
     end
 
   end
@@ -124,10 +124,10 @@ describe FakeSQS::Queue do
       send_message
       receipt = receive_message.keys.first
 
-      queue.should have(1).messages_in_flight
+      expect(queue.messages_in_flight.size).to eq 1
       queue.delete_message(receipt)
-      queue.should have(0).messages_in_flight
-      queue.should have(0).messages
+      expect(queue.messages_in_flight.size).to eq 0
+      expect(queue.messages.size).to eq 0
     end
 
     it "won't raise if the receipt is unknown" do
@@ -140,7 +140,7 @@ describe FakeSQS::Queue do
 
     it "adds to it's queue attributes" do
       queue.add_queue_attributes("foo" => "bar")
-      queue.attributes.should eq(
+      expect(queue.attributes).to eq(
         "foo"                                   => "bar",
         "QueueArn"                              => queue.arn,
         "ApproximateNumberOfMessages"           => 0,

data/spec/unit/queues_spec.rb

@@ -1,7 +1,7 @@
 require 'fake_sqs/queues'
 require 'fake_sqs/memory_database'
 
-describe FakeSQS::Queues do
+RSpec.describe FakeSQS::Queues do
 
   let(:fake_database) { FakeSQS::MemoryDatabase.new }
   let(:queue_factory) { double :queue_factory, :new => double }
@@ -10,21 +10,21 @@ describe FakeSQS::Queues do
   describe "#create" do
 
     it "creates new queues" do
-      queues.list.size.should eq 0
+      expect(queues.list.size).to eq 0
       create_queue("test")
-      queues.list.size.should eq 1
+      expect(queues.list.size).to eq 1
     end
 
     it "uses the queue factory" do
       params = double :params
-      queue_factory.should_receive(:new).with(params)
+      expect(queue_factory).to receive(:new).with(params)
       create_queue("test", params)
     end
 
     it "returns the queue" do
       queue = double
-      queue_factory.stub(:new).and_return(queue)
-      create_queue("test").should eq queue
+      allow(queue_factory).to receive(:new).and_return(queue)
+      expect(create_queue("test")).to eq queue
     end
 
     it "cannot create a queue with the same name" do
@@ -40,9 +40,9 @@ describe FakeSQS::Queues do
 
     it "deletes an existing queue" do
       create_queue("test")
-      queues.list.size.should eq 1
+      expect(queues.list.size).to eq 1
       queues.delete("test")
-      queues.list.size.should eq 0
+      expect(queues.list.size).to eq 0
     end
 
     it "cannot delete an non-existing queue" do
@@ -58,14 +58,14 @@ describe FakeSQS::Queues do
     it "returns all the queues" do
       queue1 = create_queue("test-1")
       queue2 = create_queue("test-2")
-      queues.list.should eq [ queue1, queue2 ]
+      expect(queues.list).to eq [ queue1, queue2 ]
     end
 
     it "can be filtered by prefix" do
       queue1 = create_queue("test-1")
       queue2 = create_queue("test-2")
       _ = create_queue("other-3")
-      queues.list("QueueNamePrefix" => "test").should eq [ queue1, queue2 ]
+      expect(queues.list("QueueNamePrefix" => "test")).to eq [ queue1, queue2 ]
     end
 
   end
@@ -74,7 +74,7 @@ describe FakeSQS::Queues do
 
     it "finds the queue by name" do
       queue = create_queue("test")
-      queues.get("test").should eq queue
+      expect(queues.get("test")).to eq queue
     end
 
     it "cannot get the queue if it doesn't exist" do
@@ -90,9 +90,9 @@ describe FakeSQS::Queues do
     it "clears all queues" do
       create_queue("foo")
       create_queue("bar")
-      queues.list.size.should eq 2
+      expect(queues.list.size).to eq 2
       queues.reset
-      queues.list.size.should eq 0
+      expect(queues.list.size).to eq 0
     end
 
   end

data/spec/unit/responder_spec.rb

@@ -2,11 +2,11 @@ require 'fake_sqs/responder'
 require 'active_support/core_ext/hash'
 require 'verbose_hash_fetch'
 
-describe FakeSQS::Responder do
+RSpec.describe FakeSQS::Responder do
 
   it "yields xml" do
-    xml = subject.call :GetQueueUrl do |xml|
-      xml.QueueUrl "example.com"
+    xml = subject.call :GetQueueUrl do |x|
+      x.QueueUrl "example.com"
     end
 
     data = Hash.from_xml(xml)
@@ -14,7 +14,7 @@ describe FakeSQS::Responder do
       fetch("GetQueueUrlResponse").
       fetch("GetQueueUrlResult").
       fetch("QueueUrl")
-    url.should eq "example.com"
+    expect(url).to eq "example.com"
   end
 
   it "skips result if no block is given" do
@@ -23,12 +23,12 @@ describe FakeSQS::Responder do
     data = Hash.from_xml(xml)
 
     response = data.fetch("DeleteQueueResponse")
-    response.should have_key("ResponseMetadata")
-    response.should_not have_key("DeleteQueueResult")
+    expect(response).to have_key("ResponseMetadata")
+    expect(response).not_to have_key("DeleteQueueResult")
   end
 
   it "has metadata" do
-    xml = subject.call :GetQueueUrl do |xml|
+    xml = subject.call :GetQueueUrl do |x|
     end
 
     data = Hash.from_xml(xml)
@@ -38,7 +38,7 @@ describe FakeSQS::Responder do
       fetch("ResponseMetadata").
       fetch("RequestId")
 
-    request_id.should have(36).characters
+    expect(request_id.size).to eq 36
   end
 
 end

data/spec/unit/show_output_spec.rb

@@ -1,6 +1,6 @@
 require 'fake_sqs/show_output'
 
-describe FakeSQS::ShowOutput do
+RSpec.describe FakeSQS::ShowOutput do
 
   after do
     $stdout = STDOUT
@@ -11,12 +11,12 @@ describe FakeSQS::ShowOutput do
     $stdout = StringIO.new
     middleware = FakeSQS::ShowOutput.new(app)
     env = {"rack.input" => ""}
-    app.should_receive(:call).with(env).and_return([200, {}, ["<xml>"]])
+    expect(app).to receive(:call).with(env).and_return([200, {}, ["<xml>"]])
 
     middleware.call(env)
 
     $stdout.rewind
-    $stdout.read.should eq "--- {}\n\n<xml>\n"
+    expect($stdout.read).to eq "--- {}\n\n<xml>\n"
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fake_sqs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - iain
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-05 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -70,16 +70,16 @@ dependencies:
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +186,7 @@ files:
 - lib/fake_sqs/web_interface.rb
 - spec/acceptance/message_actions_spec.rb
 - spec/acceptance/queue_actions_spec.rb
+- spec/integration_spec_helper.rb
 - spec/spec_helper.rb
 - spec/unit/api_spec.rb
 - spec/unit/catch_errors_spec.rb
@@ -217,13 +218,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Provides a fake SQS server that you can run locally to test against
 test_files:
 - spec/acceptance/message_actions_spec.rb
 - spec/acceptance/queue_actions_spec.rb
+- spec/integration_spec_helper.rb
 - spec/spec_helper.rb
 - spec/unit/api_spec.rb
 - spec/unit/catch_errors_spec.rb
@@ -235,3 +237,4 @@ test_files:
 - spec/unit/queues_spec.rb
 - spec/unit/responder_spec.rb
 - spec/unit/show_output_spec.rb
+has_rdoc: