honest_pubsub 0.2.2

data/spec/honest_pubsub/server/client_queue_listener_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe HonestPubsub::Server::ClientQueueListener do
+  describe "#message_received" do
+
+    subject { -> { queue_listener.message_received( {}, {routing_key: routing_key}, {context: context, payload: payload}) } }
+    let(:queue_listener) { HonestPubsub::Server::ClientQueueListener.new(Klass, routing_key, 'queue') }
+    let(:routing_key) { 'some.test.key' }
+    let(:context) { {} }
+    let(:payload) { {hello: 'moto'} }
+    let(:context_before){}
+    let(:validators){ [] }
+
+    before do
+      context_before
+      Object.const_set :Klass, Class.new(HonestPubsub::Server::ClientWorker)
+      validators.each do |validator|
+        Klass.validates_payload_with validator
+      end
+
+      klass_instance
+
+      allow(Klass).to receive(:new).and_return(klass_instance)
+      subject.call unless respond_to? :no_call
+    end
+
+    after do
+      Object.send :remove_const, :Klass
+    end
+
+    context "Normal execution" do
+      let!(:klass_instance){
+        instance = Klass.new({},{})
+        allow(instance).to receive(:perform)
+        instance
+      }
+
+      context "test exception" do
+        let(:no_call) { true }
+
+        it { should_not raise_exception }
+      end
+
+      context "call" do
+        it { expect(klass_instance).to have_received(:perform).with({}, payload) }
+      end
+    end
+
+    context "Exception during execution" do
+      let!(:klass_instance) {
+        instance = Klass.new({},{})
+        allow(instance).to receive(:perform){
+          raise StandardError.new("test")
+        }
+        instance
+      }
+      let(:no_call) { true }
+
+      it { should_not raise_exception }
+    end
+
+    context "Payload error" do
+      let!(:klass_instance) {
+        instance = Klass.new({},{})
+        allow(instance).to receive(:perform)
+        instance
+      }
+
+      let!(:validators) { [lambda{ |payload| false }]  }
+
+      let(:context_before){ allow(Airbrake).to receive(:notify)}
+
+      it {expect(Airbrake).to have_received(:notify)}
+    end
+  end
+end

data/spec/honest_pubsub/server/client_worker_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe HonestPubsub::Server::ClientWorker do
+  before(:each) { Object.const_set :Klass, Class.new(HonestPubsub::Server::ClientWorker) }
+  after(:each) { Object.send :remove_const, :Klass }
+
+  describe "#routing_key" do
+    subject { HonestPubsub::Server::ClientWorker.new(routing_data, properties).routing_key }
+
+    let(:properties) { {} }
+
+    context "Routing key is 'honest.test.route'" do
+      let(:routing_data) { {routing_key: "honest.test.route"} }
+      
+      it { should eq "honest.test.route" }
+    end
+  end
+
+  describe "self.validates_payload_with" do
+    before do
+      validators.each do |validator|
+        Klass.validates_payload_with validator
+      end
+    end
+
+    context "One validator" do
+      let(:validators){ [lambda{|payload| true}] }
+      it {
+        expect(Klass.new({},{}).payload_validators.length).to eq 1 }
+    end
+
+    context "Two validators" do
+      let(:validators){ [lambda{|payload| true}, lambda{|payload| true}] }
+      it { expect(Klass.new({},{}).payload_validators.length).to eq 2  }
+    end
+  end
+
+  describe '#valid_payload?' do
+    context
+    subject { Klass.new({},{}).valid_payload?({}) }
+
+    before do
+      validators.each do |validator|
+        Klass.validates_payload_with validator
+      end
+    end
+
+    context "Two validators returning true" do
+      let(:validators){ [lambda{|payload| true}, lambda{|payload| true}] }
+      it { should be true }
+    end
+
+    context "One validator returning true one returning false" do
+      let(:validators){ [lambda{|payload| false}, lambda{|payload| true}] }
+      it { should be false }
+    end
+
+    context "No validators" do
+      let(:validators){ [] }
+      it { should be true }
+    end
+
+    context "validators as symbol" do
+      context "method returns true" do
+        before {
+          Klass.class_variable_set(:@@foo_bar_called, false)
+          Klass.send :define_method,  :foo_bar do |payload|
+            Klass.class_variable_set(:@@foo_bar_called, true)
+            true
+          end
+        }
+        let(:validators) { [lambda{|payload| true}, :foo_bar] }
+        it {
+          should be true
+          expect(Klass.class_variable_get(:@@foo_bar_called)).to be true
+        }
+
+      end
+
+      context "method returns false" do
+        before {
+          Klass.class_variable_set(:@@foo_bar_called, false)
+          Klass.send :define_method,  :foo_bar do |payload|
+            Klass.class_variable_set(:@@foo_bar_called, true)
+            false
+          end
+        }
+        let(:validators) { [lambda{|payload| true}, :foo_bar] }
+        it {
+          should be false
+          expect(Klass.class_variable_get(:@@foo_bar_called)).to be true
+        }
+
+      end
+
+      context "proc returns false" do
+        before {
+          Klass.class_variable_set(:@@foo_bar_called, false)
+          Klass.send :define_method,  :foo_bar do |payload|
+            Klass.class_variable_set(:@@foo_bar_called, true)
+            true
+          end
+        }
+        let(:validators) { [lambda{|payload| false}, :foo_bar] }
+        it "method shouldn't be called" do
+          should be false
+          expect(Klass.class_variable_get(:@@foo_bar_called)).to be false
+        end
+
+      end
+    end
+  end
+
+  describe "#validate_routing_key_name" do
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, '')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef.asd')).to eq(true) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef/')).to eq(false) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.abcdef.a123')).to eq(false) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcdef.')).to eq(false) }
+    it { expect(Klass.send(:validate_routing_key_name, 'abcAf')).to eq(false) }
+  end
+
+  describe "#generated_queue_name" do
+    before(:each) { allow(HonestPubsub::Configuration).to receive(:application_name).and_return("app_name")}
+
+    it { expect(Klass.send(:generated_queue_name, 'abcdef', 'queue_name')).to eq('queue_name') }
+    it { expect(Klass.send(:generated_queue_name, 'abcdef', nil)).to eq('app_name_abcdef') }
+    it { expect(Klass.send(:generated_queue_name, 'abcdef.abcd', nil)).to eq('app_name_abcdef_abcd') }
+    it { expect(Klass.send(:generated_queue_name, 'a.b.c', nil)).to eq('app_name_a_b_c') }
+  end
+
+  describe '.subscribe_to' do
+    before(:each) { allow(HonestPubsub::Configuration).to receive(:application_name).and_return("app_name")}
+    context 'routing_key without queue_name' do
+      before { Klass.subscribe_to 'a.b.c' }
+      it 'sets the routing key and queue name' do
+        expect(Klass.subscribed_key).to eq('a.b.c')
+        expect(Klass.subscribed_queue).to eq('app_name_a_b_c')
+      end
+    end
+
+    context 'routing_key with queue_name' do
+      before { Klass.subscribe_to 'a.b.c', on: 'foo_bar' }
+      it 'sets the routing key and queue name' do
+        expect(Klass.subscribed_key).to eq('a.b.c')
+        expect(Klass.subscribed_queue).to eq('foo_bar')
+      end
+    end
+
+    context 'invalid routing key' do
+      before {  }
+      it 'sets the routing key and queue name' do
+        expect {
+          Klass.subscribe_to 'a.b.c.', on: 'foo_bar'
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/honest_pubsub/subscriber_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe HonestPubsub::Subscriber do
+  subject { HonestPubsub::Subscriber.new( routing_key ) }
+end

data/spec/logger_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe HonestPubsub::Logger do
+  let(:routing_key) { "test/logger" }
+  let(:subject) { HonestPubsub::Logger.new }
+  let(:payload) { {"hit"=>"me"} }
+  let(:message) { HonestPubsub::Message.new.serialize(context, routing_key, payload) }
+  let(:config_buffer) { StringIO.new }
+  let(:output_string) { config_buffer.string }
+  let(:config_override) { {} }
+  let(:context) { {unique_id: "1234", orig_ip_address: "127.0.0.1"}}
+
+  before do
+    HonestPubsub::Logging.instance_variable_set(:"@logger", nil)
+    directory = File::dirname(__FILE__)
+    full_name = File.join(directory, "config.yml")
+    @config_data = HashWithIndifferentAccess.new( YAML.load_file(full_name)[ENV["RAILS_ENV"]] )
+    @config_data.merge!(config_override)
+    @config_data[:logger][:file] = config_buffer
+    allow(HonestPubsub::Configuration).to receive(:configuration).at_least(1).and_return(@config_data)
+  end
+
+  describe "#log_publish" do
+    let(:result) { subject.log_publish(routing_key, message)}
+
+
+    it "should not fail" do
+      expect{ result }.not_to raise_error()
+    end
+
+    it "should write a row to the log" do
+      result
+      expect(output_string.length).not_to eq(0)
+    end
+
+  end
+
+  describe "#failed_publish" do
+    let(:result) { subject.failed_publish(routing_key, {}, message)}
+
+    context "warning log level" do
+
+      it "should not fail" do
+        expect{ result }.not_to raise_error()
+      end
+
+      it "should respect the log level of the file" do
+        result
+        expect(output_string.length).not_to eq(0)
+      end
+    end
+
+    context "fatal log level" do
+      let(:config_override) { { 'logger'=> { 'level'=>'fatal' } } }
+
+      it "should not fail" do
+        expect{ result }.not_to raise_error()
+      end
+
+      it "should respect the log level of the file" do
+        result
+        expect(output_string.length).to eq(0)
+      end
+    end
+  end
+
+  describe "#log_receive" do
+    let(:result) { subject.log_receive(routing_key, message)}
+
+    it "should not fail" do
+      expect{ result }.not_to raise_error()
+    end
+
+    it "should respect the log level of the file" do
+      result
+      expect(output_string.length).not_to eq(0)
+    end
+  end
+
+  describe "#log_service" do
+    let(:service_name) { "test" }
+    let(:result) { subject.log_service(service_name, log_level, message)}
+
+    context "debugger log" do
+      let(:log_level) { :debug }
+      it "should not fail" do
+        expect{ result }.not_to raise_error()
+      end
+
+      it "should respect the log level of the file" do
+        result
+        expect(output_string.length).to eq(0)
+      end
+    end
+
+    context "warn log" do
+      let(:log_level) { :warn }
+      it "should not fail" do
+        expect{ result }.not_to raise_error()
+      end
+
+      it "should respect the log level of the file" do
+        result
+        expect(output_string.length).not_to eq(0)
+      end
+    end
+
+  end
+
+end

data/spec/message_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe HonestPubsub::Message do
+  let(:original) { {'data'=> 'found'} }
+  let(:subject) { HonestPubsub::Message.new }
+  let(:routing_key) { "test.message" }
+  let(:context) { {unique_id: "1234", orig_ip_address: "127.0.0.1"}}
+
+  describe "#serialize" do
+    let(:result) { subject.serialize(context, routing_key, original)}
+
+    it "should not fail" do
+      expect{ result }.not_to raise_error()
+    end
+
+    it "should have all the header items" do
+      expect(result[:ts]).not_to be_nil
+      expect(result[:v]).not_to be_nil
+      expect(result[:pub]).not_to be_nil
+      expect(result[:payload]).not_to be_nil
+    end
+
+    it "should have the data in the payload" do
+      expect(result[:payload][:data]).to eq('found')
+    end
+
+    it "should have the attributes readable" do
+      result
+      expect(subject.ts).not_to be_nil
+      expect(subject.version).not_to be_nil
+      expect(subject.pub).not_to be_nil
+      expect(subject.payload).not_to be_nil
+    end
+  end
+
+  describe "#parse" do
+    let(:payload) { subject.serialize(context, routing_key, original).to_json }
+    let(:result) { subject.parse(payload) }
+
+    it "should not fail" do
+      expect{ result }.not_to raise_error()
+    end
+
+    it "should have all the hash items" do
+      expect(result[:ts]).not_to be_nil
+      expect(result[:v]).not_to be_nil
+      expect(result[:pub]).not_to be_nil
+      expect(result[:payload]).not_to be_nil
+    end
+
+    it "should have the data in the payload" do
+      expect(result[:payload][:data]).to eq('found')
+    end
+
+    it "should have the attributes readable" do
+      result
+      expect(subject.ts).not_to be_nil
+      expect(subject.version).not_to be_nil
+      expect(subject.pub).not_to be_nil
+      expect(subject.payload).not_to be_nil
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+# 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 'awesome_print'
+require 'honest_pubsub'
+require 'honest_pubsub/server'
+ENV['RAILS_ENV'] ||= "test"
+ENV['RACK_ENV'] ||= "test"
+
+
+RSpec.configure do |config|
+  # config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  # Don't want to filter on anything right now.
+  config.filter_run :focus
+
+  # 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
+  # For now, always in same order
+  config.order = 'random'
+end
+
+HonestPubsub::Configuration.configure_with("test", File.join(HonestPubsub.root,"spec/config.yml") )
+
+# Some test subscriber classes to make testing easier
+class MyTestSubscriber1 < HonestPubsub::Server::ClientWorker
+
+  def perform(payload)
+
+  end
+end
+
+class MyTestSubscriber2 < HonestPubsub::Server::ClientWorker
+  def perform(payload)
+
+  end
+end
+
+class MyTestSubscriber3 < MyTestSubscriber1
+  def perform(payload)
+
+  end
+end