qtrix 0.0.1

data/spec/qtrix/cli/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'stringio'
+require 'qtrix/cli'
+
+shared_context "cli commands" do
+  let(:stdout_stream) {StringIO.new}
+  let(:stderr_stream) {StringIO.new}
+
+  def stdout
+    stdout_stream.rewind
+    stdout_stream.read
+  end
+
+  def stderr
+    stderr_stream.rewind
+    stderr_stream.read
+  end
+end

data/spec/qtrix/matrix/analyzer_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Qtrix::Matrix::Analyzer do
+  before(:each) do
+    Qtrix.map_queue_weights A: 40, B: 30, C: 20, D: 10
+  end
+  let(:matrix) {Qtrix::Matrix.queues_for!("host1", 4)}
+
+  describe "#breakdown" do
+    it "results in hash of queue names to arrays of counts in each column in the matrix" do
+      result = Qtrix::Matrix::Analyzer.breakdown(matrix)
+      result.should == {
+        A: [1,3,0,0],
+        B: [1,1,2,0],
+        C: [1,0,2,1],
+        D: [1,0,0,3]
+      }
+      result.dump
+    end
+  end
+
+  describe "#analyze!" do
+    it "should map queue weights, populate matrix then break it down." do
+      expected = {
+        A: [1,3,0,0],
+        B: [1,1,2,0],
+        C: [1,0,2,1],
+        D: [1,0,0,3]
+      }
+      result = Qtrix::Matrix::Analyzer.analyze! 4, \
+        A: 40,
+        B: 30,
+        C: 20,
+        D: 10
+      result.should == expected
+    end
+  end
+end

data/spec/qtrix/matrix/queue_picker_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Qtrix::Matrix do
+  let(:matrix) {Qtrix::Matrix}
+  before(:each) do
+    Qtrix::Matrix.clear!
+    Qtrix.map_queue_weights \
+      A: 40,
+      B: 30,
+      C: 20,
+      D: 10
+  end
+
+  describe "#queues_for!" do
+    context "with no rows" do
+      it "should generate new rows" do
+        result = matrix.queues_for!('host1', 1)
+        result.should == [[:A, :B, :C, :D]]
+      end
+
+      it "should populate the persistant model" do
+        result = matrix.queues_for!('host1', 1)
+        result.should == matrix.to_table
+      end
+    end
+
+    context "with existing rows" do
+      it "should maintain existing rows if no more needed" do
+        matrix.queues_for!('host1', 1)
+        matrix.queues_for!('host1', 1)
+        matrix.fetch.size.should == 1
+      end
+
+      it "should add rows if more needed" do
+        matrix.queues_for!('host1', 1)
+        matrix.queues_for!('host1', 2)
+        matrix.fetch.size.should == 2
+      end
+
+      it "should prune rows if less are needed" do
+        matrix.queues_for!('host1', 2)
+        matrix.queues_for!('host1', 1)
+        matrix.fetch.size.should == 1
+      end
+    end
+
+    context "with multiple hosts" do
+      before do
+        matrix.queues_for!('host1', 2)
+        matrix.queues_for!('host2', 2)
+      end
+
+      let(:host1_rows) {matrix.fetch.select{|row| row.hostname == 'host1'}}
+      let(:host2_rows) {matrix.fetch.select{|row| row.hostname == 'host2'}}
+
+      context "when rows are added" do
+        it "should associate them with the specific host" do
+          matrix.queues_for!('host1', 3)
+          host1_rows.size.should == 3
+          host2_rows.size.should == 2
+        end
+      end
+
+      context "when rows are pruned" do
+        it "should prune them from the specific host" do
+          matrix.queues_for!('host2', 1)
+          host1_rows.size.should == 2
+          host2_rows.size.should == 1
+        end
+      end
+    end
+  end
+end

data/spec/qtrix/matrix_profile_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'rspec-prof'
+
+describe Qtrix::Matrix do
+  # For this test's purpose, a queues receives a score each time it appears
+  # in a row within the matrix -- 4 for being at the head of a row, 3 for
+  # being the next queue in the row, 2 for being the 3rd queue in the row
+  # and 1 for being the last queue in the row.
+  def cumulative_score_of(queue)
+    matrix = Qtrix::Matrix.to_table
+    scores = matrix.map{|row| 4 - row.index(queue)}
+    scores.inject(0) {|m, s| m += s}
+  end
+
+  def head_count_of(target_queue)
+    matrix = Qtrix::Matrix.to_table
+    heads = matrix.map{|row| row[0]}
+    heads.select{|queue| queue == target_queue}.size
+  end
+
+  let(:a_score) {cumulative_score_of(:A)}
+  let(:b_score) {cumulative_score_of(:B)}
+  let(:c_score) {cumulative_score_of(:C)}
+  let(:d_score) {cumulative_score_of(:D)}
+  let(:a_heads) {head_count_of(:A)}
+  let(:b_heads) {head_count_of(:B)}
+  let(:c_heads) {head_count_of(:C)}
+  let(:d_heads) {head_count_of(:D)}
+
+  # Check to make sure that the following holds true for 4, 10 and 100
+  # worker setups:
+  #
+  # 1.  every queue is at the head of a worker list at least once.
+  # 2.  queues with a higher weight occur more frequently to the left of queues
+  #     with a lower weight in the list of queues processed by all workers.
+  [2,5,50].each do |worker_count|
+    context "managing #{worker_count*2} workers across 2 hosts" do
+      # The following will generate profiling reports in the profiles dir.
+      profile(:all) do
+        before (:each) do
+          Qtrix::Matrix.clear!
+          Qtrix.map_queue_weights \
+            A: 40,
+            B: 30,
+            C: 20,
+            D: 10
+          Qtrix::Matrix.queues_for!('host1', worker_count)
+          Qtrix::Matrix.queues_for!('host2', worker_count)
+        end
+
+        it "should maintain the desired distribution of queues" do
+          a_score.should be >= b_score
+          b_score.should be >= c_score
+          c_score.should be >= d_score
+        end
+
+        it "should have every queue at the head of at least one worker's queue list" do
+          a_heads.should_not == 0
+          b_heads.should_not == 0
+          c_heads.should_not == 0
+          d_heads.should_not == 0
+        end
+
+        it "should maintain desired distribution of queues at the heead of queue lists" do
+          a_heads.should be >= b_heads
+          b_heads.should be >= c_heads
+          c_heads.should be >= d_heads
+        end
+      end
+    end
+  end
+end

data/spec/qtrix/matrix_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'set'
+
+describe Qtrix::Matrix do
+  describe "namespaced operations" do
+    include_context "established default and night namespaces"
+    let(:matrix) {Qtrix::Matrix}
+
+    describe "#fetch" do
+      it "should default to the current namespace" do
+        result = matrix.fetch.map{|row| row.entries.map(&:queue)}.sort
+        result.should == [[:A, :B, :C]]
+      end
+
+      it "should allow fetching from a different namespace" do
+        result = matrix.fetch(:night).map{|row| row.entries.map(&:queue)}.sort
+        result.should == [[:X, :Y, :Z]]
+      end
+    end
+
+    describe "#to_table" do
+      it "should default to the current namespace" do
+        matrix.to_table.should == [[:A, :B, :C]]
+      end
+
+      it "should allow fetching from a different namespace" do
+        matrix.to_table(:night).should == [[:X, :Y, :Z]]
+      end
+    end
+
+    describe "#clear!" do
+      it "should default to the current namespace" do
+        matrix.clear!
+        raw_redis.keys("qtrix:default:matrix*").should == []
+      end
+
+      it "should allow clearing of a different namespace" do
+        matrix.clear! :night
+        raw_redis.keys("qtrix:night:matrix*").should == []
+      end
+    end
+
+    describe "#queues_for!" do
+      context "with no namespace specified" do
+        it "should return queues from current namespace" do
+          matrix.queues_for!("host1", 1).should == [[:A, :B, :C]]
+        end
+
+        it "should auto-shuffle distribution of queues if they all have the same weight" do
+          Qtrix.map_queue_weights A: 1, B: 1, C: 1, D: 1, E: 1
+          matrix.queues_for!("host1", 100)
+          rows = matrix.to_table[5..-1]
+          dupes = Set.new
+          while(current_row = rows.shift) do
+            next if dupes.include? current_row
+            if rows.detect{|another_row| another_row == current_row}
+              dupes.add(current_row)
+            end
+          end
+          dupes.size.should be < 10
+        end
+      end
+
+      context "with namespace specified" do
+        it "should return queues from the specified namespace" do
+          matrix.queues_for!(:night, "host1", 1).should == [[:X, :Y, :Z]]
+        end
+      end
+    end
+  end
+end

data/spec/qtrix/namespacing_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe Qtrix::Namespacing do
+  include Qtrix::Namespacing
+  let(:test_class) {
+    class Foo < Object
+      include Qtrix::Namespacing
+    end
+  }
+  let(:test_instance) {test_class.new}
+
+  shared_examples_for "@redis_namespace definers #redis" do
+    it "should return redis connection namespaced to :a" do
+      target.redis.namespace.should == :a
+    end
+
+    it "should allow caller to specify namespacing" do
+      target.redis(:b, :c).set("d", 1)
+      result = raw_redis.keys.reject{|key| key[/namespace/]}
+      result.should == ["qtrix:default:a:b:c:d"]
+    end
+  end
+
+  [:test_class, :test_instance].each do |target_name|
+    context "for #{target_name}" do
+      let(:target) {send(target_name)}
+
+      describe "#redis" do
+        context "without @redis_namespace defined in self or self.class" do
+          it "should return redis connection namespaced to :default" do
+            target.redis.namespace.should == :default
+          end
+
+          it "should allow caller to specify namespacing" do
+            target.redis(:a, :b).set("c", 1)
+            raw_redis.keys.include?("qtrix:a:b:c").should == true
+          end
+
+          it "should evaluate caller arg of :current to the current namespace" do
+            target.redis(:current).set("a", 1)
+            result = raw_redis.keys.select{|key| key[/default/]}
+            result.should == ["qtrix:default:a"]
+          end
+        end
+
+        context "with @redis_namespace defined in self" do
+          around(:each) do |example|
+            target.send(:instance_variable_set, :@redis_namespace, [:current, :a])
+            example.run
+            target.send(:instance_variable_set, :@redis_namespace, nil)
+          end
+
+          it_should_behave_like "@redis_namespace definers #redis"
+        end
+
+        context "with @redis_namespace defined in class" do
+          around(:each) do |example|
+            target.class.send(:instance_variable_set, :@redis_namespace, [:current, :a])
+            example.run
+            target.class.send(:instance_variable_set, :@redis_namespace, nil)
+          end
+
+          it_should_behave_like "@redis_namespace definers #redis"
+        end
+      end
+
+      describe "#redis_namespace" do
+        context "without @redis_namespace defined in self or self.class" do
+          it "should return nil" do
+            target.redis_namespace.should == []
+          end
+        end
+
+        context "with @redis_namespace defined" do
+          around(:each) do |example|
+            target.send(:instance_variable_set, :@redis_namespace, [:current, :foo])
+            example.run
+            target.send(:instance_variable_set, :@redis_namespace, nil)
+          end
+
+          it "should return self@redis_namespace" do
+            target.redis_namespace.should == [:current, :foo]
+          end
+        end
+
+        context "with @redis_namespace defined in superclass" do
+          around(:each) do |example|
+            target.class.send(:instance_variable_set, :@redis_namespace, [:current, :foo])
+            example.run
+            target.class.send(:instance_variable_set, :@redis_namespace, nil)
+          end
+
+          it "should return class@redis_namespace" do
+            target.redis_namespace.should == [:current, :foo]
+          end
+        end
+      end
+    end
+  end
+
+  describe Qtrix::Namespacing::Manager do
+    let(:manager) {Qtrix::Namespacing::Manager.instance}
+
+    describe "#redis" do
+      context "with no args passed" do
+        it "should return a redis connection with no args" do
+          manager.redis.keys.should_not be_nil
+        end
+
+        it "should return a redis connection namespaced to qtrix:default" do
+          manager.redis.namespace.should == :default
+        end
+      end
+
+      context "with args passed" do
+        it "each arg should be a namespace for keys defined in redis" do
+          manager.redis(:foo, :bar).set("a", 1)
+          raw_redis.keys.include?("qtrix:foo:bar:a").should == true
+        end
+
+        it "should prune out any duplicate namespaces" do
+          manager.redis(:a, :a, :a).set("b", 1)
+          result = raw_redis.keys.grep(/qtrix:a/)
+          result.should == ["qtrix:a:b"]
+        end
+      end
+    end
+
+    describe "#add_namespace" do
+      it "should add a namespace to the system" do
+        manager.add_namespace(:night_distribution)
+        manager.namespaces.sort.should == [:default, :night_distribution]
+      end
+
+      it "should error when nil passed" do
+        expect{manager.add_namespace(nil)}.to raise_error
+      end
+
+      it "should error when valid pattern is not matched" do
+        expect{manager.add_namespace('#$*#($')}.to raise_error
+      end
+
+      it "should error when attempting to add an existing namespace" do
+        manager.namespaces.should_not be_empty
+        expect{manager.add_namespace(:default)}.to raise_error
+      end
+    end
+
+    describe "#remove_namesapce" do
+      include_context "an established matrix"
+      before {manager.add_namespace(:transition_flood)}
+
+      it "should remove a namespace from the system" do
+        manager.remove_namespace!(:transition_flood)
+        manager.namespaces.should == [:default]
+      end
+
+      it "should not allow you to delete the default namespace" do
+        expect{manager.remove_namespace!(:default)}.to raise_error
+      end
+
+      it "should not allow you to remove the current namespace" do
+        Qtrix.map_queue_weights(:transition_flood, A: 1)
+        manager.change_current_namespace(:transition_flood)
+        expect{manager.remove_namespace!(:transition_flood)}.to raise_error
+      end
+
+      describe "cascading removal" do
+        before do
+          Qtrix.add_override(:transition_flood, ["A"], 1)
+          Qtrix.map_queue_weights :transition_flood, B: 10
+          Qtrix::Matrix.queues_for!(:transition_flood, "host1", 2)
+        end
+
+        it "should cascade deletes to data in the namespace" do
+          manager.remove_namespace!(:transition_flood)
+          raw_redis.keys("qtrix:transition_flood*").should == []
+        end
+      end
+    end
+
+    describe "#current_namespace" do
+      it "should default to :default" do
+        manager.current_namespace.should == :default
+      end
+    end
+
+    describe "#change_current_namespace" do
+      include_context "an established matrix"
+      before(:each) {manager.add_namespace(:night_distribution)}
+
+      it "should set the current namespace" do
+        Qtrix.map_queue_weights(:night_distribution, A: 1)
+        manager.change_current_namespace(:night_distribution)
+        manager.current_namespace.should == :night_distribution
+      end
+
+      it "should error if trying to set the namespace to something unknown" do
+        expect{manager.change_current_namespace :foo}.to raise_error
+      end
+
+      it "should error if trying to change into an empty namespace" do
+        expect{manager.change_current_namespace(:night_distribution)}.to raise_error
+      end
+    end
+  end
+end