rails-pipeline 1.1.1

data/spec/ironmq_publisher_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require_relative 'pipeline_helper'
+
+describe RailsPipeline::IronmqPublisher do
+  before do
+    @default_emitter = DefaultIronmqEmitter.new({foo: "baz"}, without_protection: true)
+  end
+
+  it "should call post for IronMQ" do
+    expect_any_instance_of(IronMQ::Queue).to receive(:post) { |instance, serialized_encrypted_data|
+      base64_decoded_data = Base64.strict_decode64(JSON.parse(serialized_encrypted_data)['payload'])
+
+      encrypted_data = RailsPipeline::EncryptedMessage.parse(base64_decoded_data)
+
+      serialized_payload = DefaultEmitter.decrypt(encrypted_data)
+      data = DefaultEmitter_1_0.parse(serialized_payload)
+
+      expect(instance.name).to eq("harrys-#{Rails.env}-v1-default_emitters")
+      expect(encrypted_data.type_info).to eq(DefaultEmitter_1_0.to_s)
+      expect(data.foo).to eq("baz")
+    }.once
+    @default_emitter.emit
+  end
+
+  it "should actually publish message to IronMQ" do
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+  end
+
+end

data/spec/pipeline_version_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe RailsPipeline::PipelineVersion do
+  context 'major' do
+    it "parses the string correctly" do
+      expect(RailsPipeline::PipelineVersion.new("1_0").major).to eq(1)
+    end
+  end
+
+  context 'minor' do
+    it "parses the string correctly" do
+      expect(RailsPipeline::PipelineVersion.new("1_3").minor).to eq(3)
+    end
+  end
+
+  describe 'comparison' do
+    let(:v1_0) { RailsPipeline::PipelineVersion.new('1_0') }
+    let(:v2_0) { RailsPipeline::PipelineVersion.new('2_0') }
+    let(:v1_3) { RailsPipeline::PipelineVersion.new('1_3') }
+    let(:v1_10) { RailsPipeline::PipelineVersion.new('1_10') }
+    let(:v1_10bis) { RailsPipeline::PipelineVersion.new('1_10') }
+
+    it { expect(v1_0).to be < v2_0 }
+    it { expect(v1_3).to be > v1_0 }
+    it { expect(v1_10).to be < v2_0 }
+    it { expect(v1_10).to be > v1_3 }
+    it { expect(v1_10).to eq(v1_10bis) }
+  end
+
+  describe '#to_s' do
+    it "renders correctly" do
+      expect("#{RailsPipeline::PipelineVersion.new('2_1')}").to eq("2_1")
+    end
+  end
+end

data/spec/redis_forwarder_spec.rb

@@ -0,0 +1,99 @@
+
+require 'spec_helper'
+require 'pipeline_helper'
+require 'forwarder_helper'
+
+describe RailsPipeline::RedisForwarder do
+  before do
+    @emitter = DefaultRedisEmitter.new({foo: "baz"}, without_protection: true)
+    @redis_queue = @emitter._key
+    @forwarder = DummyRedisForwarder.new(@redis_queue)
+    @in_progress_queue = @forwarder._in_progress_queue
+    @redis = @emitter._redis
+  end
+
+
+  context "having one message on the queue" do
+    before do
+      @redis.del(@redis_queue)
+      @redis.del(@in_progress_queue)
+      expect(@redis.llen(@redis_queue)).to eq 0
+      @emitter.emit  # emit a message
+
+      expect(@redis.llen(@redis_queue)).to eq 1
+      expect(@forwarder._processed).to eq 0
+    end
+
+    it "should re-publish messages off the queue" do
+
+      # Spy on the publish method
+      expect(@forwarder).to receive(:publish).once { |topic, data|
+        expect(topic).to eq "harrys-#{Rails.env}-v1-default_emitters"
+        expect(data).to include "DefaultEmitter_1_0"
+      }
+
+      @forwarder.process_queue
+
+      # We should have processed the one message
+      expect(@redis.llen(@redis_queue)).to eq 0
+      expect(@forwarder._processed).to eq 1
+
+      # Just check that we can handle an empty queue OK
+      @forwarder.process_queue
+      expect(@redis.llen(@redis_queue)).to eq 0
+      expect(@forwarder._processed).to eq 1
+    end
+
+    it "should have an in_progress message temporarily" do
+      # Inside the publish method, let's inspect the in_progress queue
+      expect(@forwarder).to receive(:publish).once { |topic, data|
+        expect(@redis.llen(@in_progress_queue)).to eq 1
+        expect(@redis.lrange(@in_progress_queue, 0, 1)[0]).to eq data
+      }
+      @forwarder.process_queue
+      expect(@redis.llen(@in_progress_queue)).to eq 0
+    end
+
+    it "should re-queue failed messages" do
+      # Check what happens when publish() raises an exception...
+      expect(@forwarder).to receive(:publish).once.and_raise("dummy publishing error")
+      @forwarder.process_queue # will fail and put it back on the queue
+      expect(@redis.llen(@redis_queue)).to eq 1
+      expect(@redis.llen(@in_progress_queue)).to eq 0
+      expect(@forwarder._processed).to eq 0
+
+      # Now process again with no errors...
+      expect(@forwarder).to receive(:publish).once
+      @forwarder.process_queue # will fail and put it back on the queue
+      expect(@redis.llen(@redis_queue)).to eq 0
+      expect(@forwarder._processed).to eq 1
+    end
+
+    context "with an abandoned message" do
+      before do
+        @redis.rpoplpush(@redis_queue, @in_progress_queue)
+        expect(@redis.llen(@redis_queue)).to eq 0
+        expect(@redis.llen(@in_progress_queue)).to eq 1
+      end
+
+      it "should re-queue timed-out in-progress messages" do
+        @forwarder.check_for_failures
+        expect(@redis.llen(@redis_queue)).to eq 1
+        expect(@redis.llen(@in_progress_queue)).to eq 0
+
+      end
+    end
+
+    it "should check the in-progress queue at the right times" do
+      now = Time.now
+      expect(@forwarder).to receive(:check_for_failures).once
+      expect(@forwarder).to receive(:process_queue).once.and_call_original
+      @forwarder.run
+      Timecop.freeze(now + 1.second) {
+        expect(@forwarder).not_to receive(:check_for_failures)
+        expect(@forwarder).to receive(:process_queue).once.and_call_original
+        @forwarder.run
+      }
+    end
+  end
+end

data/spec/redis_publisher_spec.rb

@@ -0,0 +1,36 @@
+
+require 'spec_helper'
+require_relative 'pipeline_helper'
+
+describe RailsPipeline::RedisPublisher do
+  before do
+    @test_emitter = TestRedisEmitter.new({foo: "bar"}, without_protection: true)
+    @default_emitter = DefaultRedisEmitter.new({foo: "baz"}, without_protection: true)
+  end
+
+  it "should publish message to Redis" do
+    Redis.any_instance.should_receive(:lpush).once { |instance, key, serialized_encrypted_data|
+      key.should eql RailsPipeline::RedisPublisher.namespace
+      encrypted_data = RailsPipeline::EncryptedMessage.parse(serialized_encrypted_data)
+      expect(encrypted_data.type_info).to eq(DefaultEmitter_1_0.to_s)
+      serialized_payload = DefaultEmitter.decrypt(encrypted_data)
+      data = DefaultEmitter_1_0.parse(serialized_payload)
+      expect(data.foo).to eq("baz")
+      # message is encrypted, but we tested that in pipeline_emitter_spec
+    }
+    @default_emitter.emit
+  end
+
+  it "just print some timings" do
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+    @default_emitter.emit
+  end
+
+
+end

data/spec/sns_publisher_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require_relative 'pipeline_helper'
+
+describe RailsPipeline::SnsPublisher do
+  before do
+    @default_emitter = DefaultSnsEmitter.new({foo: "baz"}, without_protection: true)
+  end
+
+  it "should publish message to SNS" do
+    allow_any_instance_of(AWS::SNS::Topic).to receive(:publish) { |instance, message, options|
+      options[:subject].should eql "DefaultSnsEmitter-"
+      options[:sqs].should eql message
+      encrypted_data = RailsPipeline::EncryptedMessage.parse(message)
+      expect(encrypted_data.type_info).to eq(DefaultEmitter_1_0.to_s)
+      serialized_payload = DefaultEmitter.decrypt(encrypted_data)
+      data = DefaultEmitter_1_0.parse(serialized_payload)
+      expect(data.foo).to eq("baz")
+      # message is encrypted, but we tested that in pipeline_emitter_spec
+    }
+    @default_emitter.emit
+  end
+
+  # Skipped since I can't be bothered to set permissions in circle
+  skip "should actually send to sns" do
+    @default_emitter.emit
+  end
+
+end

data/spec/subscriber_spec.rb

@@ -0,0 +1,278 @@
+
+require 'spec_helper'
+require 'pipeline_helper'
+
+describe RailsPipeline::Subscriber do
+  before do
+    @test_emitter = TestEmitter.new({foo: "bar"}, without_protection: true)
+
+    @test_message = @test_emitter.create_message("2_0", RailsPipeline::EncryptedMessage::EventType::CREATED)
+    @subscriber = TestSubscriber.new
+    TestSubscriber.handler_method_cache = {}
+    OtherSubscriber.handler_method_cache = {}
+  end
+
+
+  context "when there is no compatible version registered for the message" do
+      before do
+        RailsPipeline::Subscriber.register(TestEmitter_2_0, TestModel)
+      end
+
+      it "should handle correct messages" do
+          expect(@subscriber).to receive(:handle_payload).once
+          @subscriber.handle_envelope(@test_message)
+      end
+  end
+
+  context "when there is a compatible version registered for the message" do
+      before do
+          @test_emitter = TestEmitter.new({foo: "bar"}, without_protection: true)
+          RailsPipeline::Subscriber.stub(:registered_handlers){{}}
+      end
+
+      it "should log the inability to process the message" do
+          expect(RailsPipeline.logger).to receive(:info).once
+          @subscriber.handle_envelope(@test_message)
+      end
+  end
+
+  it "should raise exception on malformed messages" do
+    @test_message = RailsPipeline::EncryptedMessage.new(salt: "jhkjehd", iv: "khdkjehdkejhdkjehdkjhed")
+    expect(@subscriber).not_to receive(:handle_payload)
+    expect{@subscriber.handle_envelope(@test_message)}.to raise_error
+  end
+
+  describe 'api_key' do
+    before do
+      @test_message = @test_emitter.create_message("2_0", RailsPipeline::EncryptedMessage::EventType::CREATED)
+    end
+
+    context 'with wrong api key' do
+      it "should drop messages" do
+        @test_message.api_key = '123XYZ'
+        expect{@subscriber.handle_envelope(@test_message)}.to raise_error(RailsPipeline::Subscriber::WrongApiKeyError)
+      end
+    end
+
+    context 'with no api key' do
+      it "should drop messages" do
+        @test_message.api_key = nil
+        expect{@subscriber.handle_envelope(@test_message)}.to raise_error(RailsPipeline::Subscriber::NoApiKeyError)
+      end
+    end
+
+    context 'with a correct api key' do
+      it "should accept the envelope with correct api_key" do
+        stub_const('ENV', {'PIPELINE_API_KEYS' => '123XYZ'})
+        @test_message.api_key = '123XYZ'
+        expect{@subscriber.handle_envelope(@test_message)}.not_to raise_error
+      end
+
+      it "should accept the envelope with any correct api_key" do
+        stub_const('ENV', {'PIPELINE_API_KEYS' => '123XYZ,456UVW'})
+        @test_message.api_key = '456UVW'
+        expect{@subscriber.handle_envelope(@test_message)}.not_to raise_error
+      end
+    end
+  end
+
+  context "with decrypted payload" do
+    before do
+      @payload_str = @subscriber.class.decrypt(@test_message)
+      clazz = Object.const_get(@test_message.type_info)
+      @payload = clazz.parse(@payload_str)
+    end
+
+    it "should get the version right" do
+      expect(@payload.class.name).to eq "TestEmitter_2_0"
+      version = @subscriber._version(@payload)
+      expect(version).to eq RailsPipeline::PipelineVersion.new("2_0")
+    end
+
+    context "with registered target class" do
+      before do
+        RailsPipeline::Subscriber.register(TestEmitter_2_0, TestModel)
+      end
+
+      context 'without handler' do
+        it "should map to the right target" do
+          expect(@subscriber.target_class(@payload)).to eq TestModel
+        end
+
+        it "should instantiate a target" do
+          expect(TestModel).to receive(:new).once.and_call_original
+          expect(TestModel).to receive(:from_pipeline_2_0).once.and_call_original
+          allow_any_instance_of(TestModel).to receive(:save!)
+          target = @subscriber.handle_payload(@payload, @test_message)
+          expect(target.foo).to eq @payload.foo
+        end
+      end
+
+      context 'with a handler' do
+        before do
+          RailsPipeline::Subscriber.register(
+            TestEmitter_2_0, TestModel, RailsPipeline::SubscriberHandler::ActiveRecordCRUD)
+        end
+
+        it 'should map to the correct handler' do
+          expect(@subscriber.target_handler(@payload)).to eq(RailsPipeline::SubscriberHandler::ActiveRecordCRUD)
+        end
+
+        it 'should call the correct handler' do
+          expect_any_instance_of(RailsPipeline::SubscriberHandler::ActiveRecordCRUD).to receive(:handle_payload).once
+          target = @subscriber.handle_payload(@payload, @test_message)
+        end
+      end
+    end
+
+    context "with a registered target Proc" do
+      before do
+        @called = false
+        RailsPipeline::Subscriber.register(TestEmitter_2_0, Proc.new {
+          @called = true
+        })
+      end
+
+      it "should map to the right target" do
+        expect(@subscriber.target_class(@payload).is_a?(Proc)).to eq true
+      end
+
+      it "should run the proc" do
+        @subscriber.handle_payload(@payload, @test_message)
+        expect(@called).to eq true
+      end
+    end
+
+
+    context "without registered target" do
+      before do
+        RailsPipeline::Subscriber.register(TestEmitter_2_0, nil)
+      end
+
+      it "should not instantiate a target" do
+        @subscriber.handle_payload(@payload, @test_message)
+      end
+    end
+  end
+
+  describe '#most_suitable_method' do
+    let(:subscriber) { TestSubscriber.new }
+    let(:fake_class) { Class.new }
+    before do
+      stub_const("TestClass", fake_class)
+      # Clear TestSubscriber cache
+      TestSubscriber.handler_method_cache = {}
+    end
+
+    context 'when receiver class has the correct version method' do
+      before do
+        TestClass.define_singleton_method(:from_pipeline_1_1) { }
+      end
+      let(:version) { RailsPipeline::PipelineVersion.new('1_1') }
+      it 'picks the method' do
+        subscriber.most_suitable_handler_method_name(version, TestClass).should eq(:from_pipeline_1_1)
+      end
+    end
+
+    context 'when receiver class has a handler with same major and lower minor handler method' do
+      before do
+        TestClass.define_singleton_method(:from_pipeline_1_0) { }
+      end
+      let(:version) { RailsPipeline::PipelineVersion.new('1_1') }
+      it 'picks the method' do
+        subscriber.most_suitable_handler_method_name(version, TestClass).should eq(:from_pipeline_1_0)
+      end
+    end
+
+    context 'when receiver has multiple methods defined' do
+      before do
+        TestClass.define_singleton_method(:from_pipeline_1_0) { }
+        TestClass.define_singleton_method(:from_pipeline_1_5) { }
+        TestClass.define_singleton_method(:from_pipeline_1_2) { }
+        TestClass.define_singleton_method(:from_pipeline_1_1) { }
+      end
+      let(:version) { RailsPipeline::PipelineVersion.new('1_4') }
+      it 'picks the closest lower method' do
+        subscriber.most_suitable_handler_method_name(version, TestClass).should eq(:from_pipeline_1_2)
+      end
+    end
+
+    context 'when receiver has multiple methods defined' do
+      before do
+        TestClass.define_singleton_method(:from_pipeline_1_2) { }
+        TestClass.define_singleton_method(:from_pipeline_1_0) { }
+        TestClass.define_singleton_method(:from_pipeline_1_4) { }
+        TestClass.define_singleton_method(:from_pipeline_1_5) { }
+      end
+      let(:version) { RailsPipeline::PipelineVersion.new('1_4') }
+      it 'picks the closest lower method' do
+        subscriber.most_suitable_handler_method_name(version, TestClass).should eq(:from_pipeline_1_4)
+      end
+    end
+
+    context 'when receiver class does not have a handler method' do
+      let(:version) { RailsPipeline::PipelineVersion.new('1_1') }
+      it 'returns nil' do
+        subscriber.most_suitable_handler_method_name(version, TestClass).should be_nil
+      end
+    end
+  end
+
+  context 'methods cache' do
+    let(:subscriber) { TestSubscriber.new }
+    let(:other_subscriber) { OtherSubscriber.new }
+    let(:version) { RailsPipeline::PipelineVersion.new('1_1') }
+    let(:fake_class) { Class.new }
+    before do
+      stub_const("TestClass", fake_class)
+      TestClass.define_singleton_method(:from_pipeline_1_0) { }
+    end
+
+    it 'exists' do
+      TestSubscriber.handler_method_cache.should_not be_nil
+    end
+
+    context 'with empty cache' do
+
+      it 'caches method handler for version' do
+        subscriber.most_suitable_handler_method_name(version, TestClass)
+        TestSubscriber.handler_method_cache[version].should eq(:from_pipeline_1_0)
+      end
+    end
+
+    context 'with non empty cache' do
+      before do
+        # warms the cache
+        subscriber.most_suitable_handler_method_name(version, TestClass)
+      end
+
+      it "reads value from cache" do
+        TestClass.should_not_receive(:methods)
+        TestSubscriber.handler_method_cache.should_receive(:[]).with(version).once.and_call_original
+        subscriber.most_suitable_handler_method_name(version, TestClass)
+      end
+    end
+
+    context 'cache is attached to each class' do
+      let(:fake_class2) { Class.new }
+      before do
+        stub_const("TestClass2", fake_class2)
+        TestClass2.define_singleton_method(:from_pipeline_1_1) { }
+        TestClass2.define_singleton_method(:from_pipeline_2_0) { }
+      end
+      let(:v1_1) { RailsPipeline::PipelineVersion.new('1_1') }
+      let(:v2_0) { RailsPipeline::PipelineVersion.new('2_0') }
+
+      it 'caches methods in separate buckets' do
+        subscriber.most_suitable_handler_method_name(v1_1, TestClass)
+        other_subscriber.most_suitable_handler_method_name(v1_1, TestClass2)
+        other_subscriber.most_suitable_handler_method_name(v2_0, TestClass2)
+        TestSubscriber.handler_method_cache != OtherSubscriber.handler_method_cache
+        TestSubscriber.handler_method_cache.length.should eq(1)
+        OtherSubscriber.handler_method_cache.length.should eq(2)
+      end
+    end
+  end
+
+end
+