fairway 0.0.1

data/spec/lib/fairway/channeled_connection_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+module Fairway
+  describe ChanneledConnection do
+    let(:config) do
+      Config.new do |c|
+        c.facet { |message| message[:facet] }
+      end
+    end
+    let(:connection) do
+      ChanneledConnection.new(Connection.new(config)) do |message|
+        message[:topic]
+      end
+    end
+    let(:redis)  { config.redis }
+    let(:message) { { facet: 1, topic: "event:helloworld" } }
+
+    describe "#deliver" do
+      context "multiple queues exist for message type" do
+        it "adds message for both queues" do
+          config.register_queue("myqueue", ".*:helloworld")
+          config.register_queue("yourqueue", "event:.*world")
+          connection.deliver(message)
+          redis.llen("myqueue:1").should == 1
+          redis.llen("yourqueue:1").should == 1
+        end
+      end
+
+      context "registered queue exists for message type" do
+        before do
+          config.register_queue("myqueue", "event:helloworld")
+        end
+
+        it "adds message to the environment facet for the queue" do
+          connection.deliver(message)
+          redis.llen("myqueue:1").should == 1
+          redis.lindex("myqueue:1", 0).should == message.to_json
+        end
+
+        it "adds facet to list of active facets" do
+          connection.deliver(message)
+          redis.smembers("myqueue:active_facets").should == ["1"]
+        end
+
+        it "pushes facet onto facet queue" do
+          connection.deliver(message)
+          redis.llen("myqueue:facet_queue").should == 1
+          redis.lindex("myqueue:facet_queue", 0).should == "1"
+        end
+
+        it "doesn't push onto to facet queue if currently active" do
+          redis.sadd("myqueue:active_facets", "1")
+          connection.deliver(message)
+          redis.llen("myqueue:facet_queue").should == 0
+        end
+      end
+
+      context "registered queue exists for another message type" do
+        before do
+          config.register_queue("myqueue", "foo")
+        end
+
+        it "doesn't add message to the queue" do
+          connection.deliver(message)
+          redis.llen("myqueue:1").should == 0
+        end
+
+        it "doesn't add facet to list of active facets" do
+          connection.deliver(message)
+          redis.smembers("myqueue:active_facets").should == []
+        end
+      end
+    end
+  end
+end

data/spec/lib/fairway/config_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+module Fairway
+  describe Config do
+    describe "#initialize" do
+      it "yields itself to a block" do
+        config = Config.new do |c|
+          c.namespace = "x"
+        end
+        config.namespace.should == "x"
+      end
+    end
+
+    describe "#facet" do
+      context "when called with a block" do
+        it "sets the facet" do
+          config = Config.new
+          config.facet do |message|
+            "foo"
+          end
+          config.facet.call({}).should == "foo"
+        end
+      end
+    end
+
+    it "allows setting of redis connection options" do
+      Config.new do |config|
+        config.redis = { host: "127.0.0.1", port: 6379 }
+      end
+    end
+
+    it "allows setting of redis namespace" do
+      config = Config.new do |config|
+        config.namespace = "ns"
+      end
+
+      config.namespace.should == "ns"
+    end
+
+    it "sets the default facet" do
+      config = Config.new
+      config.facet.call(environment_id: 5, facet: 1).should == Config::DEFAULT_FACET
+    end
+
+    it "allows custom faceting" do
+      config = Config.new do |config|
+        config.facet do |message|
+          message[:environment_id]
+        end
+      end
+
+      config.facet.call(environment_id: 5, facet: 1).should == 5
+    end
+  end
+end

data/spec/lib/fairway/connection_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+module Fairway
+  describe Connection do
+    let(:config) do
+      Config.new do |c|
+        c.facet { |message| message[:facet] }
+      end
+    end
+
+    let(:connection) { Connection.new(config) }
+    let(:redis)      { config.redis }
+    let(:message)    { { facet: 1, topic: "event:helloworld" } }
+
+    describe "#initialize" do
+      it "registers queues from the config" do
+        config = Config.new
+        config.register_queue("myqueue", ".*")
+        config.redis.hgetall("registered_queues").should == {}
+        Connection.new(config)
+
+        config.redis.hgetall("registered_queues").should == {
+          "myqueue" => ".*"
+        }
+      end
+
+      context "when an existing queue definition does not match" do
+        it "raises a QueueMismatchError"
+      end
+    end
+
+    describe "#deliver" do
+      it "publishes message over the message topic channel" do
+        redis = Redis.new
+
+        redis.psubscribe("*") do |on|
+          on.psubscribe do |pattern, total|
+            connection.deliver(message)
+          end
+
+          on.pmessage do |pattern, channel, received_message|
+            received_message.should == message.to_json
+            channel.should == "default"
+            redis.punsubscribe(pattern)
+          end
+        end
+      end
+
+      context "registered queue exists for message type" do
+        before do
+          config.register_queue("myqueue")
+        end
+
+        it "adds message to the environment facet for the queue" do
+          connection.deliver(message)
+          redis.llen("myqueue:1").should == 1
+          redis.lindex("myqueue:1", 0).should == message.to_json
+        end
+
+        it "adds facet to list of active facets" do
+          connection.deliver(message)
+          redis.smembers("myqueue:active_facets").should == ["1"]
+        end
+
+        it "pushes facet onto facet queue" do
+          connection.deliver(message)
+          redis.llen("myqueue:facet_queue").should == 1
+          redis.lindex("myqueue:facet_queue", 0).should == "1"
+        end
+
+        it "doesn't push onto to facet queue if currently active" do
+          redis.sadd("myqueue:active_facets", "1")
+          connection.deliver(message)
+          redis.llen("myqueue:facet_queue").should == 0
+        end
+      end
+    end
+  end
+end

data/spec/lib/fairway/queue_reader_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+module Fairway
+  describe QueueReader do
+    let(:config) do
+      Config.new do |c|
+        c.facet { |message| message[:facet] }
+      end
+    end
+    let(:connection) do
+      c = Connection.new(config)
+      ChanneledConnection.new(c) do |message|
+        message[:topic]
+      end
+    end
+    let(:message)     { { facet: 1, topic: "event:helloworld" } }
+
+    describe "#initialize" do
+      it "requires a Connection and queue names" do
+        lambda { QueueReader.new }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "#pull" do
+      before do
+        config.register_queue("myqueue", "event:helloworld")
+      end
+
+      it "pulls a message off the queue using FIFO strategy" do
+        connection.deliver(message1 = message.merge(message: 1))
+        connection.deliver(message2 = message.merge(message: 2))
+
+        reader = QueueReader.new(connection, "myqueue")
+        reader.pull.should == ["myqueue", message1.to_json]
+        reader.pull.should == ["myqueue", message2.to_json]
+      end
+
+      it "pulls from facets of the queue in a round-robin nature" do
+        connection.deliver(message1 = message.merge(facet: 1, message: 1))
+        connection.deliver(message2 = message.merge(facet: 1, message: 2))
+        connection.deliver(message3 = message.merge(facet: 2, message: 3))
+
+        reader = QueueReader.new(connection, "myqueue")
+        reader.pull.should == ["myqueue", message1.to_json]
+        reader.pull.should == ["myqueue", message3.to_json]
+        reader.pull.should == ["myqueue", message2.to_json]
+      end
+
+      it "removes facet from active list if it becomes empty" do
+        connection.deliver(message)
+
+        config.redis.smembers("myqueue:active_facets").should == ["1"]
+        reader = QueueReader.new(connection, "myqueue")
+        reader.pull
+        config.redis.smembers("myqueue:active_facets").should be_empty
+      end
+
+      it "returns nil if there are no messages to retrieve" do
+        connection.deliver(message)
+
+        reader = QueueReader.new(connection, "myqueue")
+        reader.pull.should == ["myqueue", message.to_json]
+        reader.pull.should be_nil
+      end
+
+      context "pulling from multiple queues" do
+        before do
+          config.register_queue("myqueue1", "event:1")
+          config.register_queue("myqueue2", "event:2")
+        end
+
+        it "pulls messages off first queue with a message" do
+          connection.deliver(message1 = message.merge(topic: "event:1"))
+          connection.deliver(message2 = message.merge(topic: "event:2"))
+
+          reader = QueueReader.new(connection, "myqueue2", "myqueue1")
+          reader.pull.should == ["myqueue2", message2.to_json]
+          reader.pull.should == ["myqueue1", message1.to_json]
+        end
+
+        it "returns nil if no queues have messages" do
+          reader = QueueReader.new(connection, "myqueue2", "myqueue1")
+          reader.pull.should be_nil
+        end
+
+        it "pulls from facets of the queue in a round-robin nature" do
+          connection.deliver(message1 = message.merge(facet: 1, topic: "event:1"))
+          connection.deliver(message2 = message.merge(facet: 1, topic: "event:1"))
+          connection.deliver(message3 = message.merge(facet: 2, topic: "event:1"))
+          connection.deliver(message4 = message.merge(facet: 1, topic: "event:2"))
+
+          reader = QueueReader.new(connection, "myqueue2", "myqueue1")
+          reader.pull.should == ["myqueue2", message4.to_json]
+          reader.pull.should == ["myqueue1", message1.to_json]
+          reader.pull.should == ["myqueue1", message3.to_json]
+          reader.pull.should == ["myqueue1", message2.to_json]
+        end
+      end
+    end
+  end
+end

data/spec/lib/fairway/scripts_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+module Fairway
+  describe Scripts do
+    describe "#initialize" do
+      it "requires a redis client" do
+        lambda {
+          Scripts.new
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "#method_missing" do
+      let(:scripts) { Scripts.new(Redis.new, "foo") }
+
+      it "runs the script" do
+        scripts.fairway_register_queue("namespace", "name", "topic")
+      end
+
+      context "when the script does not exist" do
+        it "loads the script" do
+          Redis.new.script(:flush)
+          scripts.fairway_register_queue("namespace", "name", "topic")
+        end
+      end
+    end
+  end
+end

data/spec/lib/fairway/sidekiq/composite_fetch_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+module Fairway::Sidekiq
+  describe CompositeFetch do
+    describe "#initialize" do
+      it "accepts a hash of fetches with priority" do
+        fetcher = CompositeFetch.new(fetcherA: 10, fetcherB: 1)
+        fetcher.fetches.should == [Array.new(10, :fetcherA), :fetcherB].flatten
+      end
+    end
+
+    describe "#fetch_order" do
+      let(:fetcher)  { CompositeFetch.new(fetcherA: 10, fetcherB: 1) }
+
+      it "should shuffle and uniq fetches" do
+        fetcher.fetches.should_receive(:shuffle).and_return(fetcher.fetches)
+        fetcher.fetch_order
+      end
+
+      it "should unique fetches list" do
+        fetcher.fetches.length.should == 11
+        fetcher.fetch_order.length.should == 2
+      end
+    end
+
+    describe "#retrieve_work" do
+      let(:work)     { mock(:work) }
+      let(:fetcherA) { mock(:fetcher) }
+      let(:fetcherB) { mock(:fetcher) }
+      let(:fetcher)  { CompositeFetch.new(fetcherA => 10, fetcherB => 1) }
+
+      before do
+        fetcher.stub(fetch_order: [fetcherA, fetcherB])
+      end
+
+      it "returns work from the first fetcher who has work" do
+        fetcherA.stub(retrieve_work: work)
+        fetcherB.should_not_receive(:retrieve_work)
+
+        fetcher.retrieve_work.should == work
+      end
+
+      it "attempts to retrieve work from each fetcher if no work is found" do
+        fetcherA.should_receive(:retrieve_work)
+        fetcherB.should_receive(:retrieve_work)
+        fetcher.retrieve_work.should be_nil
+      end
+    end
+  end
+end

data/spec/lib/fairway/sidekiq/fetcher_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+module Fairway::Sidekiq
+  describe Fetcher do
+    let(:manager) { mock(:manager) }
+    let(:fetch) { mock(:fetch) }
+
+    it "accepts a manager and a fetch strategy" do
+      fetcher = Fetcher.new(manager, fetch)
+      fetcher.mgr.should == manager
+      fetcher.strategy.should == fetch
+    end
+
+    describe "#fetch" do
+      let(:fetcher) { Fetcher.new(manager, fetch) }
+
+      it "retrieves work from fetch strategy" do
+        fetch.should_receive(:retrieve_work)
+        fetcher.fetch
+      end
+
+      it "tells manager to assign work if work is fetched" do
+        work = mock(:work)
+        fetch.stub(retrieve_work: work)
+        manager.stub(async: manager)
+        manager.should_receive(:assign).with(work)
+        fetcher.fetch
+      end
+    end
+  end
+end

data/spec/lib/fairway/sidekiq/non_blocking_fetch_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+module Fairway::Sidekiq
+  describe NonBlockingFetch do
+    let(:queues) { [:critical, :critical, :default] }
+    let(:fetch)  { NonBlockingFetch.new(queues: queues) }
+
+    it "accepts options with a list of queues and their weights" do
+      fetch.queues.should == ["queue:critical", "queue:critical", "queue:default"]
+    end
+
+    describe  "#retrieve_work" do
+      it "calls rpop script with queue order" do
+        fetch.stub(queues_cmd: ["queue:default", "queue:critical"])
+
+        ::Sidekiq.redis do |conn|
+          conn.lpush("queue:default", "default")
+          conn.lpush("queue:critical", "critical")
+        end
+
+        unit_of_work = fetch.retrieve_work
+        unit_of_work.queue_name.should == "default"
+        unit_of_work.message.should == "default"
+
+        unit_of_work = fetch.retrieve_work
+        unit_of_work.queue_name.should == "critical"
+        unit_of_work.message.should == "critical"
+      end
+    end
+  end
+end

data/spec/lib/fairway/sidekiq/queue_fetch_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+module Fairway
+  module Sidekiq
+    describe QueueFetch do
+      let(:reader) { QueueReader.new(Connection.new, "fairway") }
+      let(:work)   { { queue: "golf_events", type: "swing", name: "putt" }.to_json }
+
+      it "requests work from the queue reader" do
+        fetch = QueueFetch.new(reader)
+
+        reader.stub(pull: ["fairway", work])
+
+        unit_of_work = fetch.retrieve_work
+        unit_of_work.queue_name.should == "golf_events"
+        unit_of_work.message.should == work
+      end
+
+      it "allows transforming of the message into a job" do
+        fetch = QueueFetch.new(reader) do |fairway_queue, message|
+          message.tap do |message|
+            message["queue"] = "my_#{message["queue"]}"
+            message["class"] = "GolfEventJob"
+          end
+        end
+
+        reader.stub(pull: ["fairway", work])
+
+        unit_of_work = fetch.retrieve_work
+        unit_of_work.queue_name.should == "my_golf_events"
+        unit_of_work.message.should == JSON.parse(work).merge("queue" => "my_golf_events", "class" => "GolfEventJob").to_json
+      end
+    end
+  end
+end

data/spec/lib/fairway/subscription_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+# module Fairway
+#   describe Subscription do
+#     describe "#initialize" do
+#       it "requires a Connection"
+#       it "requires a pattern"
+#       it "requires a block"
+#       it "subscribes to the pattern"
+#     end
+
+#     context "when a message is published" do
+#       it "calls the block"
+#     end
+#   end
+# end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+ENV["RAILS_ENV"] = "test"
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require_relative "../boot"
+require "rspec/autorun"
+
+Bundler.require(:default, :test)
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+require "sidekiq"
+require "sidekiq/manager"
+require "fairway/sidekiq"
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Fairway.configure do |config|
+      config.namespace = "test:backbone"
+    end
+
+    Fairway::Config.new.redis.flushdb
+  end
+
+  config.after(:each) do
+    Fairway::Config.new.redis.flushdb
+  end
+end