pusher-fake 1.2.0 → 1.3.0

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

@@ -4,55 +4,56 @@ describe PusherFake::Server, ".start" do
   subject { PusherFake::Server }
 
   before do
-    subject.stubs(start_web_server: nil, start_socket_server: nil)
-    EventMachine.stubs(run: nil)
+    allow(subject).to receive(:start_web_server).and_return(nil)
+    allow(subject).to receive(:start_socket_server).and_return(nil)
+    allow(EventMachine).to receive(:run).and_return(nil)
   end
 
   it "runs the event loop" do
     subject.start
 
-    expect(EventMachine).to have_received(:run).with()
+    expect(EventMachine).to have_received(:run).with(no_args)
   end
 
   it "starts the socket web server when run yields" do
     subject.start
 
-    expect(subject).to have_received(:start_web_server).never
+    expect(subject).to_not have_received(:start_web_server)
 
-    EventMachine.stubs(:run).yields
+    allow(EventMachine).to receive(:run).and_yield
 
     subject.start
 
-    expect(subject).to have_received(:start_web_server).with()
+    expect(subject).to have_received(:start_web_server).with(no_args)
   end
 
   it "starts the socket server when run yields" do
     subject.start
 
-    expect(subject).to have_received(:start_socket_server).never
+    expect(subject).to_not have_received(:start_socket_server)
 
-    EventMachine.stubs(:run).yields
+    allow(EventMachine).to receive(:run).and_yield
 
     subject.start
 
-    expect(subject).to have_received(:start_socket_server).with()
+    expect(subject).to have_received(:start_socket_server).with(no_args)
   end
 end
 
 describe PusherFake::Server, ".start_socket_server" do
-  let(:data)          { stub }
-  let(:socket)        { stub(onopen: nil, onmessage: nil, onclose: nil) }
+  let(:data)          { double }
+  let(:socket)        { double(:socket, onopen: nil, onmessage: nil, onclose: nil) }
   let(:options)       { configuration.socket_options }
-  let(:connection)    { stub(establish: nil, process: nil) }
-  let(:configuration) { stub(socket_options: { host: "192.168.0.1", port: 8080 }) }
+  let(:connection)    { double(:connection, establish: nil, process: nil) }
+  let(:configuration) { double(:configuration, socket_options: { host: "192.168.0.1", port: 8080 }) }
 
   subject { PusherFake::Server }
 
   before do
-    PusherFake.stubs(configuration: configuration)
-    PusherFake::Channel.stubs(:remove)
-    PusherFake::Connection.stubs(new: connection)
-    EventMachine::WebSocket.stubs(:start).yields(socket)
+    allow(PusherFake).to receive(:configuration).and_return(configuration)
+    allow(PusherFake::Channel).to receive(:remove)
+    allow(PusherFake::Connection).to receive(:new).and_return(connection)
+    allow(EventMachine::WebSocket).to receive(:start).and_yield(socket)
   end
 
   it "creates a WebSocket server" do
@@ -64,15 +65,15 @@ describe PusherFake::Server, ".start_socket_server" do
   it "defines an open callback on the socket" do
     subject.start_socket_server
 
-    expect(socket).to have_received(:onopen).with()
+    expect(socket).to have_received(:onopen).with(no_args)
   end
 
   it "creates a connection with the provided socket when onopen yields" do
     subject.start_socket_server
 
-    expect(PusherFake::Connection).to have_received(:new).never
+    expect(PusherFake::Connection).to_not have_received(:new)
 
-    socket.stubs(:onopen).yields
+    allow(socket).to receive(:onopen).and_yield
 
     subject.start_socket_server
 
@@ -82,35 +83,35 @@ describe PusherFake::Server, ".start_socket_server" do
   it "establishes the connection when onopen yields" do
     subject.start_socket_server
 
-    expect(connection).to have_received(:establish).never
+    expect(connection).to_not have_received(:establish)
 
-    socket.stubs(:onopen).yields
+    allow(socket).to receive(:onopen).and_yield
 
     subject.start_socket_server
 
-    expect(connection).to have_received(:establish).with()
+    expect(connection).to have_received(:establish).with(no_args)
   end
 
   it "defines a message callback on the socket when onopen yields" do
     subject.start_socket_server
 
-    expect(socket).to have_received(:onmessage).never
+    expect(socket).to_not have_received(:onmessage)
 
-    socket.stubs(:onopen).yields
+    allow(socket).to receive(:onopen).and_yield
 
     subject.start_socket_server
 
-    expect(socket).to have_received(:onmessage).with()
+    expect(socket).to have_received(:onmessage).with(no_args)
   end
 
   it "triggers process on the connection when onmessage yields" do
-    socket.stubs(:onopen).yields
+    allow(socket).to receive(:onopen).and_yield
 
     subject.start_socket_server
 
-    expect(connection).to have_received(:process).never
+    expect(connection).to_not have_received(:process)
 
-    socket.stubs(:onmessage).yields(data)
+    allow(socket).to receive(:onmessage).and_yield(data)
 
     subject.start_socket_server
 
@@ -120,23 +121,23 @@ describe PusherFake::Server, ".start_socket_server" do
   it "defines a close callback on the socket when onopen yields" do
     subject.start_socket_server
 
-    expect(socket).to have_received(:onclose).never
+    expect(socket).to_not have_received(:onclose)
 
-    socket.stubs(:onopen).yields
+    allow(socket).to receive(:onopen).and_yield
 
     subject.start_socket_server
 
-    expect(socket).to have_received(:onclose).with()
+    expect(socket).to have_received(:onclose).with(no_args)
   end
 
   it "removes the connection from all channels when onclose yields" do
-    socket.stubs(:onopen).yields
+    allow(socket).to receive(:onopen).and_yield
 
     subject.start_socket_server
 
-    expect(PusherFake::Channel).to have_received(:remove).never
+    expect(PusherFake::Channel).to_not have_received(:remove)
 
-    socket.stubs(:onclose).yields
+    allow(socket).to receive(:onclose).and_yield
 
     subject.start_socket_server
 
@@ -147,15 +148,15 @@ end
 describe PusherFake::Server, ".start_web_server" do
   let(:host)          { "192.168.0.1" }
   let(:port)          { 8081 }
-  let(:server)        { stub(:start! => true, :ssl= => true) }
-  let(:configuration) { stub(web_options: { host: host, port: port, ssl: true }) }
+  let(:server)        { double(:server, :start! => true, :ssl= => true) }
+  let(:configuration) { double(:configuration, web_options: { host: host, port: port, ssl: true }) }
 
   subject { PusherFake::Server }
 
   before do
-    Thin::Server.stubs(new: server)
-    Thin::Logging.stubs(:silent=)
-    PusherFake.stubs(configuration: configuration)
+    allow(Thin::Server).to receive(:new).and_return(server)
+    allow(Thin::Logging).to receive(:silent=)
+    allow(PusherFake).to receive(:configuration).and_return(configuration)
   end
 
   it "silences the logging" do
@@ -179,6 +180,6 @@ describe PusherFake::Server, ".start_web_server" do
   it "starts the web server" do
     subject.start_web_server
 
-    expect(server).to have_received(:start!).with()
+    expect(server).to have_received(:start!).with(no_args)
   end
 end

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

@@ -4,25 +4,27 @@ describe PusherFake::Webhook, ".trigger" do
   subject { PusherFake::Webhook }
 
   let(:data)          { { channel: "name" } }
-  let(:http)          { stub(post: true) }
+  let(:http)          { double(:http, post: true) }
   let(:name)          { "channel_occupied" }
+  let(:digest)        { double(:digest) }
   let(:payload)       { MultiJson.dump({ events: [data.merge(name: name)], time_ms: Time.now.to_i }) }
   let(:webhooks)      { ["url"] }
   let(:signature)     { "signature" }
-  let(:configuration) { stub(key: "key", secret: "secret", webhooks: webhooks) }
+  let(:configuration) { double(:configuration, key: "key", secret: "secret", webhooks: webhooks) }
 
   before do
-    OpenSSL::HMAC.stubs(hexdigest: signature)
-    EventMachine::HttpRequest.stubs(new: http)
-    PusherFake.stubs(:log)
-    PusherFake.stubs(configuration: configuration)
+    allow(OpenSSL::HMAC).to receive(:hexdigest).and_return(signature)
+    allow(OpenSSL::Digest::SHA256).to receive(:new).and_return(digest)
+    allow(EventMachine::HttpRequest).to receive(:new).and_return(http)
+    allow(PusherFake).to receive(:log)
+    allow(PusherFake).to receive(:configuration).and_return(configuration)
   end
 
   it "generates a signature" do
     subject.trigger(name, data)
 
     expect(OpenSSL::HMAC).to have_received(:hexdigest)
-      .with(kind_of(OpenSSL::Digest::SHA256), configuration.secret, payload)
+      .with(digest, configuration.secret, payload)
   end
 
   it "creates a HTTP request for each webhook URL" do

data/spec/lib/pusher_fake_spec.rb

@@ -11,13 +11,14 @@ describe PusherFake, ".configure" do
 end
 
 describe PusherFake, ".configuration" do
-  let(:configuration) { mock }
+  let(:configuration) { double }
 
   subject { PusherFake }
 
   before do
-    PusherFake::Configuration.stubs(new: configuration)
     PusherFake.instance_variable_set("@configuration", nil)
+
+    allow(PusherFake::Configuration).to receive(:new).and_return(configuration)
   end
 
   after do
@@ -63,7 +64,7 @@ describe PusherFake, ".javascript" do
 end
 
 describe PusherFake, ".log" do
-  let(:logger)        { stub(:<< => "") }
+  let(:logger)        { double(:logger, :<< => "") }
   let(:message)       { "Hello world." }
   let(:configuration) { subject.configuration }
 
@@ -86,6 +87,6 @@ describe PusherFake, ".log" do
 
     subject.log(message)
 
-    expect(logger).to have_received(:<<).never
+    expect(logger).to_not have_received(:<<)
   end
 end

data/spec/spec_helper.rb

@@ -7,8 +7,10 @@ Dir[File.expand_path("../support/**/*.rb", __FILE__)].each do |file|
 end
 
 RSpec.configure do |config|
-  config.mock_with   :mocha
   config.expect_with :rspec do |rspec|
     rspec.syntax = :expect
   end
+
+  # Raise errors for any deprecations.
+  config.raise_errors_for_deprecations!
 end

data/{features/support/application/public/javascripts/vendor/pusher-2.2.2.js → spec/support/application/public/javascripts/vendor/pusher-2.2.4.js}

@@ -1,5 +1,5 @@
 /*!
- * Pusher JavaScript Library v2.2.2
+ * Pusher JavaScript Library v2.2.4
  * http://pusher.com/
  *
  * Copyright 2014, Pusher
@@ -626,7 +626,7 @@
 }).call(this);
 
 ;(function() {
-  Pusher.VERSION = '2.2.2';
+  Pusher.VERSION = '2.2.4';
   Pusher.PROTOCOL = 7;
 
   // DEPRECATED: WS connection parameters
@@ -678,7 +678,8 @@
       }]],
       [":def", "sockjs_options", {
         hostUnencrypted: config.httpHost + ":" + config.httpPort,
-        hostEncrypted: config.httpHost + ":" + config.httpsPort
+        hostEncrypted: config.httpHost + ":" + config.httpsPort,
+        httpPath: config.httpPath
       }],
       [":def", "timeouts", {
         loop: true,
@@ -1086,7 +1087,7 @@
    * @param  {String} name
    * @param  {Function} callback
    */
-  prototype.load = function(name, callback) {
+  prototype.load = function(name, options, callback) {
     var self = this;
 
     if (self.loading[name] && self.loading[name].length > 0) {
@@ -1094,7 +1095,7 @@
     } else {
       self.loading[name] = [callback];
 
-      var request = new Pusher.ScriptRequest(self.getPath(name));
+      var request = new Pusher.ScriptRequest(self.getPath(name, options));
       var receiver = self.receivers.create(function(error) {
         self.receivers.remove(receiver);
 
@@ -1176,7 +1177,7 @@
   }
 
   if (!window.JSON) {
-    Pusher.Dependencies.load("json2", initializeOnDocumentBody);
+    Pusher.Dependencies.load("json2", {}, initializeOnDocumentBody);
   } else {
     initializeOnDocumentBody();
   }
@@ -2078,25 +2079,29 @@
     }));
 
     if (self.hooks.beforeInitialize) {
-      self.hooks.beforeInitialize();
+      self.hooks.beforeInitialize.call(self);
     }
 
     if (self.hooks.isInitialized()) {
       self.changeState("initialized");
     } else if (self.hooks.file) {
       self.changeState("initializing");
-      Pusher.Dependencies.load(self.hooks.file, function(error, callback) {
-        if (self.hooks.isInitialized()) {
-          self.changeState("initialized");
-          callback(true);
-        } else {
-          if (error) {
-            self.onError(error);
+      Pusher.Dependencies.load(
+        self.hooks.file,
+        { encrypted: self.options.encrypted },
+        function(error, callback) {
+          if (self.hooks.isInitialized()) {
+            self.changeState("initialized");
+            callback(true);
+          } else {
+            if (error) {
+              self.onError(error);
+            }
+            self.onClose();
+            callback(false);
           }
-          self.onClose();
-          callback(false);
         }
-      });
+      );
     } else {
       self.onClose();
     }
@@ -2366,7 +2371,8 @@
       if (window.WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR === undefined) {
         window.WEB_SOCKET_SUPPRESS_CROSS_DOMAIN_SWF_ERROR = true;
       }
-      window.WEB_SOCKET_SWF_LOCATION = Pusher.Dependencies.getRoot() +
+      window.WEB_SOCKET_SWF_LOCATION =
+        Pusher.Dependencies.getRoot({ encrypted: this.options.encrypted }) +
         "/WebSocketMain.swf";
     },
     isInitialized: function() {
@@ -3918,7 +3924,7 @@
 
   Pusher.Channel.Authorizer.prototype = {
     composeQuery: function(socketId) {
-      var query = '&socket_id=' + encodeURIComponent(socketId) +
+      var query = 'socket_id=' + encodeURIComponent(socketId) +
         '&channel_name=' + encodeURIComponent(this.channel.name);
 
       for(var i in this.authOptions.params) {
@@ -3999,6 +4005,7 @@
       script.src = this.options.authEndpoint +
         '?callback=' +
         encodeURIComponent(callback_name) +
+        '&' +
         this.composeQuery(socketId);
 
       var head = document.getElementsByTagName("head")[0] || document.documentElement;

data/spec/support/application/views/index.erb

@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>PusherFake Test Application</title>
+</head>
+<body>
+
+<section>
+  <header>
+    <h1>Client disconnected.</h1>
+  </header>
+
+  <ul></ul>
+</section>
+
+<script src="/javascripts/vendor/pusher-2.2.4.js"></script>
+<script>
+  Pusher.instance = <%= PusherFake.javascript %>;
+  Pusher.instance.connection.bind("state_change", function(states) {
+    var header = document.querySelector("h1");
+
+    header.innerText = "Client " + states.current + ".";
+  });
+
+  var Helpers = {
+    log: function(text, attributes) {
+      var list    = document.querySelector("ul"),
+          element = document.createElement("li");
+
+      element.innerText = text;
+
+      for (var name in attributes) {
+        element.setAttribute(name, attributes[name]);
+      }
+
+      list.appendChild(element);
+    },
+
+    subscribe: function(name) {
+      Pusher.instance.subscribe(name)
+        .bind("pusher:subscription_succeeded", function(client) {
+          Helpers.log("Subscribed to " + name + ".");
+
+          for (var id in client.members) {
+            Helpers.log(client.members[id].name, {
+              "id"    : "client-" + id,
+              "class" : "channel-" + name
+            });
+          }
+        })
+        .bind("pusher:member_added", function(client) {
+          Helpers.log(client.info.name, {
+            "id"    : "client-" + client.id,
+            "class" : "channel-" + name
+          });
+        })
+        .bind("pusher:member_removed", function(client) {
+          var list = document.querySelector("ul"),
+              item = list.querySelector("#client-" + client.id);
+
+          list.removeChild(item);
+        })
+        .bind_all(function(event, message) {
+          Helpers.log("Channel " + name + " received " + event + " event.");
+        });
+    },
+
+    trigger: function(channel, event) {
+      var channel = Pusher.instance.channel(channel);
+
+      channel.trigger(event, {});
+    },
+
+    unsubscribe: function(name) {
+      Pusher.instance.unsubscribe(name)
+
+      Helpers.log("Unsubscribed from " + name + ".");
+    }
+  };
+</script>
+
+</body>
+</html>