hivent 1.0.1

data/spec/hivent/redis/signal_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Hivent::Redis::Signal do
+
+  let(:signal) do
+    Hivent::Redis::Signal.new(name)
+  end
+
+  let(:name)         { "my_topic" }
+  let(:client_id)    { "client_id" }
+  let(:version)      { 5 }
+
+  before :each do
+    Hivent.configure do |config|
+      config.backend   = :redis
+      config.client_id = client_id
+    end
+  end
+
+  describe "#emit" do
+
+    subject { signal.emit(payload, version: version, cid: cid, key: key) }
+
+    let(:payload)      { { key: "value" } }
+    let(:cid)          { nil }
+    let(:key)          { SecureRandom.hex }
+    let(:redis_client) { Redis.new(url: REDIS_URL) }
+    let(:producer)     { Hivent::Redis::Producer.new(redis_client) }
+
+    before :each do
+      allow(Redis).to receive(:new).and_return(redis_client)
+      allow(Hivent::Redis::Producer).to receive(:new).with(redis_client).and_return(producer)
+    end
+
+    after :each do
+      redis_client.flushall
+    end
+
+    context "when no consuming services are configured" do
+      it "does not send the message" do
+        expect { subject }.not_to change { redis_client.keys }
+      end
+
+      it "does not raise an error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when an exception is raised" do
+      let(:max_tries)   { 2 }
+      let(:wait_period) { 0.5 }
+
+      before :each do
+        stub_const("Hivent::Redis::Signal::MAX_TRIES", max_tries)
+        stub_const("Hivent::Redis::Signal::SLEEP", wait_period)
+      end
+
+      it "retries sending the message after a wait period" do
+        tries = 0
+
+        expect(producer).to receive(:write).exactly(max_tries).times do |_message|
+          tries += 1
+
+          if tries < max_tries
+            raise Redis::CommandError.new
+          end
+        end
+
+        subject
+      end
+    end
+
+    context "when a consuming service is configured" do
+      let(:service_name)    { "some_service" }
+      let(:partition_count) { 1 }
+
+      before :each do
+        redis_client.sadd(name, service_name)
+        redis_client.set("#{service_name}:partition_count", partition_count)
+      end
+
+      it "creates a list containing the message" do
+        subject
+        item = JSON.parse(redis_client.lindex("#{service_name}:0", -1))
+
+        expect(item["payload"]).to eq(payload.with_indifferent_access)
+      end
+
+      context "when configured with more than one partition" do
+        let(:partition_count) { 2 }
+
+        it "creates a message in only one of the partitions" do
+          subject
+          items = Array.new(partition_count) do |n|
+            redis_client.lindex("#{service_name}:#{n}", -1)
+          end
+
+          expect(items.compact.length).to eq(1)
+        end
+
+        describe "message distribution" do
+          subject do
+            repetitions.times do
+              signal.emit(payload, version: version, cid: cid, key: SecureRandom.hex)
+            end
+          end
+
+          let(:partition_count) { 4 }
+          let(:repetitions)     { 1000 }
+          let(:lists) do
+            Array.new(partition_count) { |n| "#{service_name}:#{n}" }
+          end
+          let(:item_counts) do
+            lists.map { |list| redis_client.llen(list) }
+          end
+          let(:sum) { item_counts.sum }
+
+          it "publishes messages on all partitions" do
+            subject
+            expect(item_counts.all? { |count| count > 0 }).to be(true)
+          end
+
+          it "publishes all the messages emitted" do
+            subject
+            expect(sum).to be(repetitions)
+          end
+        end
+      end
+
+    end
+
+    context "when multiple consuming services are configured" do
+      let(:service_names)   { ["some_service", "other_service"] }
+      let(:partition_count) { 1 }
+
+      before :each do
+        service_names.each do |service_name|
+          redis_client.sadd(name, service_name)
+          redis_client.set("#{service_name}:partition_count", partition_count)
+        end
+      end
+
+      it "creates a list for each service containing the message" do
+        subject
+        payloads = service_names.map do |service_name|
+          JSON.parse(redis_client.lindex("#{service_name}:0", -1))["payload"]
+        end
+
+        expect(payloads.uniq).to eq([payload.with_indifferent_access])
+      end
+    end
+  end
+
+end

data/spec/hivent_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Hivent do
+
+  let(:client_id)  { "client_id" }
+
+  describe "Configuration" do
+
+    context "when configuring with an unsupported backend" do
+      it "raises an UnsupportedOption Error" do
+        expect {
+          Hivent.configure do |config|
+            config.backend = :unsupported
+          end
+        }.to raise_error(
+          Hivent::Config::Options::UnsupportedOptionError,
+          "Unsupported value :unsupported for option :backend"
+        )
+      end
+    end
+
+    context "when configuring with an empty client_id" do
+      it "raises an UnsupportedOption Error" do
+        expect {
+          Hivent.configure do |config|
+            config.client_id = nil
+          end
+        }.to raise_error(
+          Hivent::Config::Options::UnsupportedOptionError,
+          "Unsupported value nil for option :client_id"
+        )
+      end
+    end
+
+    context "when configuring with a non-integer partition_count" do
+      it "raises an UnsupportedOption Error" do
+        expect {
+          Hivent.configure do |config|
+            config.partition_count = "foo"
+          end
+        }.to raise_error(
+          Hivent::Config::Options::UnsupportedOptionError,
+          "Unsupported value \"foo\" for option :partition_count"
+        )
+      end
+    end
+
+    context "when configuring with a partition_count smaller than 1" do
+      it "raises an UnsupportedOption Error" do
+        expect {
+          Hivent.configure do |config|
+            config.partition_count = 0
+          end
+        }.to raise_error(
+          Hivent::Config::Options::UnsupportedOptionError,
+          "Unsupported value 0 for option :partition_count"
+        )
+      end
+    end
+
+    describe "accessing Configured values" do
+
+      before :each do
+        Hivent.configure do |config|
+          config.client_id = client_id
+        end
+      end
+
+      subject { Hivent::Config }
+
+      let(:client_id)  { "an_id" }
+
+      its(:client_id)  { is_expected.to eq(client_id) }
+
+    end
+
+  end
+
+  describe "Event consumption" do
+    subject { Hivent.emitter.emit "my_signal:1", increase: increase }
+
+    let(:increase)  { 5 }
+
+    after :each do
+      Hivent.emitter.remove_listener "my_signal:1"
+    end
+
+    it "consumes events" do
+      counter = 0
+      Hivent.emitter.on "my_signal:1" do |data|
+        counter += data[:increase]
+      end
+
+      expect { subject }.to change { counter }.by(increase)
+    end
+
+  end
+
+end

data/spec/spec/matchers/emit_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Hivent::Spec::Matchers do
+
+  subject do
+    Hivent::Spec::Signal.new(signal).emit(payload, version: version, cid: cid)
+  end
+
+  let(:signal)      { 'my:signal' }
+  let(:payload)     { { foo: 'bar' } }
+  let(:version)     { 1 }
+  let(:cid)         { SecureRandom.hex }
+
+  describe '#emit' do
+
+    it 'checks if an event was emitted' do
+      expect { subject }.to emit(signal)
+    end
+
+    it 'checks if an event was emitted with a given version' do
+      expect { subject }.to emit(signal, version: version)
+    end
+
+    it 'checks if an event was emitted with a given cid' do
+      expect { subject }.to emit(signal, cid: cid)
+    end
+
+    it 'checks if an event was not emitted' do
+      expect { subject }.not_to emit('other:signal')
+    end
+
+    it 'checks if an event was not emitted with a given version' do
+      expect { subject }.not_to emit(signal, version: 2)
+    end
+
+    it 'checks if an event was not emitted with a given cid' do
+      expect { subject }.not_to emit(signal, cid: 'does-not-match')
+    end
+
+    it 'checks if an event was emitted with a given payload' do
+      expect { subject }.to emit(signal).with(payload)
+    end
+
+    it 'checks if an event was not emitted with a given payload' do
+      expect { subject }.not_to emit(signal).with(bar: 'baz')
+    end
+
+    context 'when the subject emits multiple signals' do
+      subject do
+        Hivent::Spec::Signal.new(signal).emit({ bar: 'baz' }, version: version)
+        Hivent::Spec::Signal.new(signal).emit(payload, version: version)
+        Hivent::Spec::Signal.new(signal).emit({ foo: 'other' }, version: version)
+      end
+
+      it 'checks if an event was emitted' do
+        expect { subject }.to emit(signal)
+      end
+
+      it 'checks if an event was emitted with a given payload' do
+        expect { subject }.to emit(signal).with(payload)
+      end
+    end
+
+  end
+end

data/spec/spec/signal_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Hivent::Spec::Signal do
+  subject do
+    described_class.new(name)
+  end
+
+  let(:name) { "my:signal" }
+
+  describe "#emit" do
+    subject { super().emit(payload, version: version) }
+
+    let(:payload) { { foo: "bar" } }
+    let(:version) { 1 }
+
+    before :each do
+      allow(Hivent.emitter).to receive(:emit)
+    end
+
+    it "emits that event on the wildcard channel" do
+      expect(Hivent.emitter).to receive(:emit)
+        .with(Hivent::Emitter::WILDCARD, hash_including(payload: payload))
+
+      subject
+    end
+
+    it 'emits that event with the given name' do
+      expect(Hivent.emitter).to receive(:emit).with(name, hash_including(payload: payload))
+
+      subject
+    end
+
+    it 'emits that event with the given name and version' do
+      expect(Hivent.emitter).to receive(:emit).with("#{name}:#{version}", hash_including(payload: payload))
+
+      subject
+    end
+
+    context "with a Redis backend" do
+      before :each do
+        Hivent.configure do |config|
+          config.backend                  = :redis
+          config.life_cycle_event_handler = life_cycle_event_handler
+        end
+      end
+
+      let(:life_cycle_event_handler) { double }
+
+      it "notifies life cycle event handler about the processed event" do
+        expect(life_cycle_event_handler).to receive(:event_processing_succeeded)
+          .with(name, version, hash_including(payload: payload))
+        subject
+      end
+
+      context "when emitting fails" do
+
+        let(:error) { StandardError.new("error") }
+
+        before :each do
+          allow(Hivent.emitter).to receive(:emit).and_raise(error)
+        end
+
+        it "notifies life cycle event handler about the error" do
+          expect(life_cycle_event_handler).to receive(:event_processing_failed)
+            .with(error, hash_including(payload: payload), kind_of(String), kind_of(String))
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'simplecov'
+
+require 'rspec/its'
+require 'pry'
+
+require 'hivent'
+require 'hivent/rspec'
+require 'hivent/cli/runner'
+
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+end
+
+Dir.glob("#{File.expand_path(File.dirname(__FILE__))}/support/**/*.rb").each { |f| require f }
+
+REDIS_URL = ENV["REDIS_URL"].presence || "redis://localhost:6379/15"
+
+RSpec.configure do |config|
+  config.include STDOUTHelpers
+
+  config.after :each do
+    Hivent.configure {}
+    Hivent::Redis.class_variable_set(:@@redis, nil)
+  end
+end

data/spec/support/matchers/exit_with_code.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+RSpec::Matchers.define :exit_with_code do |exp_code|
+  actual = nil
+
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+      actual = e.status
+    end
+    actual && actual == exp_code
+  end
+
+  failure_message do
+    "expected block to call exit(#{exp_code}) but exit" +
+      (actual.nil? ? " not called" : "(#{actual}) was called")
+  end
+
+  failure_message_when_negated do
+    "expected block not to call exit(#{exp_code})"
+  end
+
+  description do
+    "expect block to call exit(#{exp_code})"
+  end
+
+  supports_block_expectations
+end