thunderer 0.9.0

data/spec/javascripts/helpers/jasmine_examples/SpecHelper.js

@@ -0,0 +1,15 @@
+beforeEach(function () {
+  jasmine.addMatchers({
+    toBePlaying: function () {
+      return {
+        compare: function (actual, expected) {
+          var player = actual;
+
+          return {
+            pass: player.currentlyPlayingSong === expected && player.isPlaying
+          }
+        }
+      };
+    }
+  });
+});

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,123 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+  - thunderer.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+  - 'helpers/**/*.js'
+
+# spec_files
+#
+# Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - **/*[sS]pec.js
+#
+spec_files:
+  - '**/*[sS]pec.js'
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir: app/assets/javascripts
+
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir: spec/javascripts
+
+# spec_helper
+#
+# Ruby file that Jasmine server will require before starting.
+# Returned relative to your root path
+# Default spec/javascripts/support/jasmine_helper.rb
+#
+# EXAMPLE:
+#
+# spec_helper: spec/javascripts/support/jasmine_helper.rb
+#
+spec_helper: spec/javascripts/support/jasmine_helper.rb
+
+# boot_dir
+#
+# Boot directory path. Your boot_files must be returned relative to this path.
+# Default: Built in boot file
+#
+# EXAMPLE:
+#
+# boot_dir: spec/javascripts/support/boot
+#
+boot_dir:
+
+# boot_files
+#
+# Return an array of filepaths relative to boot_dir to include in order to boot Jasmine
+# Default: Built in boot file
+#
+# EXAMPLE
+#
+# boot_files:
+#   - '**/*.js'
+#
+boot_files:
+
+# rack_options
+#
+# Extra options to be passed to the rack server
+# by default, Port and AccessLog are passed.
+#
+# This is an advanced options, and left empty by default
+#
+# EXAMPLE
+#
+# rack_options:
+#   server: 'thin'

data/spec/javascripts/support/jasmine_helper.rb

@@ -0,0 +1,11 @@
+#Use this file to set/override Jasmine configuration options
+#You can remove it if you don't need it.
+#This file is loaded *after* jasmine.yml is interpreted.
+#
+#Example: using a different boot file.
+#Jasmine.configure do |config|
+#   config.boot_dir = '/absolute/path/to/boot_dir'
+#   config.boot_files = lambda { ['/absolute/path/to/boot_dir/file.js'] }
+#end
+#
+

data/spec/javascripts/thunderer_spec.js

@@ -0,0 +1,118 @@
+describe('Thunderer', function () {
+  var doc;
+  beforeEach(function () {
+    Faye = {};
+    doc = {};
+  });
+
+  it('adds subscription callback', function () {
+    Thunderer.subscribe('Hello', 'WorldCallback');
+    expect(Thunderer.subscriptionCallbacks['Hello']).toEqual('WorldCallback')
+  });
+
+  it('has fayExtension which add some signature for outgoing message',function () {
+    var called = false;
+    var message = {channel: "/meta/subscribe", subscription: "hello"}
+    Thunderer.subscriptions["hello"] = {signature: "abcd", timestamp: "1234"}
+    Thunderer.fayeExtension.outgoing(message, function(message) {
+      expect(message.ext.thunderer_signature).toEqual("abcd");
+      expect(message.ext.thunderer_timestamp).toEqual("1234");
+      called = true;
+    });
+    expect(called).toBeTruthy();
+  });
+
+  it("adds a faye subscription with response handler when signing", function() {
+    var faye = {subscribe: jasmine.createSpy()};
+    spyOn(Thunderer, 'faye').and.callFake(function(callback) {
+      callback(faye);
+    });
+    var options = {server: "server", channel: "somechannel"};
+    Thunderer.sign(options);
+    expect(faye.subscribe).toHaveBeenCalledWith("somechannel", jasmine.any(Function));
+    expect(Thunderer.subscriptions.server).toEqual("server");
+    expect(Thunderer.subscriptions.somechannel).toEqual(options);
+  });
+
+  it("unsubscribes a channel by name", function(){
+    var sub = { cancel: jasmine.createSpy() };
+    var faye = {subscribe: function(){ return sub; }};
+    spyOn(Thunderer, 'faye').and.callFake(function(callback) {
+      callback(faye);
+    });
+    var options = { server: "server", channel: "somechannel" };
+    Thunderer.sign(options);
+    expect(Thunderer.subscription("somechannel")).toEqual(sub);
+    Thunderer.unsubscribe("somechannel");
+    expect(sub.cancel).toHaveBeenCalled();
+    expect(Thunderer.subscription("somechannel")).toBeFalsy();
+  });
+
+  it("unsubscribes all channels", function(){
+    var created = 0;
+    var sub = function() {
+      created ++;
+      var sub = { cancel: function(){ created --; } };
+      return sub;
+    };
+    var faye = { subscribe: function(){ return sub(); }};
+    spyOn(Thunderer, 'faye').and.callFake(function(callback) {
+      callback(faye);
+    });
+    Thunderer.sign({server: "server", channel: "firstchannel"});
+    Thunderer.sign({server: "server", channel: "secondchannel"});
+    expect(created).toEqual(2);
+    expect(Thunderer.subscription("firstchannel")).toBeTruthy();
+    expect(Thunderer.subscription("secondchannel")).toBeTruthy();
+    Thunderer.unsubscribeAll()
+    expect(created).toEqual(0);
+    expect(Thunderer.subscription("firstchannel")).toBeFalsy();
+    expect(Thunderer.subscription("secondchannel")).toBeFalsy();
+  });
+
+  it("returns the subscription object for a subscribed channel", function(){
+    var faye = {subscribe: function(){ return "subscription"; }};
+    spyOn(Thunderer, 'faye').and.callFake(function(callback) {
+      callback(faye);
+    });
+    var options = { server: "server", channel: "somechannel" };
+    Thunderer.sign(options);
+    expect(Thunderer.subscription("somechannel")).toEqual("subscription")
+  });
+
+  it("triggers callback matching message channel in response", function() {
+    var handler, callbackSpy, response, faye;
+    callbackSpy = jasmine.createSpy();
+    response = {channel: 'test', data: 'abcd'};
+    faye = {subscribe: function (channel, handleResponse) {
+      handler = handleResponse;
+    }};
+    spyOn(Thunderer, 'faye').and.callFake(function(callback) {
+      callback(faye);
+    });
+    var options = {server: "server", channel: "somechannel"};
+    Thunderer.sign(options);
+    Thunderer.subscribe("test", callbackSpy);
+    handler(response);
+
+    expect(callbackSpy).toHaveBeenCalledWith('abcd','test')
+  });
+
+   it("takes a callback for subscription object when signing", function(){
+    var faye = {subscribe: function(){ return "subscription"; }};
+    spyOn(Thunderer, 'faye').and.callFake(function(callback) {
+      callback(faye);
+    });
+    var options = { server: "server", channel: "somechannel" };
+    options.subscription = jasmine.createSpy();
+    Thunderer.sign(options);
+    expect(options.subscription).toHaveBeenCalledWith("subscription");
+  });
+
+  it("adds fayeCallback when client and server aren't available", function() {
+    Thunderer.faye("callback");
+    expect(Thunderer.fayeCallbacks[0]).toEqual("callback");
+  });
+
+
+});

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+require 'bundler/setup'
+require 'support/matchers/have_filter'
+require 'json'
+require 'faye'
+require 'support/controller_macros'
+Bundler.setup
+
+require 'thunderer'
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.include ControllerMacros
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/controller_macros.rb

@@ -0,0 +1,5 @@
+module ControllerMacros
+  def has_before_filters *names
+    expect(controller).to have_filters(:before, *names)
+  end
+end

data/spec/support/matchers/have_filter.rb

@@ -0,0 +1,6 @@
+RSpec::Matchers.define :have_filters do |kind, *names|
+  match do |controller|
+    filters = controller._process_action_callbacks.select{ |f| f.kind == kind }.map(&:filter)
+    names.all?{ |name| filters.include?(name) }
+  end
+end

data/spec/thunderer/controller_aditions_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'action_controller'
+require 'thunderer/controller_additions'
+
+
+describe Thunderer::ControllerAdditions do
+  class MyController < ActionController::Base
+    include Thunderer::ControllerAdditions
+
+    def index
+      # render text: 'ok'
+    end
+
+    def params; end
+  end
+
+  let(:controller_class) { MyController }
+
+  describe '#thunderer_channels' do
+
+      it 'should affect channels class variable' do
+        controller_class.thunderer_channels('hello')
+        expect(controller_class.channels).to include('hello')
+      end
+
+      it 'should affect interpolation_object of class' do
+        controller_class.thunderer_channels(object: 'hello')
+        expect(controller_class.interpolation_object).to include('hello')
+      end
+
+      it 'should setup before filter for setting headers' do
+        expect(controller_class).to have_filters(:before, :add_channels_header)
+      end
+
+      context 'for instance of controller' do
+        subject(:controller) { controller_class.new }
+
+        # it 'should add special header for index response' do
+        #   controller_class.thunderer_channels('hello')
+        #   allow(controller).to receive(:headers)
+        #   controller.send(:add_channels_header)
+        # end
+
+      end
+
+  end
+
+end

data/spec/thunderer/messanger_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'thunderer/messanger'
+
+describe Thunderer::Messanger do
+  let(:messanger) { Thunderer::Messanger }
+  before { Thunderer::Messanger.reset_config }
+
+  it 'default have nil uri' do
+    expect(messanger.config['uri']).to eq(nil)
+  end
+
+  it 'default have nil use_ssl' do
+    expect(messanger.config['use_ssl']).to eq(nil)
+  end
+
+  context 'with default config' do
+
+    it 'should raise error when you try post message' do
+      message = double(:message)
+      expect {
+        messanger.post(message)
+      }.to raise_error Thunderer::Messanger::ConfigurationError
+    end
+
+  end
+
+  describe '#configure' do
+
+    it 'parse url and set configuration' do
+      messanger.configure('http://google.ru')
+      expect(messanger.config).not_to eq({})
+    end
+
+    it 'set use_ssl to false for http' do
+      messanger.configure('http://google.ru')
+      expect(messanger.config['use_ssl']).to eq(false)
+    end
+
+    it 'set use_ssl to false for https' do
+      messanger.configure('https://google.ru')
+      expect(messanger.config['use_ssl']).to eq(true)
+    end
+
+  end
+
+end

data/spec/thunderer/parser_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Thunderer::Parser do
+
+  let(:object) { OpenStruct.new(first: 1, second: 2) }
+
+  describe '#interpolate_channel' do
+    subject { Thunderer::Parser.interpolate_channel(channel, object) }
+
+    context 'when channel have no interpolation' do
+      let(:channel) { 'without interpolation string' }
+
+      it { should == channel }
+    end
+
+    context 'when channel have one interpolation sequence' do
+      let(:channel) { '/hello/:first' }
+
+      it { should include('1') }
+
+    end
+
+    context 'when channel have two interpolations' do
+      let(:channel) { '/hello/:first/world/:second' }
+
+      it { should include('1') }
+
+      it { should include('2') }
+    end
+
+
+  end
+
+end

data/spec/thunderer_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Thunderer do
+  before { Thunderer.reset_config }
+
+  it "defaults server to nil" do
+    Thunderer.config[:server].should be_nil
+  end
+
+  it "defaults signature_expiration to nil" do
+    Thunderer.config[:signature_expiration].should be_nil
+  end
+
+  it "defaults subscription timestamp to current time in milliseconds" do
+    time = Time.now
+    Time.stub(:now).and_return(time)
+    Thunderer.subscription[:timestamp].should eq((time.to_f * 1000).round)
+  end
+
+  it "loads a simple configuration file via load_config" do
+    Thunderer.load_config("spec/fixtures/thunderer.yml", "production")
+    Thunderer.config[:server].should eq("http://example.com/faye")
+    Thunderer.config[:secret_token].should eq("PRODUCTION_SECRET_TOKEN")
+    Thunderer.config[:signature_expiration].should eq(600)
+  end
+
+  it 'also configure Thunderer::Messanger when load config' do
+    Thunderer.load_config("spec/fixtures/thunderer.yml", "production")
+    # expect(Thunderer.messanger).to be_kind_of(Thunderer::Messanger)
+    expect(Thunderer.messanger.config).not_to be_nil
+  end
+
+  it "raises an exception if an invalid environment is passed to load_config" do
+    expect {
+      Thunderer.load_config("spec/fixtures/thunderer.yml", :test)
+    }.to raise_error ArgumentError
+  end
+
+
+  it "includes channel, server, and custom time in subscription" do
+    Thunderer.config[:server] = "server"
+    subscription = Thunderer.subscription(:timestamp => 123, :channel => "hello")
+    subscription[:timestamp].should eq(123)
+    subscription[:channel].should eq("hello")
+    subscription[:server].should eq("server")
+  end
+
+  it "does a sha1 digest of channel, timestamp, and secret token" do
+    Thunderer.config[:secret_token] = "token"
+    subscription = Thunderer.subscription(:timestamp => 123, :channel => "channel")
+    subscription[:signature].should eq(Digest::SHA1.hexdigest("tokenchannel123"))
+  end
+
+  it "formats a message hash given a channel and a hash" do
+    Thunderer.config[:secret_token] = "token"
+    Thunderer.message("chan", :foo => "bar").should eq(
+      :ext => {:thunderer_secret_token => "token"},
+      :channel => "chan",
+      :data => {
+        :channel => "chan",
+        :data => {:foo => "bar"}
+      }
+    )
+  end
+
+  it "publish message as json to server using Net::HTTP" do
+    message = 'foo'
+    Thunderer.load_config("spec/fixtures/thunderer.yml", "production")
+
+    expect(Thunderer::Messanger).to receive(:post)
+    Thunderer.publish_message(message)
+  end
+
+  
+  it "raises an exception if no server is specified when calling publish_message" do
+    lambda {
+      Thunderer.publish_message("foo")
+    }.should raise_error(Thunderer::Error)
+  end
+
+  it "publish_to passes message to publish_message call" do
+    Thunderer.should_receive(:message).with("chan", "foo").and_return("message")
+    Thunderer.should_receive(:publish_message).with("message").and_return(:result)
+    Thunderer.publish_to("chan", "foo").should eq(:result)
+  end
+
+  it "has a Faye rack app instance" do
+    Thunderer.faye_app.should be_kind_of(Faye::RackAdapter)
+  end
+
+  it "says signature has expired when time passed in is greater than expiration" do
+    Thunderer.config[:signature_expiration] = 30*60
+    time = Thunderer.subscription[:timestamp] - 31*60*1000
+    Thunderer.signature_expired?(time).should be_true
+  end
+
+  it "says signature has not expired when time passed in is less than expiration" do
+    Thunderer.config[:signature_expiration] = 30*60
+    time = Thunderer.subscription[:timestamp] - 29*60*1000
+    Thunderer.signature_expired?(time).should be_false
+  end
+
+  it "says signature has not expired when expiration is nil" do
+    Thunderer.config[:signature_expiration] = nil
+    Thunderer.signature_expired?(0).should be_false
+  end
+
+end

data/thunderer.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'thunderer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "thunderer"
+  spec.version       = Thunderer::VERSION
+  spec.authors       = ["Nick Chubarov"]
+  spec.email         = ["nick.chubarov@gmail.com"]
+  spec.summary       = 'pub/sub messaging in Rails application'
+  spec.description   = 'pub/sub messaging in Rails application thought Faye.'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.add_dependency 'faye'
+
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'rspec', '~> 2.14.1'
+  spec.add_development_dependency 'jasmine'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end