emque-consuming 1.0.0.beta4

data/spec/consumer_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "emque/consuming/consumer"
+require "emque/consuming/consumer/common"
+
+class MyConsumer
+  include Emque::Consuming.consumer
+
+  def my_event(message)
+    pipe(message, :through => [
+      :keep_pipe_going, :another_method
+    ])
+  end
+
+  def my_stop_event(message)
+    pipe(message, :through => [
+      :stop_pipe, :another_method
+    ])
+  end
+
+  private
+
+  def stop_pipe(message)
+    message.with(:status => :stop)
+  end
+
+  def keep_pipe_going(message)
+    message
+  end
+
+  def another_method(message)
+    message
+  end
+
+end
+
+describe Emque::Consuming::Consumer do
+  describe "#pipe" do
+    context "when continuing pipe" do
+      it "calls all methods in the pipe chain" do
+        consumer = MyConsumer.new
+        message = Emque::Consuming::Message.new
+        expect(consumer).to receive(:another_method)
+        consumer.my_event message
+      end
+    end
+
+    context "when stopping pipe" do
+      it "stops after stop method" do
+        consumer = MyConsumer.new
+        message = Emque::Consuming::Message.new
+        expect(consumer).not_to receive(:another_method)
+        consumer.my_stop_event message
+      end
+    end
+  end
+end

data/spec/control/errors_spec.rb

@@ -0,0 +1,170 @@
+require "spec_helper"
+require "ostruct"
+
+describe Emque::Consuming::Control::Errors do
+  describe "#clear" do
+    it "resets the error_tracker's occurances hash" do
+      control = Emque::Consuming::Control::Errors.new
+      config = Emque::Consuming::Configuration.new
+      error_tracker = Emque::Consuming::ErrorTracker.new
+      app = OpenStruct.new
+      app.error_tracker = error_tracker
+      application = OpenStruct.new
+      application.config = config
+      application.instance = app
+      expect(Emque::Consuming).to receive(:application)
+        .at_least(1).times
+        .and_return(application)
+
+      error_tracker.occurrences = {
+        :one => 1,
+        :two => 2
+      }
+      control.clear
+      expect(error_tracker.occurrences).to eq({})
+    end
+  end
+
+  describe "#down" do
+    describe "when error_tracker limit is greater than 1" do
+      it "lowers the limit by 1" do
+        control = Emque::Consuming::Control::Errors.new
+        config = Emque::Consuming::Configuration.new
+        error_tracker = Emque::Consuming::ErrorTracker.new(:limit => 2)
+        app = OpenStruct.new
+        app.error_tracker = error_tracker
+        application = OpenStruct.new
+        application.config = config
+        application.instance = app
+        expect(Emque::Consuming).to receive(:application)
+          .at_least(1).times
+          .and_return(application)
+
+        expect { control.down }.to change { error_tracker.limit }.to(1)
+      end
+
+      it "changes the config error_limit to the same value" do
+        control = Emque::Consuming::Control::Errors.new
+        config = Emque::Consuming::Configuration.new
+        error_tracker = Emque::Consuming::ErrorTracker.new(:limit => 2)
+        app = OpenStruct.new
+        app.error_tracker = error_tracker
+        application = OpenStruct.new
+        application.config = config
+        application.instance = app
+        expect(Emque::Consuming).to receive(:application)
+          .at_least(1).times
+          .and_return(application)
+
+        expect { control.down }.to change { config.error_limit }.to(1)
+      end
+    end
+
+    describe "when error_tracker limit is 1" do
+      it "does not change the limit" do
+        control = Emque::Consuming::Control::Errors.new
+        config = Emque::Consuming::Configuration.new
+        error_tracker = Emque::Consuming::ErrorTracker.new(:limit => 1)
+        app = OpenStruct.new
+        app.error_tracker = error_tracker
+        application = OpenStruct.new
+        application.config = config
+        application.instance = app
+        expect(Emque::Consuming).to receive(:application)
+          .at_least(1).times
+          .and_return(application)
+
+        expect { control.down }.to_not change { error_tracker.limit }
+      end
+    end
+  end
+
+  describe "#expire_after" do
+    describe "when passed an integer" do
+      it "changes the error_tracker expiration value to the value passed" do
+        control = Emque::Consuming::Control::Errors.new
+        config = Emque::Consuming::Configuration.new
+        error_tracker = Emque::Consuming::ErrorTracker.new
+        app = OpenStruct.new
+        app.error_tracker = error_tracker
+        application = OpenStruct.new
+        application.config = config
+        application.instance = app
+        expect(Emque::Consuming).to receive(:application)
+          .at_least(1).times
+          .and_return(application)
+
+        expect { control.expire_after(1000) }.to change {
+          error_tracker.expiration
+        }.to(1000)
+      end
+
+      it "changes the config error_expiration value to the value passed" do
+        control = Emque::Consuming::Control::Errors.new
+        config = Emque::Consuming::Configuration.new
+        error_tracker = Emque::Consuming::ErrorTracker.new
+        app = OpenStruct.new
+        app.error_tracker = error_tracker
+        application = OpenStruct.new
+        application.config = config
+        application.instance = app
+        expect(Emque::Consuming).to receive(:application)
+          .at_least(1).times
+          .and_return(application)
+
+        expect { control.expire_after(1000) }.to change {
+          config.error_expiration
+        }.to(1000)
+      end
+    end
+
+    describe "when passed something other than an integer" do
+      it "raises an argument error" do
+        control = Emque::Consuming::Control::Errors.new
+        expect { control.expire_after(:invalid) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#up" do
+    it "increases the error_tracker limit by 1" do
+      control = Emque::Consuming::Control::Errors.new
+      config = Emque::Consuming::Configuration.new
+      error_tracker = Emque::Consuming::ErrorTracker.new(:limit => 1)
+      app = OpenStruct.new
+      app.error_tracker = error_tracker
+      application = OpenStruct.new
+      application.config = config
+      application.instance = app
+      expect(Emque::Consuming).to receive(:application)
+        .at_least(1).times
+        .and_return(application)
+
+      expect { control.up }.to change { error_tracker.limit }.to(2)
+    end
+
+    it "changes the config error_limit to the same value" do
+      control = Emque::Consuming::Control::Errors.new
+      config = Emque::Consuming::Configuration.new
+      error_tracker = Emque::Consuming::ErrorTracker.new(:limit => 1)
+      app = OpenStruct.new
+      app.error_tracker = error_tracker
+      application = OpenStruct.new
+      application.config = config
+      application.instance = app
+      expect(Emque::Consuming).to receive(:application)
+        .at_least(1).times
+        .and_return(application)
+
+      expect { control.up }.to change { config.error_limit }.to(2)
+    end
+  end
+
+  describe "#retry" do
+    it "starts the retry worker" do
+      control = Emque::Consuming::Control::Errors.new
+      config = Emque::Consuming::Configuration.new
+      control.retry
+    end
+  end
+end

data/spec/control_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Emque::Consuming::Control do
+  describe "#initialize" do
+    it "creates a new errors control object" do
+      expect(Emque::Consuming::Control::Errors).to receive(:new)
+      Emque::Consuming::Control.new
+    end
+
+    it "creates a new workers control object" do
+      expect(Emque::Consuming::Control::Workers).to receive(:new)
+      Emque::Consuming::Control.new
+    end
+  end
+end

data/spec/core_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+describe Emque::Consuming::Core do
+  class CoreContainer
+    extend Emque::Consuming::Core
+  end
+
+  describe ".extended" do
+    it "adds a .root accessor" do
+      expect(CoreContainer).to respond_to(:root)
+      expect(CoreContainer).to respond_to(:root=)
+    end
+
+    it "adds a .topic_mapping accessor" do
+      expect(CoreContainer).to respond_to(:topic_mapping)
+      expect(CoreContainer).to respond_to(:topic_mapping=)
+    end
+
+    it "adds a .router accessor" do
+      expect(CoreContainer).to respond_to(:router)
+      expect(CoreContainer).to respond_to(:router=)
+    end
+
+    it "adds an .instance accessor" do
+      expect(CoreContainer).to respond_to(:instance)
+      expect(CoreContainer).to respond_to(:instance=)
+    end
+
+    it "adds an alias, configure, for instance_exec" do
+      expect(CoreContainer).to respond_to(:configure)
+    end
+  end
+
+  describe ".config" do
+    describe "when @config is not set" do
+      it "initializes a new Emque::Consuming::Configuration object" do
+        expect(Emque::Consuming::Configuration).to receive(:new)
+        CoreContainer.config
+      end
+
+      it "assigns the new configuration to @config and returns it" do
+        config = double(:config)
+        expect(Emque::Consuming::Configuration).to receive(:new)
+          .and_return(config)
+
+        expect(CoreContainer.config).to eq(config)
+        expect(CoreContainer.instance_variable_get(:@config)).to eq(config)
+
+        CoreContainer.instance_variable_set(:@config, nil)
+      end
+    end
+
+    describe "when @config is set" do
+      it "returns the value of @config and does not initialize a new object" do
+        config = double(:config)
+        klass = Class.new(Object) do
+          @config = config
+          extend Emque::Consuming::Core
+        end
+
+        expect(Emque::Consuming::Configuration).to_not receive(:new)
+        expect(klass.config).to eq(config)
+      end
+    end
+  end
+
+  describe ".emque_env" do
+    it "returns the value of config.env_var if it is set" do
+      CoreContainer.config.env = "some_env_name"
+
+      expect(CoreContainer.emque_env).to eq("some_env_name")
+
+      CoreContainer.instance_variable_set(:@config, nil)
+    end
+
+    describe "when config.emque_env is not set" do
+      it "returns the ENV value, EMQUE_ENV, if it's set" do
+        CoreContainer.config.env = nil
+        old_emque_env_val = ENV["EMQUE_ENV"]
+        ENV["EMQUE_ENV"] = "some_other_env_name"
+
+        expect(CoreContainer.emque_env).to eq(ENV["EMQUE_ENV"])
+
+        ENV["EMQUE_ENV"] = old_emque_env_val
+        CoreContainer.instance_variable_set(:@config, nil)
+      end
+
+      describe "and the ENV value EMQUE_ENV is not set" do
+        it "returns the ENV value, RACK_ENV, if it's set" do
+          CoreContainer.config.env = nil
+          old_emque_env_val = ENV["EMQUE_ENV"]
+          ENV["EMQUE_ENV"] = nil
+          old_rack_env_val = ENV["RACK_ENV"]
+          ENV["RACK_ENV"] = "yet_another_env_name"
+
+          expect(CoreContainer.emque_env).to eq(ENV["RACK_ENV"])
+
+          ENV["EMQUE_ENV"] = old_emque_env_val
+          ENV["RACK_ENV"] = old_rack_env_val
+          CoreContainer.instance_variable_set(:@config, nil)
+        end
+
+        describe "and the ENV value RACK_ENV is not set" do
+          it "defaults to development" do
+            CoreContainer.config.env = nil
+            old_emque_env_val = ENV["EMQUE_ENV"]
+            ENV["EMQUE_ENV"] = nil
+            old_rack_env_val = ENV["RACK_ENV"]
+            ENV["RACK_ENV"] = nil
+
+            expect(CoreContainer.emque_env).to eq("development")
+
+            ENV["EMQUE_ENV"] = old_emque_env_val
+            ENV["RACK_ENV"] = old_rack_env_val
+            CoreContainer.instance_variable_set(:@config, nil)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/dummy/config/application.rb

@@ -0,0 +1,38 @@
+require "emque/consuming"
+
+ENV["EMQUE_ENV"] = "test"
+
+module Emque
+  module Consuming
+    module Adapters
+      module TestAdapter
+        def self.default_options; {}; end
+        def self.load; end
+        def self.manager
+          Emque::Consuming::Adapters::TestAdapter::Manager
+        end
+
+        class Manager
+          def async; self; end
+          def start; end
+          def stop; end
+          def worker(topic:, command:); end
+          def workers(flatten: false); end
+          def retry_errors; end
+        end
+      end
+    end
+  end
+end
+
+module Dummy
+  class Application
+    include Emque::Consuming::Application
+
+    self.root = File.expand_path("../..", __FILE__)
+
+    initialize_core!
+
+    config.set_adapter(:test_adapter)
+  end
+end

data/spec/error_tracker_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+require "emque/consuming/error_tracker"
+
+describe Emque::Consuming::ErrorTracker do
+  describe "#count" do
+    it "returns the number of errors not yet expired" do
+      Timecop.freeze do
+        tracker = Emque::Consuming::ErrorTracker.new
+        tracker.occurrences = {
+          :one => Time.now + (10 * 60),
+          :two => Time.now,
+          :three => Time.now - 60
+        }
+
+        expect(tracker.count).to eq(2)
+      end
+    end
+  end
+
+  describe "#limit_reached?" do
+    it "is false initially" do
+      tracker = Emque::Consuming::ErrorTracker.new
+
+      expect(tracker.limit_reached?).to eq(false)
+    end
+
+    it "is true once n(limit) unique values are noticed" do
+      tracker = Emque::Consuming::ErrorTracker.new(:limit => 2)
+
+      tracker.notice_error_for({ :first => "value" })
+      expect(tracker.limit_reached?).to eq(false)
+
+      tracker.notice_error_for({ :first => "value" })
+      expect(tracker.limit_reached?).to eq(false)
+
+      tracker.notice_error_for({ :second => "value" })
+      expect(tracker.limit_reached?).to eq(true)
+
+      tracker.notice_error_for({ :third => "value" })
+      expect(tracker.limit_reached?).to eq(true)
+    end
+
+    it "takes expiration time into account" do
+      Timecop.freeze do
+        current_time = Time.now
+
+        tracker = Emque::Consuming::ErrorTracker.new(
+          :limit => 2, :expiration => 60
+        )
+
+        tracker.notice_error_for({ :first => "value" })
+
+        Timecop.travel(current_time + 61) do
+
+          tracker.notice_error_for({ :second => "value" })
+          expect(tracker.limit_reached?).to eq(false)
+
+          tracker.notice_error_for({ :first => "value "})
+          expect(tracker.limit_reached?).to eq(true)
+        end
+      end
+    end
+  end
+end

data/spec/pidfile_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe Emque::Consuming::Pidfile do
+  describe "#initialize" do
+    it "creates a directory to hold the pidfile if it doesn't exist" do
+      path = "spec/dummy/tmp/testingpidpath"
+      pidfile = File.join(path, "pidfile.pid")
+      expect(Dir.exists?(path)).to eq(false)
+      Emque::Consuming::Pidfile.new(pidfile)
+      expect(Dir.exists?(path)).to eq(true)
+      FileUtils.rm_rf(path)
+    end
+
+    it "loads the pid from the pidfile if it already exists" do
+      path = "spec/dummy/tmp/testingpidpath"
+      pidfile = File.join(path, "pidfile.pid")
+      Emque::Consuming::Pidfile.new(pidfile)
+      File.open(pidfile, "w") do |f|
+        f.write("1000000")
+      end
+      pf = Emque::Consuming::Pidfile.new(pidfile)
+      expect(pf.to_i).to eq(1000000)
+      FileUtils.rm_rf(path)
+    end
+  end
+
+  describe "#running?" do
+    describe "when the pidfile exists" do
+      describe "and the pid is not a valid process" do
+        it "deletes the pidfile and returns false" do
+          path = "spec/dummy/tmp/testingpidpath"
+          pidfile = File.join(path, "pidfile.pid")
+          Emque::Consuming::Pidfile.new(pidfile)
+          File.open(pidfile, "w") do |f|
+            f.write("10000000")
+          end
+          pf = Emque::Consuming::Pidfile.new(pidfile)
+          expect(File.exists?(pidfile)).to eq(true)
+          expect(pf.running?).to eq(false)
+          expect(File.exists?(pidfile)).to eq(false)
+          FileUtils.rm_rf(path)
+        end
+      end
+
+      describe "and the pid is a valid process" do
+        it "returns true" do
+          path = "spec/dummy/tmp/testingpidpath"
+          pidfile = File.join(path, "pidfile.pid")
+          Emque::Consuming::Pidfile.new(pidfile)
+          File.open(pidfile, "w") do |f|
+            f.write(Process.pid)
+          end
+          pf = Emque::Consuming::Pidfile.new(pidfile)
+          expect(File.exists?(pidfile)).to eq(true)
+          expect(pf.running?).to eq(true)
+          FileUtils.rm_rf(path)
+        end
+      end
+    end
+  end
+
+  describe "#write" do
+    it "writes the current process's pid to the pidfile" do
+      path = "spec/dummy/tmp/testingpidpath"
+      pidfile = File.join(path, "pidfile.pid")
+      pf = Emque::Consuming::Pidfile.new(pidfile)
+      expect(File.exists?(pidfile)).to eq(false)
+      pf.write
+      expect(File.exists?(pidfile)).to eq(true)
+      expect(File.read(pidfile).chomp).to eq(Process.pid.to_s)
+      FileUtils.rm_rf(path)
+    end
+  end
+end

data/spec/router_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "emque/consuming/consumer"
+require "emque/consuming/consumer/common"
+
+describe Emque::Consuming::Router do
+  describe "#topic" do
+    it "uses strings as mapping keys" do
+      router = Emque::Consuming::Router.new
+      mappings = router.topic("events" => "EventsConsumer") do
+        map "events.new" => "new_event"
+      end
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+describe Emque::Consuming::Runner do
+  describe "#initialize" do
+    it "initializes a new control object" do
+      expect(Emque::Consuming::Control).to receive(:new).and_return(nil)
+      Emque::Consuming::Runner.new
+    end
+
+    it "initializes a new status object" do
+      expect(Emque::Consuming::Status).to receive(:new).and_return(nil)
+      Emque::Consuming::Runner.new
+    end
+
+    it "initializes the logger" do
+      app = double(:application, :root => "/")
+      expect(app).to receive(:config)
+        .and_return(Emque::Consuming::Configuration.new)
+      expect(Emque::Consuming).to receive(:application)
+        .at_least(1).times
+        .and_return(app)
+      expect(app).to receive(:initialize_logger).and_return(nil)
+
+      Emque::Consuming::Runner.new
+    end
+
+    it "stores itself on the class variable instance" do
+      instance = Emque::Consuming::Runner.new
+      expect(Emque::Consuming::Runner.instance).to eq(instance)
+    end
+
+    it "creates a new pidfile object" do
+      expect(Emque::Consuming::Pidfile).to receive(:new).and_return(nil)
+      Emque::Consuming::Runner.new
+    end
+
+    it "passes valid options to the app configuration" do
+      valid_opts = {
+        :app_name => "testing",
+        :error_limit => 5,
+        :status => :one
+      }
+      invalid_opts = {
+        :not => :valid,
+        :also => :not_valid,
+        :another => 50
+      }
+
+      app = double(:application, :initialize_logger => nil, :root => "/")
+      config = Emque::Consuming::Configuration.new
+      expect(Emque::Consuming).to receive(:application)
+        .at_least(1).times
+        .and_return(app)
+      expect(app).to receive(:config)
+        .at_least(1).times
+        .and_return(config)
+
+      valid_opts.each do |meth, val|
+        expect(config).to receive("#{meth}=").with(val)
+      end
+
+      invalid_opts.each do |meth, val|
+        expect(config).to_not receive("#{meth}=")
+      end
+
+      Emque::Consuming::Runner.new(valid_opts.merge(invalid_opts))
+    end
+  end
+
+  describe "#start" do
+    it "exits if the specified pidfile already exists" do
+      runner = Emque::Consuming::Runner.new
+      expect(runner).to receive(:pid)
+        .at_least(1).times
+        .and_return(double(:pid, :running? => true))
+
+      expect { runner.start }.to raise_error(SystemExit)
+    end
+
+    it "daemonizes the process if the daemon option is set" do
+      runner = Emque::Consuming::Runner.new(:daemon => true)
+      expect(runner).to receive(:receivers).at_least(1).times.and_return([])
+      expect(runner).to receive(:persist).and_return(double(:join => true))
+      expect(runner).to receive(:pid)
+        .at_least(1).times
+        .and_return(double(:running? => false, :write => true))
+
+      expect(runner).to receive(:daemonize!).and_return(true)
+      runner.start
+    end
+
+    it "creates a unix socket receiver and starts it" do
+      runner = Emque::Consuming::Runner.new
+      expect(runner).to receive(:persist).and_return(double(:join => true))
+      expect(runner).to receive(:pid)
+        .at_least(1).times
+        .and_return(double(:running? => false, :write => true))
+      socket = double(:unix_socket, :start => true)
+
+      expect(Emque::Consuming::CommandReceivers::UnixSocket)
+        .to receive(:new).and_return(socket)
+      expect(socket).to receive(:start)
+      runner.start
+    end
+
+    it "creates a http receiver and starts it if the status is set to :on" do
+      runner = Emque::Consuming::Runner.new(:status => :on)
+      expect(runner).to receive(:persist).and_return(double(:join => true))
+      expect(runner).to receive(:pid)
+        .at_least(1).times
+        .and_return(double(:running? => false, :write => true))
+      http = double(:http_server, :start => true)
+
+      expect(Emque::Consuming::CommandReceivers::HttpServer)
+        .to receive(:new).and_return(http)
+      expect(http).to receive(:start)
+      runner.start
+    end
+
+    it "starts the application" do
+      runner = Emque::Consuming::Runner.new
+      expect(runner).to receive(:persist).and_return(double(:join => true))
+      expect(runner).to receive(:pid)
+        .at_least(1).times
+        .and_return(double(:running? => false, :write => true))
+      socket = double(:unix_socket, :start => true)
+      expect(Emque::Consuming::CommandReceivers::UnixSocket)
+        .to receive(:new).and_return(socket)
+      app = Emque::Consuming.application.new
+      expect(Emque::Consuming.application).to receive(:instance)
+        .at_least(1).times
+        .and_return(app)
+
+      expect(app).to receive(:start)
+      runner.start
+    end
+  end
+end