pusher-fake 0.13.0 → 0.14.0

data/spec/lib/pusher-fake/server/application_spec.rb

@@ -19,26 +19,32 @@ shared_examples_for "an API request" do
 
   it "creates a request" do
     subject.call(environment)
-    Rack::Request.should have_received(:new).with(environment)
+
+    expect(Rack::Request).to have_received(:new).with(environment)
   end
 
   it "dumps the response hash to JSON" do
     subject.call(environment)
-    MultiJson.should have_received(:dump).with(hash)
+
+    expect(MultiJson).to have_received(:dump).with(hash)
   end
 
   it "creates a Rack response with the response JSON" do
     subject.call(environment)
-    Rack::Response.should have_received(:new).with(string)
+
+    expect(Rack::Response).to have_received(:new).with(string)
   end
 
   it "finishes the response" do
     subject.call(environment)
-    response.should have_received(:finish).with()
+
+    expect(response).to have_received(:finish).with()
   end
 
   it "returns the response" do
-    subject.call(environment).should == response
+    result = subject.call(environment)
+
+    expect(result).to eq(response)
   end
 end
 
@@ -53,7 +59,8 @@ describe PusherFake::Server::Application, ".call, for triggering events" do
 
     it "emits events" do
       subject.call(environment)
-      subject.should have_received(:events).with(request)
+
+      expect(subject).to have_received(:events).with(request)
     end
   end
 end
@@ -69,7 +76,8 @@ describe PusherFake::Server::Application, ".call, for retrieving occupied channe
 
     it "filters the occupied channels" do
       subject.call(environment)
-      subject.should have_received(:channels).with(request)
+
+      expect(subject).to have_received(:channels).with(request)
     end
   end
 end
@@ -92,21 +100,26 @@ describe PusherFake::Server::Application, ".call, with unknown path" do
 
   it "creates a request" do
     subject.call(environment)
-    Rack::Request.should have_received(:new).with(environment)
+
+    expect(Rack::Request).to have_received(:new).with(environment)
   end
 
   it "creates a Rack response with the error message" do
     subject.call(environment)
-    Rack::Response.should have_received(:new).with(message, 400)
+
+    expect(Rack::Response).to have_received(:new).with(message, 400)
   end
 
   it "finishes the response" do
     subject.call(environment)
-    response.should have_received(:finish).with()
+
+    expect(response).to have_received(:finish).with()
   end
 
   it "returns the response" do
-    subject.call(environment).should == response
+    result = subject.call(environment)
+
+    expect(result).to eq(response)
   end
 end
 
@@ -131,21 +144,26 @@ describe PusherFake::Server::Application, ".call, raising an error" do
 
   it "creates a request" do
     subject.call(environment)
-    Rack::Request.should have_received(:new).with(environment)
+
+    expect(Rack::Request).to have_received(:new).with(environment)
   end
 
   it "creates a Rack response with the error message" do
     subject.call(environment)
-    Rack::Response.should have_received(:new).with(message, 400)
+
+    expect(Rack::Response).to have_received(:new).with(message, 400)
   end
 
   it "finishes the response" do
     subject.call(environment)
-    response.should have_received(:finish).with()
+
+    expect(response).to have_received(:finish).with()
   end
 
   it "returns the response" do
-    subject.call(environment).should == response
+    result = subject.call(environment)
+
+    expect(result).to eq(response)
   end
 end
 
@@ -171,22 +189,23 @@ describe PusherFake::Server::Application, ".events" do
 
   it "parses the request body as JSON" do
     subject.events(request)
-    MultiJson.should have_received(:load).with(json)
+
+    expect(MultiJson).to have_received(:load).with(json)
   end
 
   it "creates channels by name" do
     subject.events(request)
 
     channels.each do |channel|
-      PusherFake::Channel.should have_received(:factory).with(channel)
+      expect(PusherFake::Channel).to have_received(:factory).with(channel)
     end
   end
 
   it "emits the event to the channels" do
     subject.events(request)
 
-    channel_1.should have_received(:emit).with(name, data, socket_id: socket_id)
-    channel_2.should have_received(:emit).with(name, data, socket_id: socket_id)
+    expect(channel_1).to have_received(:emit).with(name, data, socket_id: socket_id)
+    expect(channel_2).to have_received(:emit).with(name, data, socket_id: socket_id)
   end
 end
 
@@ -201,12 +220,9 @@ describe PusherFake::Server::Application, ".channels, requesting all channels" d
   end
 
   it "returns a hash of all the channels" do
-    subject.channels(request).should == {
-      channels: {
-        "channel-1" => {},
-        "channel-2" => {}
-      }
-    }
+    hash = subject.channels(request)
+
+    expect(hash).to eq({ channels: { "channel-1" => {}, "channel-2" => {} } })
   end
 end
 
@@ -222,7 +238,9 @@ describe PusherFake::Server::Application, ".channels, requesting channels with a
   end
 
   it "returns a hash of the channels matching the filter" do
-    subject.channels(request).should == { channels: { "public-1" => {} } }
+    hash = subject.channels(request)
+
+    expect(hash).to eq({ channels: { "public-1" => {} } })
   end
 end
 
@@ -239,7 +257,9 @@ describe PusherFake::Server::Application, ".channels, requesting user count for
   end
 
   it "returns a hash of the channels matching the filter and include the user count" do
-    subject.channels(request).should == { channels: { "presence-1" => { user_count: 2 } } }
+    hash = subject.channels(request)
+
+    expect(hash).to eq({ channels: { "presence-1" => { user_count: 2 } } })
   end
 end
 
@@ -254,7 +274,9 @@ describe PusherFake::Server::Application, ".channels, requesting all channels wi
   end
 
   it "returns a hash of no channels" do
-    subject.channels(request).should == { channels: {} }
+    hash = subject.channels(request)
+
+    expect(hash).to eq({ channels: {} })
   end
 end
 
@@ -284,7 +306,9 @@ describe PusherFake::Server::Application, ".channel, for an occupied channel" do
   end
 
   it "returns a hash with the occupied status" do
-    subject.channel(name, request).should == { occupied: true }
+    hash = subject.channel(name, request)
+
+    expect(hash).to eq({ occupied: true })
   end
 end
 
@@ -301,7 +325,9 @@ describe PusherFake::Server::Application, ".channel, for an unoccupied channel"
   end
 
   it "returns a hash with the occupied status" do
-    subject.channel(name, request).should == { occupied: false }
+    hash = subject.channel(name, request)
+
+    expect(hash).to eq({ occupied: false })
   end
 end
 
@@ -316,7 +342,9 @@ describe PusherFake::Server::Application, ".channel, for an unknown channel" do
   end
 
   it "returns a hash with the occupied status" do
-    subject.channel("fake", request).should == { occupied: false }
+    hash = subject.channel("fake", request)
+
+    expect(hash).to eq({ occupied: false })
   end
 end
 
@@ -334,7 +362,9 @@ describe PusherFake::Server::Application, ".channel, request user count for a pr
   end
 
   it "returns a hash with the occupied status" do
-    subject.channel(name, request).should == { occupied: true, user_count: 2 }
+    hash = subject.channel(name, request)
+
+    expect(hash).to eq({ occupied: true, user_count: 2 })
   end
 end
 
@@ -365,10 +395,12 @@ describe PusherFake::Server::Application, ".users, for an occupied channel" do
   end
 
   it "returns a hash with the occupied status" do
-    subject.users(name).should == { users: [
+    hash = subject.users(name)
+
+    expect(hash).to eq({ users: [
       { id: user_1.object_id },
       { id: user_2.object_id }
-    ] }
+    ] })
   end
 end
 
@@ -384,7 +416,9 @@ describe PusherFake::Server::Application, ".users, for an empty channel" do
   end
 
   it "returns a hash with the occupied status" do
-    subject.users(name).should == { users: [] }
+    hash = subject.users(name)
+
+    expect(hash).to eq({ users: [] })
   end
 end
 
@@ -398,6 +432,8 @@ describe PusherFake::Server::Application, ".users, for an unknown channel" do
   end
 
   it "returns a hash with the occupied status" do
-    subject.users("fake").should == { users: [] }
+    hash = subject.users("fake")
+
+    expect(hash).to eq({ users: [] })
   end
 end

data/spec/lib/pusher-fake/server_spec.rb

@@ -10,27 +10,32 @@ describe PusherFake::Server, ".start" do
 
   it "runs the event loop" do
     subject.start
-    EventMachine.should have_received(:run).with()
+
+    expect(EventMachine).to have_received(:run).with()
   end
 
   it "starts the socket web server when run yields" do
     subject.start
-    subject.should have_received(:start_web_server).never
+
+    expect(subject).to have_received(:start_web_server).never
 
     EventMachine.stubs(:run).yields
 
     subject.start
-    subject.should have_received(:start_web_server).with()
+
+    expect(subject).to have_received(:start_web_server).with()
   end
 
   it "starts the socket server when run yields" do
     subject.start
-    subject.should have_received(:start_socket_server).never
+
+    expect(subject).to have_received(:start_socket_server).never
 
     EventMachine.stubs(:run).yields
 
     subject.start
-    subject.should have_received(:start_socket_server).with()
+
+    expect(subject).to have_received(:start_socket_server).with()
   end
 end
 
@@ -52,76 +57,90 @@ describe PusherFake::Server, ".start_socket_server" do
 
   it "creates a WebSocket server" do
     subject.start_socket_server
-    EventMachine::WebSocket.should have_received(:start).with(options)
+
+    expect(EventMachine::WebSocket).to have_received(:start).with(options)
   end
 
   it "defines an open callback on the socket" do
     subject.start_socket_server
-    socket.should have_received(:onopen).with()
+
+    expect(socket).to have_received(:onopen).with()
   end
 
   it "creates a connection with the provided socket when onopen yields" do
     subject.start_socket_server
-    PusherFake::Connection.should have_received(:new).never
+
+    expect(PusherFake::Connection).to have_received(:new).never
 
     socket.stubs(:onopen).yields
 
     subject.start_socket_server
-    PusherFake::Connection.should have_received(:new).with(socket)
+
+    expect(PusherFake::Connection).to have_received(:new).with(socket)
   end
 
   it "establishes the connection when onopen yields" do
     subject.start_socket_server
-    connection.should have_received(:establish).never
+
+    expect(connection).to have_received(:establish).never
 
     socket.stubs(:onopen).yields
 
     subject.start_socket_server
-    connection.should have_received(:establish).with()
+
+    expect(connection).to have_received(:establish).with()
   end
 
   it "defines a message callback on the socket when onopen yields" do
     subject.start_socket_server
-    socket.should have_received(:onmessage).never
+
+    expect(socket).to have_received(:onmessage).never
 
     socket.stubs(:onopen).yields
 
     subject.start_socket_server
-    socket.should have_received(:onmessage).with()
+
+    expect(socket).to have_received(:onmessage).with()
   end
 
   it "triggers process on the connection when onmessage yields" do
     socket.stubs(:onopen).yields
 
     subject.start_socket_server
-    connection.should have_received(:process).never
+
+    expect(connection).to have_received(:process).never
 
     socket.stubs(:onmessage).yields(data)
 
     subject.start_socket_server
-    connection.should have_received(:process).with(data)
+
+    expect(connection).to have_received(:process).with(data)
   end
 
   it "defines a close callback on the socket when onopen yields" do
     subject.start_socket_server
-    socket.should have_received(:onclose).never
+
+    expect(socket).to have_received(:onclose).never
 
     socket.stubs(:onopen).yields
 
     subject.start_socket_server
-    socket.should have_received(:onclose).with()
+
+    expect(socket).to have_received(:onclose).with()
   end
 
   it "removes the connection from all channels when onclose yields" do
     socket.stubs(:onopen).yields
 
     subject.start_socket_server
-    PusherFake::Channel.should have_received(:remove).never
+
+    expect(PusherFake::Channel).to have_received(:remove).never
 
     socket.stubs(:onclose).yields
 
     subject.start_socket_server
-    PusherFake::Channel.should have_received(:remove).with(connection)
+
+    expect(PusherFake::Channel).to have_received(:remove).with(connection)
   end
 end
 
@@ -141,21 +160,25 @@ describe PusherFake::Server, ".start_web_server" do
 
   it "silences the logging" do
     subject.start_web_server
-    Thin::Logging.should have_received(:silent=).with(true)
+
+    expect(Thin::Logging).to have_received(:silent=).with(true)
   end
 
   it "creates the web server" do
     subject.start_web_server
-    Thin::Server.should have_received(:new).with(host, port, PusherFake::Server::Application)
+
+    expect(Thin::Server).to have_received(:new).with(host, port, PusherFake::Server::Application)
   end
 
   it "assigns custom options to the server" do
     subject.start_web_server
-    server.should have_received(:ssl=).with(true)
+
+    expect(server).to have_received(:ssl=).with(true)
   end
 
   it "starts the web server" do
     subject.start_web_server
-    server.should have_received(:start!).with()
+
+    expect(server).to have_received(:start!).with()
   end
 end

data/spec/lib/pusher-fake/webhook_spec.rb

@@ -19,17 +19,21 @@ describe PusherFake::Webhook, ".trigger" do
 
   it "generates a signature" do
     subject.trigger(name, data)
-    OpenSSL::HMAC.should have_received(:hexdigest).with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, payload)
+
+    expect(OpenSSL::HMAC).to have_received(:hexdigest)
+      .with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, payload)
   end
 
   it "creates a HTTP request for each webhook URL" do
     subject.trigger(name, data)
-    EventMachine::HttpRequest.should have_received(:new).with(webhooks.first)
+
+    expect(EventMachine::HttpRequest).to have_received(:new).with(webhooks.first)
   end
 
   it "posts the payload to the webhook URL" do
     subject.trigger(name, data)
-    http.should have_received(:post).with(
+
+    expect(http).to have_received(:post).with(
       body: payload,
       head: {
         "Content-Type"       => "application/json",