qtrix 0.0.1

data/spec/qtrix/override_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Qtrix::Override do
+  include Qtrix::Namespacing
+  include_context "established default and night namespaces"
+
+  let(:queues) {[:a, :b, :c]}
+  let(:matrix) {Qtrix::Matrix}
+  let(:default_overrides) {raw_redis.llen("qtrix:default:overrides")}
+  let(:night_overrides) {raw_redis.llen("qtrix:night:overrides")}
+
+  before do
+    raw_redis.del "qtrix:default:overrides"
+    raw_redis.del "qtrix:night:overrides"
+  end
+
+  def override_count(ns=:current)
+    override = Qtrix::Override.all(ns).detect{|o| o.queues == queues}
+    override ? override.processes : 0
+  end
+
+  describe "#add" do
+    describe "with no namespace passed" do
+      it "should persist the override in the current ns" do
+        Qtrix::Override.add(queues, 1)
+        default_overrides.should == 1
+      end
+
+      it "should persist multiple processes as multiple rows" do
+        Qtrix::Override.add(queues, 1)
+        Qtrix::Override.add(queues, 1)
+        default_overrides.should == 2
+      end
+
+      it "should raise errors if the processes are zero" do
+        expect{Qtrix::Override.add(queues, 0)}.to raise_error
+      end
+
+      it "should blow away the matrix in the current ns" do
+        Qtrix::Override.add(queues, 1)
+        matrix.to_table.should be_empty
+      end
+    end
+
+    describe "with namespace passed" do
+      it "should persist the override in the target ns" do
+        Qtrix::Override.add(:night, queues, 1)
+        night_overrides.should == 1
+        default_overrides.should == 0
+      end
+    end
+  end
+
+  describe "#remove" do
+    describe "with no namespace passed" do
+      it "should remove the override in the current ns" do
+        Qtrix::Override.add(queues, 1)
+        Qtrix::Override.remove(queues, 1)
+        default_overrides.should == 0
+      end
+
+      it "should blow away the matrix in the current ns" do
+        Qtrix::Override.remove(queues, 100)
+        matrix.to_table.should be_empty
+      end
+    end
+
+    describe "with namespace passed" do
+      it "should remove the override in the target ns" do
+        Qtrix::Override.add(:night, queues, 2)
+        Qtrix::Override.remove(:night, queues, 1)
+        night_overrides.should == 1
+        default_overrides.should == 0
+      end
+
+      it "should blow away the matrix in the target ns" do
+        Qtrix::Override.remove(:night, queues, 100)
+        matrix.to_table(:night).should be_empty
+      end
+    end
+  end
+
+  describe "#clear!" do
+    describe "with no namespace passed" do
+      it "should drop all override data from redis" do
+        Qtrix::Override.add(queues, 1)
+        Qtrix::Override.clear!
+        redis.exists(Qtrix::Override::REDIS_KEY).should_not == true
+      end
+
+      it "should blow away the matrix" do
+        Qtrix::Override.clear!
+        matrix.to_table.should be_empty
+      end
+    end
+
+    describe "with namespace passed" do
+      it "should drop override data from the target namespace" do
+        Qtrix::Override.add(:night, queues, 1)
+        Qtrix::Override.clear! :night
+        raw_redis.llen("qtrix:night:overrides").should == 0
+      end
+
+      it "should blow away the matrix in target namespace" do
+        Qtrix::Override.clear!(:night)
+        matrix.to_table(:night).should be_empty
+      end
+    end
+  end
+
+  describe "#overrides_for" do
+    describe "with no namespace passed" do
+      it "should return an empty list if no overrides are present" do
+        Qtrix::Override.overrides_for("host1", 1).should == []
+      end
+
+      it "should return a list of queues from an unclaimed override" do
+        Qtrix::Override.add(queues, 1)
+        Qtrix::Override.overrides_for("host1", 1).should == [queues]
+      end
+
+      it "should associate the host with the override" do
+        Qtrix::Override.add(queues, 1)
+        Qtrix::Override.overrides_for("host1", 1)
+        result = Qtrix::Override.all.detect{|override| override.host == "host1"}
+        result.should_not be_nil
+      end
+
+      it "should return existing claims on subsequent invocations" do
+        Qtrix::Override.add(queues, 1)
+        expected = Qtrix::Override.overrides_for("host1", 1)
+        result = Qtrix::Override.overrides_for("host1", 1)
+        result.should == expected
+      end
+
+      it "should not return overrides beyond the current count of overrides" do
+        Qtrix::Override.add(queues, 1)
+        Qtrix::Override.overrides_for("host1", 3).should == [queues]
+      end
+
+      it "should not return overrides beyond the requested number of overrides" do
+        Qtrix::Override.add(queues, 5)
+        Qtrix::Override.overrides_for("host1", 1).should == [queues]
+      end
+    end
+
+    describe "with namespace passed" do
+      it "should limit the operation to the passed namespace" do
+        Qtrix::Override.add(:night, queues, 1)
+        Qtrix::Override.overrides_for(:current, "host", 1).should == []
+        Qtrix::Override.overrides_for(:night, "host", 1).should == [queues]
+      end
+    end
+  end
+end

data/spec/qtrix/queue_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+class DummyJob
+  @queue = :test_queue
+end
+
+describe Qtrix::Queue do
+  include Qtrix::Namespacing
+  before(:each) do
+    Qtrix::Queue.map_queue_weights a: 2, b: 3
+  end
+  let(:all_queues) {Qtrix::Queue.all_queues}
+  let(:queue1) {all_queues[1]}
+  let(:queue2) {all_queues[0]}
+  let(:matrix) {Qtrix::Matrix}
+
+  context "comparing two queues with the same name and weights" do
+    let(:other_queue) {Qtrix::Queue.new(:current, :a, 2)}
+    describe "#==" do
+      it "should return true" do
+        queue1.should == other_queue
+      end
+    end
+
+    describe "#hash" do
+      it "should return the same result" do
+        queue1.hash.should == other_queue.hash
+      end
+    end
+  end
+
+  context "comparing two queues with the same name and different weights" do
+    let(:other_queue) {other_queue = Qtrix::Queue.new(:current, :a, 3)}
+    describe "#==" do
+      it "should return false" do
+        queue1.should_not == other_queue
+      end
+    end
+
+    describe "#hash" do
+      it "should return different results" do
+        queue1.hash.should_not == other_queue.hash
+      end
+    end
+  end
+
+  context "comparing two queues with the same weight and different names" do
+    let(:other_queue) {other_queue = Qtrix::Queue.new(:default, :b, 2)}
+    describe "#==" do
+      it "should return false" do
+        queue1.should_not == other_queue
+      end
+    end
+
+    describe "#hash" do
+      it "should return different results" do
+        queue1.hash.should_not == other_queue.hash
+      end
+    end
+  end
+
+  describe "#resource_percentage" do
+    it "should equal weight / total weight of all queues" do
+      queue1.resource_percentage.should == 0.4
+      queue2.resource_percentage.should == 0.6
+    end
+  end
+
+  context "class instance methods" do
+    include_context "established default and night namespaces"
+    describe "#map_queue_weights" do
+      context "no namespace specified" do
+        it "should remove old queues" do
+          Qtrix::Queue.map_queue_weights A: 100
+          result = Qtrix::Queue.all_queues.map(&:name)
+          result.include?(:B).should_not be_true
+          result.include?(:C).should_not be_true
+        end
+
+        it "should add new queues ordered according to weight" do
+          results = Qtrix::Queue.all_queues
+          results.map(&:name).should == [:A, :B, :C]
+          results.map(&:weight).should == [3, 2, 1]
+        end
+
+        it "should error when trying to save empty queue name" do
+          expect{Qtrix::Queue.map_queue_weights('' => 1)}.to raise_error
+        end
+
+        it "should error when trying to save nil weight" do
+          expect{Qtrix::Queue.map_queue_weights(c: nil)}.to raise_error
+        end
+
+        it "should error when trying to save weight of 0" do
+          expect{Qtrix::Queue.map_queue_weights(c: 0)}.to raise_error
+        end
+
+        it "should blow away the matrix" do
+          matrix.queues_for!('host1', 1)
+          matrix.to_table.should_not be_empty
+          Qtrix::Queue.map_queue_weights \
+            A: 1,
+            B: 2
+          matrix.to_table.should be_empty
+        end
+      end
+
+      context "namespace specified" do
+        it "should affect targetted namespace" do
+          Qtrix::Queue.map_queue_weights :night, Z: 10, X: 1, Y: 5
+          Qtrix::Queue.all_queues(:night).map(&:name).should == [:Z, :Y, :X]
+        end
+      end
+    end
+
+    describe "#all_queues" do
+      describe "with no namepsace specified" do
+        it "should contain all queues in the default ns sorted by weight desc" do
+          Qtrix::Queue.all_queues.map(&:name).should == [:A, :B, :C]
+        end
+      end
+
+      describe "with namespace specified" do
+        it "should contain all queues in the default ns sorted by weight desc" do
+          result = Qtrix::Queue.all_queues(:night)
+          result.map(&:name).should == [:X, :Y, :Z]
+        end
+      end
+    end
+
+    describe "#count" do
+      context "with no namespace specified" do
+        it "should be the number of queues mapped in the current namespace" do
+          Qtrix::Queue.count.should == 3
+        end
+      end
+      context "with namespace specifeid" do
+        it "should be the number of queues mapped in the target namespace" do
+          Qtrix::Queue.map_queue_weights(:night, a: 2)
+          Qtrix::Queue.count(:night).should == 1
+        end
+      end
+    end
+
+    describe "#total_weight" do
+      context "with no namespace specified" do
+        it "should contain the sum of all weights" do
+          Qtrix::Queue.total_weight == 6
+        end
+      end
+
+      context "with namespace provided" do
+        it "should contain the sum of all weights in the namespace" do
+          Qtrix::Queue.total_weight(:night) == 7
+        end
+      end
+    end
+
+    describe "#clear!" do
+      context "with no namespace specified" do
+        before(:each) {Qtrix::Queue.clear!}
+        it "should remove all existing queue weights" do
+          redis.exists(Qtrix::Queue::REDIS_KEY).should_not == true
+        end
+
+        it "should blow away the matrix" do
+          matrix.to_table.should be_empty
+        end
+      end
+
+      context "with namespace specified" do
+        before(:each) {Qtrix::Queue.clear! :night}
+        it "should remove all existing queue weights" do
+          redis(:night).exists(Qtrix::Queue::REDIS_KEY).should_not == true
+        end
+
+        it "should blow away the matrix" do
+          matrix.to_table(:night).should be_empty
+        end
+      end
+    end
+  end
+end

data/spec/qtrix_spec.rb

@@ -0,0 +1,204 @@
+require 'set'
+require 'spec_helper'
+
+describe Qtrix do
+
+  let(:namespace_manager) {Qtrix::Namespacing::Manager.instance}
+
+  describe "operations for configuration sets" do
+    describe "#configuration_sets" do
+      it "should return all namespaces" do
+        Qtrix.configuration_sets.should == [:default]
+      end
+    end
+
+    describe "#create_configuration_set" do
+      it "should create a namespace" do
+        Qtrix.create_configuration_set :weekend
+        namespace_manager.namespaces.sort.should == [:default, :weekend]
+      end
+    end
+
+    describe "#remove_configuration_set!" do
+      it "should remove a namespace" do
+        namespace_manager.add_namespace :daytime
+        Qtrix.remove_configuration_set! :daytime
+        namespace_manager.namespaces.should == [:default]
+      end
+    end
+
+    describe "#current_configuration_set" do
+      it "should return the current namespace" do
+        Qtrix.current_configuration_set.should == :default
+      end
+    end
+
+    describe "#activate_configuration_set!" do
+      it "should set the current namespace" do
+        namespace_manager.add_namespace :weekend
+        Qtrix.map_queue_weights :weekend, A: 10
+        Qtrix.activate_configuration_set! :weekend
+        namespace_manager.current_namespace.should == :weekend
+      end
+    end
+  end
+
+  describe "#desired_distribution" do
+    include_context "established default and night namespaces"
+    let(:desired_dist) {Qtrix.desired_distribution}
+    let(:qtrix_queues) {Set.new(desired_dist.map(&:name)).to_a}
+
+    it "should include the list of known queues" do
+      known_queues = Qtrix::Queue.all_queues
+      Qtrix.desired_distribution.should == known_queues
+    end
+
+    it "should be constrainable to a config set." do
+      known_queues = Qtrix::Queue.all_queues :night
+      Qtrix.desired_distribution(:night).should == known_queues
+    end
+  end
+
+  describe "#map_queue_weights" do
+    include_context "established default and night namespaces"
+    it "should persist the mappings of queues to weights" do
+      Qtrix.map_queue_weights \
+        B: 0.3,
+        A: 0.4,
+        D: 0.1,
+        C: 0.2
+      effects = Qtrix.desired_distribution
+      effects.map(&:name).should == [:A, :B, :C, :D]
+      effects.map(&:weight).should == [0.4, 0.3, 0.2, 0.1]
+    end
+
+    it "should be constrainable to a config set" do
+      Qtrix.map_queue_weights(:night, A: 100)
+      known_queues = Qtrix::Queue.all_queues :night
+      Qtrix.desired_distribution(:night).should == known_queues
+    end
+  end
+
+  describe "override methods" do
+    include_context "established default and night namespaces"
+    def override_counts
+      [Qtrix::Override.all.size, Qtrix::Override.all(:night).size]
+    end
+
+    let(:default_overrides) {Qtrix::Override.all.map{|o| o.queues}}
+    let(:night_overrides) {Qtrix::Override.all(:night).map{|o| o.queues}}
+    let(:default_size) {Qtrix::Override.all.size}
+    let(:night_size) {Qtrix::Override.all(:night).size}
+
+    describe "#add_override" do
+      it "should persist the override to redis" do
+        Qtrix.add_override([:a, :b, :c], 2)
+        default_overrides[-2..-1].should == [[:a, :b, :c], [:a, :b, :c]]
+      end
+
+      it "should be directable to a config set" do
+        default_before, night_before = override_counts
+        Qtrix.add_override(:night, [:abc], 2)
+        default_after, night_after = override_counts
+        default_after.should == default_before
+        (night_after > night_before).should == true
+      end
+    end
+
+    describe "#remove_override" do
+      it "should remove the override from redis" do
+        Qtrix.add_override([:abc], 2)
+        Qtrix.remove_override([:abc], 2)
+        default_overrides.select{|ql| ql == [:abc]}.should be_empty
+      end
+
+      it "should be directable to a config set" do
+        Qtrix.add_override(:night, [:abc], 2)
+        default_before, night_before = override_counts
+        Qtrix.remove_override(:night, [:abc], 2)
+        default_after, night_after = override_counts
+        default_after.should == default_before
+        (night_after < night_before).should == true
+      end
+    end
+
+    describe "#overrides" do
+      it "should return all overrides from redis" do
+        Qtrix.add_override([:a, :b, :c], 1)
+        Qtrix.add_override([:x, :y, :z], 1)
+        default_overrides[-2..-1].should == [[:a, :b, :c], [:x, :y, :z]]
+      end
+
+      it "should be directable to a config set" do
+        Qtrix.add_override(:night, [:abc], 1)
+        default_cnt, night_cnt = override_counts
+        default_cnt.should == (night_cnt - 1)
+      end
+    end
+  end
+
+  describe "#queues_for!" do
+    before(:each) do
+      Qtrix.map_queue_weights \
+        A: 4,
+        B: 3,
+        C: 2,
+        D: 1
+    end
+
+    context "no overrides" do
+      it "should pick a queue list for a worker from the matrix" do
+        result = Qtrix.queues_for!('host1', 1)
+        result.should == [[:A, :B, :C, :D, :__orchestrated__]]
+      end
+    end
+
+    context "with overrides" do
+      before(:each) do
+        Qtrix.add_override([:Z], 1)
+      end
+
+      context "when requesting queus for fewer or equal workers as there are overrides" do
+        it "should pick a queue list from the overrides" do
+          Qtrix.queues_for!('host1', 1).should == [[:Z]]
+        end
+      end
+
+      context "when requeues queues for more workers than there are overrides" do
+        it "should choose queue lists from both overrides and the matrix" do
+          Qtrix.queues_for!('host1', 2)
+            .should == [[:Z],[:A,:B,:C,:D,:__orchestrated__]]
+        end
+      end
+    end
+
+    context "across hosts" do
+      it "it should appropriately distribute the queues." do
+        first_expected = [[:A, :B, :C, :D, :__orchestrated__],
+                          [:B, :A, :C, :D, :__orchestrated__]]
+        Qtrix.queues_for!('host1', 2).should == first_expected
+        second_expected = [[:C, :A, :B, :D, :__orchestrated__],
+                           [:D, :A, :B, :C, :__orchestrated__]]
+        Qtrix.queues_for!('host2', 2).should == second_expected
+      end
+    end
+  end
+
+  describe "#clear!" do
+    let(:queue_key) {Qtrix::Queue::REDIS_KEY}
+    let(:override_key) {Qtrix::Override::REDIS_KEY}
+    let(:matrix_key) {Qtrix::Matrix::REDIS_KEY}
+    before do
+      Qtrix.map_queue_weights A: 0.4
+      Qtrix::Matrix.queues_for!("localhost", 2)
+      Qtrix.add_override([:D, :A, :B, :C], 1)
+    end
+
+    it "should clear redis of all keys related to qtrix" do
+      Qtrix.clear!
+      Qtrix.redis.keys("#{matrix_key}*").should be_empty
+      Qtrix.redis.keys("#{queue_key}*").should_not be_empty
+      Qtrix.redis.keys("#{override_key}*").should_not be_empty
+    end
+  end
+end