qfill 0.0.4 → 0.1.0

data/spec/qfill/list_spec.rb

@@ -1,44 +1,52 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::List do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-        expect { Qfill::List.new() }.to raise_error(ArgumentError)
+  describe '#new' do
+    context 'with no arguments' do
+      it 'raises ArgumentError' do
+        expect { described_class.new }.to raise_error(ArgumentError)
       end
     end
-    context "with name" do
-      before :each do
-        @arguments = { :name => "High List" }
+
+    context 'with name' do
+      before do
+        @arguments = { name: 'High List' }
       end
-      it "should not raise any errors" do
-        expect { Qfill::List.new(@arguments) }.to_not raise_error
+
+      it 'does not raise any errors' do
+        expect { described_class.new(@arguments) }.not_to raise_error
       end
-      it "should instantiate with name" do
-        Qfill::List.new(@arguments).name.should == 'High List'
+
+      it 'instantiates with name' do
+        expect(described_class.new(@arguments).name).to eq('High List')
       end
     end
-    context "with elements" do
-      before :each do
-        @arguments = {  :name => "High List",
-                        :elements => [1,2] }
+
+    context 'with elements' do
+      before do
+        @arguments = {  name: 'High List',
+                        elements: [1, 2] }
       end
-      it "should instantiate with elements" do
-        Qfill::List.new(@arguments).elements.should == [1,2]
+
+      it 'instantiates with elements' do
+        expect(described_class.new(@arguments).elements).to eq([1, 2])
       end
     end
-    context "with filter" do
-      before :each do
-        lambda = -> (object) { !object.nil? }
+
+    context 'with filter' do
+      before do
+        lambda = ->(object) { !object.nil? }
         @filter = Qfill::Filter.new(lambda)
-        @arguments = {  :name => "High List",
-                        :elements => [1, 2],
-                        :filter => @filter }
+        @arguments = {  name: 'High List',
+                        elements: [1, 2],
+                        filter: @filter }
       end
-      it "should instantiate with processor" do
-        Qfill::List.new(@arguments).filter.should be_a(Qfill::Filter)
-        Qfill::List.new(@arguments).filter.should == @filter
+
+      it 'instantiates with processor' do
+        expect(described_class.new(@arguments).filter).to be_a(Qfill::Filter)
+        expect(described_class.new(@arguments).filter).to eq(@filter)
       end
     end
   end
-
 end

data/spec/qfill/manager_spec.rb

@@ -1,588 +1,824 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::Manager do
-  #context "#new" do
-  #  context "with no arguments" do
-  #    it "should raise ArgumentError" do
-  #      expect { Qfill::Manager.new() }.to raise_error(ArgumentError)
-  #    end
-  #  end
-  #  context "with only popper" do
-  #    it "should raise ArgumentError" do
-  #      popper = Qfill::Popper.from_array_of_hashes(
-  #        [{ :name => "High List",
-  #          :elements => [1,2,3]}] )
-  #      expect { Qfill::Manager.new(:popper => popper) }.to raise_error(ArgumentError)
-  #    end
-  #  end
-  #  context "with only pusher" do
-  #    it "should raise ArgumentError" do
-  #      pusher = Qfill::Pusher.from_array_of_hashes(
-  #        [{ :name => "Some Result",
-  #           :ratio => 0.25 }] )
-  #      expect { Qfill::Manager.new(:pusher => pusher) }.to raise_error(ArgumentError)
-  #    end
-  #  end
-  #  context "with popper and pusher" do
-  #    before :each do
-  #      @popper = Qfill::Popper.from_array_of_hashes(
-  #        [{ :name => "High List",
-  #           :elements => [1,2,3]}] )
-  #      @pusher = Qfill::Pusher.from_array_of_hashes(
-  #        [{ :name => "Some Result",
-  #           :ratio => 0.25 }] )
-  #      @arguments = {
-  #        :pusher => @pusher,
-  #        :popper => @popper
-  #      }
-  #    end
-  #    it "should not raise any errors" do
-  #      expect { Qfill::Manager.new(@arguments) }.to_not raise_error
-  #    end
-  #    it "should instantiate with pusher" do
-  #      Qfill::Manager.new(@arguments).pusher.should == @pusher
-  #    end
-  #    it "should instantiate with popper" do
-  #      Qfill::Manager.new(@arguments).popper.should == @popper
-  #    end
-  #  end
-  #  context "with popper and pusher and all_list_max smaller than # total elements" do
-  #    before :each do
-  #      @popper = Qfill::Popper.from_array_of_hashes(
-  #        [{ :name => "High List",
-  #           :elements => [1,2,3]}] )
-  #      @pusher = Qfill::Pusher.from_array_of_hashes(
-  #        [{ :name => "Some Result",
-  #           :ratio => 0.25 }] )
-  #      @arguments = {
-  #        :pusher => @pusher,
-  #        :popper => @popper,
-  #        :all_list_max => 2
-  #      }
-  #    end
-  #    it "should not raise any errors" do
-  #      expect { Qfill::Manager.new(@arguments) }.to_not raise_error
-  #    end
-  #    it "should instantiate with pusher" do
-  #      Qfill::Manager.new(@arguments).pusher.should == @pusher
-  #    end
-  #    it "should instantiate with popper" do
-  #      Qfill::Manager.new(@arguments).popper.should == @popper
-  #    end
-  #    it "should instantiate with all_list_max" do
-  #      Qfill::Manager.new(@arguments).all_list_max.should == 2
-  #    end
-  #  end
-  #  context "all_list_max greater than # total elements" do
-  #    before :each do
-  #      @popper = Qfill::Popper.from_array_of_hashes(
-  #        [{ :name => "High List",
-  #           :elements => [1,2,3]}] )
-  #      @pusher = Qfill::Pusher.from_array_of_hashes(
-  #        [{ :name => "Some Result",
-  #           :ratio => 0.25 }] )
-  #      @arguments = {
-  #        :pusher => @pusher,
-  #        :popper => @popper,
-  #        :all_list_max => 666
-  #      }
-  #    end
-  #    it "should instantiate with all_list_max" do
-  #      Qfill::Manager.new(@arguments).all_list_max.should == 3
-  #    end
-  #  end
-  #end
-  context "strategy => :sample" do
-    context "backfill => false" do
-      before :each do
-        @popper = Qfill::Popper.from_array_of_hashes(
+  let(:manager) { described_class.new(arguments) }
+
+  describe '#new' do
+    context 'with no arguments' do
+      it 'raises ArgumentError' do
+        expect { described_class.new }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with only popper' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
+          [{ name: 'High List',
+             elements: [1, 2, 3] }]
+        )
+      end
+
+      it 'raises ArgumentError' do
+        expect { described_class.new(popper: popper) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with only pusher' do
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'Some Result',
+             ratio: 0.25 }]
+        )
+      end
+
+      it 'raises ArgumentError' do
+        expect { described_class.new(pusher: pusher) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with popper and pusher' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
+          [{ name: 'High List',
+             elements: [1, 2, 3] }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'Some Result',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper
+        }
+      end
+
+      it 'does not raise any errors' do
+        expect { described_class.new(arguments) }.not_to raise_error
+      end
+
+      it 'instantiates with pusher' do
+        expect(described_class.new(arguments).pusher).to eq(pusher)
+      end
+
+      it 'instantiates with popper' do
+        expect(described_class.new(arguments).popper).to eq(popper)
+      end
+    end
+
+    context 'with popper and pusher and all_list_max smaller than # total elements' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
+          [{ name: 'High List',
+             elements: [1, 2, 3] }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'Some Result',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 2
+        }
+      end
+
+      it 'does not raise any errors' do
+        expect { described_class.new(arguments) }.not_to raise_error
+      end
+
+      it 'instantiates with pusher' do
+        expect(described_class.new(arguments).pusher).to eq(pusher)
+      end
+
+      it 'instantiates with popper' do
+        expect(described_class.new(arguments).popper).to eq(popper)
+      end
+
+      it 'retains specified all_list_max' do
+        expect(described_class.new(arguments).all_list_max).to eq(2)
+      end
+    end
+
+    context 'all_list_max greater than # total elements' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
+          [{ name: 'High List',
+             elements: [1, 2, 3] }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'Some Result',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 666
+        }
+      end
+
+      it 'reduces all_list_max to number of elements' do
+        expect(described_class.new(arguments).all_list_max).to eq(3)
+      end
+    end
+  end
+
+  context 'when strategy => :sample' do
+    context 'when backfill => false' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
           # We will create 4 queues, high, medium, low, and none.
           # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
           # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
           #   but not at the expense of hte experience, would be:
           # high => medium => none => low
-          [{:name => 'high',
-            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
-            :backfill => 'medium'},
-           {:name => "medium",
-            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
-            :backfill => 'none'},
-           {:name => 'low',
-            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
-            :backfill => false},
-           {:name => 'none',
-            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
-            :backfill => 'low' }] )
-        @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "first",
-             :list_ratios => {
+          [{ name: 'high',
+             elements: %w[h1 h2 h3 h4 h5 h6 h7 h8 h9],
+             backfill: 'medium' },
+           { name: 'medium',
+             elements: %w[m1 m2 m3 m4 m5 m6 m7 m8 m9],
+             backfill: 'none' },
+           { name: 'low',
+             elements: %w[l1 l2 l3 l4 l5 l6 l7 l8 l9],
+             backfill: false },
+           { name: 'none',
+             elements: %w[n1 n2 n3 n4 n5 n6 n7 n8 n9],
+             backfill: 'low' }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'first',
+             list_ratios: {
                'high' => 0.5,
                'medium' => 0.1,
                'none' => 0.4
              },
-             :ratio => 0.25 },
-           { :name => "second",
-             :ratio => 0.50 },
-           { :name => "third",
-             :ratio => 0.25 }] )
-        @arguments = {
-          :pusher => @pusher,
-          :popper => @popper,
-          :all_list_max => 40,
-          :strategy => :sample
+             ratio: 0.25 },
+           { name: 'second',
+             ratio: 0.50 },
+           { name: 'third',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 40,
+          strategy: :sample
         }
       end
-      context "#new" do
-        it "should not raise any errors" do
-          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+
+      describe '#new' do
+        it 'does not raise any errors' do
+          expect { described_class.new(arguments) }.not_to raise_error
         end
       end
-      context "#fill!" do
-        it "should instantiate with pusher" do
-          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+
+      describe '#fill!' do
+        it 'instantiates with pusher' do
+          expect { described_class.new(arguments).fill! }.not_to raise_error
         end
       end
-      context "results" do
-        before(:each) do
-          @manager = Qfill::Manager.new(@arguments)
-        end
-        context "before fill!" do
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 36
+
+      context 'results' do
+        context 'before fill!' do
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(36)
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 36
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(36)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 0
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(0)
           end
         end
-        context "after fill!" do
-          before(:each) do
-            @manager.fill!
+
+        context 'after fill!' do
+          before do
+            manager.fill!
           end
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 0
+
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(0)
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 0
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(0)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 36
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(36)
           end
         end
       end
     end
-    context "backfill => true" do
-      before :each do
-        @popper = Qfill::Popper.from_array_of_hashes(
+
+    context 'when backfill => true' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
           # We will create 4 queues, high, medium, low, and none.
           # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
           # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
           #   but not at the expense of hte experience, would be:
           # high => medium => none => low
-          [{:name => 'high',
-            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
-            :backfill => 'medium'},
-           {:name => "medium",
-            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
-            :backfill => 'none'},
-           {:name => 'low',
-            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
-            :backfill => true},
-           {:name => 'none',
-            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
-            :backfill => 'low' }] )
-        @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "first",
-             :list_ratios => {
+          [{ name: 'high',
+             elements: %w[h1 h2 h3 h4 h5 h6 h7 h8 h9],
+             backfill: 'medium' },
+           { name: 'medium',
+             elements: %w[m1 m2 m3 m4 m5 m6 m7 m8 m9],
+             backfill: 'none' },
+           { name: 'low',
+             elements: %w[l1 l2 l3 l4 l5 l6 l7 l8 l9],
+             backfill: true },
+           { name: 'none',
+             elements: %w[n1 n2 n3 n4 n5 n6 n7 n8 n9],
+             backfill: 'low' }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'first',
+             list_ratios: {
                'high' => 0.5,
                'medium' => 0.1,
                'none' => 0.4
              },
-             :ratio => 0.25 },
-           { :name => "second",
-             :ratio => 0.50 },
-           { :name => "third",
-             :ratio => 0.25 }] )
-        @arguments = {
-          :pusher => @pusher,
-          :popper => @popper,
-          :all_list_max => 40,
-          :strategy => :sample
+             ratio: 0.25 },
+           { name: 'second',
+             ratio: 0.50 },
+           { name: 'third',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 28,
+          strategy: :sample
         }
       end
-      context "#new" do
-        it "should not raise any errors" do
-          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+
+      describe '#new' do
+        it 'does not raise any errors' do
+          expect { described_class.new(arguments) }.not_to raise_error
         end
       end
-      context "#fill!" do
-        it "should instantiate with pusher" do
-          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+
+      describe '#fill!' do
+        it 'instantiates with pusher' do
+          expect { described_class.new(arguments).fill! }.not_to raise_error
         end
       end
-      context "results" do
-        before(:each) do
-          @manager = Qfill::Manager.new(@arguments)
-        end
-        context "before fill!" do
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 36
+
+      context 'results' do
+        context 'before fill!' do
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(36)
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 27
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(27)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 0
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(0)
           end
         end
-        context "after fill!" do
-          before(:each) do
-            @manager.fill!
+
+        context 'after fill!' do
+          before do
+            manager.fill!
           end
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 8
+
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(8)
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 0
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(0)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 28
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(28)
           end
         end
       end
     end
   end
-  context "strategy :drain_to_limit" do
-    context "backfill => false" do
-      before :each do
-        @popper = Qfill::Popper.from_array_of_hashes(
+
+  context 'when strategy => :drain_to_limit' do
+    context 'when backfill => false' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
           # We will create 4 queues, high, medium, low, and none.
           # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
           # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
           #   but not at the expense of hte experience, would be:
           # high => medium => none => low
-          [{:name => 'high',
-            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
-            :backfill => 'medium'},
-           {:name => "medium",
-            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
-            :backfill => 'none'},
-           {:name => 'low',
-            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
-            :backfill => false},
-           {:name => 'none',
-            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
-            :backfill => 'low' }] )
-        @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "first",
-             :list_ratios => {
+          [{ name: 'high',
+             elements: %w[h1 h2 h3 h4 h5 h6 h7 h8 h9 h10 h11 h12],
+             backfill: 'medium' },
+           { name: 'medium',
+             elements: %w[m1 m2 m3 m4 m5 m6 m7 m8 m9 m10 m11 m12],
+             backfill: 'none' },
+           { name: 'low',
+             elements: %w[l1 l2 l3 l4 l5 l6 l7 l8 l9 l10 l11 l12],
+             backfill: false },
+           { name: 'none',
+             elements: %w[n1 n2 n3 n4 n5 n6 n7 n8 n9 n10 n11 n12],
+             backfill: 'low' }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'first',
+             list_ratios: {
                'high' => 0.5,
                'medium' => 0.1,
                'none' => 0.4
              },
-             :ratio => 0.25 },
-           { :name => "second",
-             :ratio => 0.50 },
-           { :name => "third",
-             :ratio => 0.25 }] )
-        @arguments = {
-          :pusher => @pusher,
-          :popper => @popper,
-          :all_list_max => 40,
-          :strategy => :drain_to_limit
+             ratio: 0.25 },
+           { name: 'second',
+             ratio: 0.50 },
+           { name: 'third',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 40,
+          strategy: :drain_to_limit
         }
       end
-      context "#new" do
-        it "should not raise any errors" do
-          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+
+      describe '#new' do
+        it 'does not raise any errors' do
+          expect { described_class.new(arguments) }.not_to raise_error
         end
       end
-      context "#fill!" do
-        it "should instantiate with pusher" do
-          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+
+      describe '#fill!' do
+        it 'instantiates with pusher' do
+          expect { described_class.new(arguments).fill! }.not_to raise_error
         end
       end
-      context "results" do
-        before(:each) do
-          @manager = Qfill::Manager.new(@arguments)
-        end
-        context "before fill!" do
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 36
+
+      context 'results' do
+        context 'before fill!' do
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(48)
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 36
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(48)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 0
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(0)
           end
         end
-        context "after fill!" do
-          before(:each) do
-            @manager.fill!
+
+        context 'after fill!' do
+          before do
+            manager.fill!
           end
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 0 # With drain_to_limit the results do not exactly match the requested ratios.
+
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(8) # With drain_to_limit the results do not exactly match the requested ratios.
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 0
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(8)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 36
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(40)
           end
         end
       end
     end
-    context "backfill => true" do
-      before :each do
-        @popper = Qfill::Popper.from_array_of_hashes(
+
+    context 'when backfill => true' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
           # We will create 4 queues, high, medium, low, and none.
           # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
           # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
           #   but not at the expense of hte experience, would be:
           # high => medium => none => low
-          [{:name => 'high',
-            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
-            :backfill => 'medium'},
-           {:name => "medium",
-            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
-            :backfill => 'none'},
-           {:name => 'low',
-            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
-            :backfill => true},
-           {:name => 'none',
-            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
-            :backfill => 'low' }] )
-        @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "first",
-             :list_ratios => {
+          [{ name: 'high',
+             elements: %w[h1 h2 h3 h4 h5 h6 h7 h8 h9],
+             backfill: 'medium' },
+           { name: 'medium',
+             elements: %w[m1 m2 m3 m4 m5 m6 m7 m8 m9],
+             backfill: 'none' },
+           { name: 'low',
+             elements: %w[l1 l2 l3 l4 l5 l6 l7 l8 l9],
+             backfill: true },
+           { name: 'none',
+             elements: %w[n1 n2 n3 n4 n5 n6 n7 n8 n9],
+             backfill: 'low' }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'first',
+             list_ratios: {
                'high' => 0.5,
                'medium' => 0.1,
                'none' => 0.4
              },
-             :ratio => 0.25 },
-           { :name => "second",
-             :ratio => 0.50 },
-           { :name => "third",
-             :ratio => 0.25 }] )
-        @arguments = {
-          :pusher => @pusher,
-          :popper => @popper,
-          :all_list_max => 40,
-          :strategy => :drain_to_limit
+             ratio: 0.25 },
+           { name: 'second',
+             ratio: 0.50 },
+           { name: 'third',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 40,
+          strategy: :drain_to_limit
         }
       end
-      context "#new" do
-        it "should not raise any errors" do
-          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+
+      describe '#new' do
+        it 'does not raise any errors' do
+          expect { described_class.new(arguments) }.not_to raise_error
         end
       end
-      context "#fill!" do
-        it "should instantiate with pusher" do
-          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+
+      describe '#fill!' do
+        it 'instantiates with pusher' do
+          expect { described_class.new(arguments).fill! }.not_to raise_error
         end
       end
-      context "results" do
-        before(:each) do
-          @manager = Qfill::Manager.new(@arguments)
-        end
-        context "before fill!" do
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 36
+
+      context 'results' do
+        context 'before fill!' do
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(36)
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 27
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(27)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 0
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(0)
           end
         end
-        context "after fill!" do
-          before(:each) do
-            @manager.fill!
+
+        context 'after fill!' do
+          before do
+            manager.fill!
           end
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 7 # With drain_to_limit the results do not exactly match the requested ratios.
+
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(7) # With drain_to_limit the results do not exactly match the requested ratios.
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 0
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(0)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 29
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(29)
           end
         end
       end
     end
   end
-  context "strategy :drain_to_empty" do
-    context "backfill => false" do
-      before :each do
-        @popper = Qfill::Popper.from_array_of_hashes(
-          # We will create 4 queues, high, medium, low, and none.
+
+  context 'when strategy => :drain_to_empty' do
+    context 'when backfill => false' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
+          # We will create 4 queues, higspec/qfill/manager_spec.rb:386h, medium, low, and none.
           # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
           # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
-          #   but not at the expense of hte experience, would be:
+          #   but not at the expense of the experience, would be:
           # high => medium => none => low
-          [{:name => 'high',
-            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
-            :backfill => 'medium'},
-           {:name => "medium",
-            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
-            :backfill => 'none'},
-           {:name => 'low',
-            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
-            :backfill => false},
-           {:name => 'none',
-            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
-            :backfill => 'low' }] )
-        @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "first",
-             :list_ratios => {
+          [{ name: 'high',
+             elements: %w[h1 h2 h3 h4 h5 h6 h7 h8 h9],
+             backfill: 'medium' },
+           { name: 'medium',
+             elements: %w[m1 m2 m3 m4 m5 m6 m7 m8 m9],
+             backfill: 'none' },
+           { name: 'low',
+             elements: %w[l1 l2 l3 l4 l5 l6 l7 l8 l9],
+             backfill: false },
+           { name: 'none',
+             elements: %w[n1 n2 n3 n4 n5 n6 n7 n8 n9],
+             backfill: 'low' }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'first',
+             list_ratios: {
                'high' => 0.5,
                'medium' => 0.1,
                'none' => 0.4
              },
-             :preferred => ['high', 'none']
-           },
-           { :name => "second",
-             :list_ratios => {
+             preferred: %w[high none] },
+           { name: 'second',
+             list_ratios: {
                'high' => 0.5,
                'medium' => 0.4,
                'none' => 0.1
              },
-             :preferred => ['high', 'medium']
-           },
-           { :name => "third" }] )
-        @arguments = {
-          :pusher => @pusher,
-          :popper => @popper,
-          :all_list_max => 40,
-          :strategy => :drain_to_empty
+             preferred: %w[high medium] },
+           { name: 'third' }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 40,
+          strategy: :drain_to_empty
         }
       end
-      context "#new" do
-        it "should not raise any errors" do
-          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+
+      describe '#new' do
+        it 'does not raise any errors' do
+          expect { described_class.new(arguments) }.not_to raise_error
         end
       end
-      context "#fill!" do
-        it "should instantiate with pusher" do
-          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+
+      describe '#fill!' do
+        it 'instantiates with pusher' do
+          expect { described_class.new(arguments).fill! }.not_to raise_error
         end
       end
-      context "results" do
-        before(:each) do
-          @manager = Qfill::Manager.new(@arguments)
+
+      context 'results' do
+      end
+
+      context 'before fill!' do
+        it 'calculates the correct popper total elements' do
+          expect(manager.popper.count_all_elements).to eq(36)
         end
-        context "before fill!" do
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 36
-          end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 36
-          end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 0
-          end
+
+        it 'calculates the correct popper primary elements' do
+          expect(manager.popper.count_primary_elements).to eq(36)
         end
-        context "after fill!" do
-          before(:each) do
-            @manager.fill!
-          end
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 0 # With drain_to_limit the results do not exactly match the requested ratios.
-          end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 0
-          end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 36
-          end
+
+        it 'calculates the correct pusher total elements' do
+          expect(manager.pusher.count_all_elements).to eq(0)
+        end
+      end
+
+      context 'after fill!' do
+        before do
+          manager.fill!
+        end
+
+        it 'calculates the correct popper total elements' do
+          expect(manager.popper.count_all_elements).to eq(0) # With drain_to_limit the results do not exactly match the requested ratios.
+        end
+
+        it 'calculates the correct popper primary elements' do
+          expect(manager.popper.count_primary_elements).to eq(0)
+        end
+
+        it 'calculates the correct pusher total elements' do
+          expect(manager.pusher.count_all_elements).to eq(36)
         end
       end
     end
-    context "backfill => true" do
-      before :each do
-        @popper = Qfill::Popper.from_array_of_hashes(
+
+    context 'when backfill => true' do
+      let(:popper) do
+        Qfill::Popper.from_array_of_hashes(
           # We will create 4 queues, high, medium, low, and none.
           # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
           # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
-          #   but not at the expense of hte experience, would be:
+          #   but not at the expense of the experience, would be:
           # high => medium => none => low
-          [{:name => 'high',
-            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 h1 h2 h3 h4 h5 h6 h7 h8 h9 h1 h2 h3 h4 h5 h6 h7 h8 h9 h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
-            :backfill => 'medium'},
-           {:name => "medium",
-            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 m1 m2 m3 m4 m5 m6 m7 m8 m9 m1 m2 m3 m4 m5 m6 m7 m8 m9 m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
-            :backfill => 'none'},
-           {:name => 'low',
-            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 l1 l2 l3 l4 l5 l6 l7 l8 l9 l1 l2 l3 l4 l5 l6 l7 l8 l9 l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
-            :backfill => true},
-           {:name => 'none',
-            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 n1 n2 n3 n4 n5 n6 n7 n8 n9 n1 n2 n3 n4 n5 n6 n7 n8 n9 n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
-            :backfill => 'low' }] )
-        @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "first",
-             :list_ratios => {
+          [{ name: 'high',
+             elements: build_elements('h', 20),
+             backfill: 'medium' },
+           { name: 'medium',
+             elements: build_elements('m', 20),
+             backfill: 'none' },
+           { name: 'low',
+             elements: build_elements('l', 20),
+             backfill: true },
+           { name: 'none',
+             elements: build_elements('n', 20),
+             backfill: 'low' }]
+        )
+      end
+      let(:pusher) do
+        Qfill::Pusher.from_array_of_hashes(
+          [{ name: 'first',
+             list_ratios: {
                'high' => 0.5,
                'medium' => 0.1,
                'none' => 0.4
              },
-             :ratio => 1,
-             :preferred => ['high', 'none']
-           },
-           { :name => "second",
-             :ratio => 0.50 },
-           { :name => "third",
-             :ratio => 0.25 }] )
-        @arguments = {
-          :pusher => @pusher,
-          :popper => @popper,
-          :all_list_max => 40,
-          :strategy => :drain_to_limit
+             ratio: 1,
+             preferred: %w[high none] },
+           { name: 'second',
+             ratio: 0.50 },
+           { name: 'third',
+             ratio: 0.25 }]
+        )
+      end
+      let(:arguments) do
+        {
+          pusher: pusher,
+          popper: popper,
+          all_list_max: 100,
+          strategy: :drain_to_empty
         }
       end
-      context "#new" do
-        it "should not raise any errors" do
-          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+
+      describe '#new' do
+        it 'does not raise any errors' do
+          expect { described_class.new(arguments) }.not_to raise_error
         end
       end
-      context "#fill!" do
-        it "should instantiate with pusher" do
-          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+
+      describe '#fill!' do
+        it 'instantiates with pusher' do
+          expect { described_class.new(arguments).fill! }.not_to raise_error
         end
       end
-      context "results" do
-        before(:each) do
-          @manager = Qfill::Manager.new(@arguments)
-        end
-        context "before fill!" do
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 144
+
+      context 'results' do
+        context 'before fill!' do
+          it 'calculates the correct popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(80)
           end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 27
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(60)
           end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 0
+
+          it 'calculates the correct pusher total elements' do
+            expect(manager.pusher.count_all_elements).to eq(0)
           end
         end
-        context "after fill!" do
-          before(:each) do
-            @manager.fill!
-          end
-          it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 104 # With drain_to_empty the results do not exactly match the requested ratios.
-          end
-          it "should calculate the correct popper primary elements" do
-            @manager.popper.count_primary_elements == 0
-          end
-          it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 40
+
+        context 'after fill!' do
+          before do
+            manager.fill!
+          end
+
+          it 'calculates the correct leftover popper total elements' do
+            expect(manager.popper.count_all_elements).to eq(20) # TODO???: With drain_to_empty the results do not exactly match the requested ratios.
+          end
+
+          it 'calculates the correct popper primary elements' do
+            expect(manager.popper.count_primary_elements).to eq(0)
+          end
+
+          context 'when all_list_max is higher than count of all elements' do
+            it 'reduces all_list_max to original count of all elements' do
+              expect(manager.all_list_max).to eq(80)
+            end
+
+            it 'is greater than count of all elements in the results (pusher)' do
+              expect(manager.all_list_max > manager.pusher.count_all_elements).to eq(true)
+            end
+          end
+
+          context 'when all_list_max is lower than count of all elements' do
+            let(:arguments) do
+              {
+                pusher: pusher,
+                popper: popper,
+                all_list_max: 4,
+                strategy: :drain_to_empty
+              }
+            end
+
+            it 'retains specified all_list_max' do
+              expect(manager.all_list_max).to eq(4)
+            end
+
+            it 'is equal to count of all elements in the results (pusher)' do
+              expect(manager.pusher.count_all_elements).to eq(manager.all_list_max)
+            end
           end
         end
       end
     end
   end
+
+  context 'when strategy => :time_slice' do
+    let(:popper) do
+      Qfill::Popper.from_array_of_hashes(
+        [
+          {
+            name: 'data',
+            elements: build_elements('ef', 2400)
+          }
+        ]
+      )
+    end
+    let(:arguments) do
+      {
+        popper: popper,
+        strategy: :time_slice,
+        strategy_options: {
+          window_size: 20,
+          window_units: 'minutes',
+          pane_size: 2,
+          pane_units: 'seconds'
+        }
+      }
+    end
+
+    describe '#new' do
+      it 'does not raise any errors' do
+        expect { described_class.new(arguments) }.not_to raise_error
+      end
+    end
+
+    describe '#fill!' do
+      it 'instantiates with pusher' do
+        expect { described_class.new(arguments).fill! }.not_to raise_error
+      end
+    end
+
+    context 'results' do
+      context 'before fill!' do
+        it 'calculates the correct popper total elements' do
+          expect(manager.popper.count_all_elements).to eq(2400)
+        end
+
+        it 'calculates the correct popper primary elements' do
+          expect(manager.popper.count_primary_elements).to eq(2400)
+        end
+
+        it 'calculates the correct pusher total elements' do
+          expect(manager.pusher.count_all_elements).to eq(0)
+        end
+
+        it 'has pusher queues that are "full" (because max starts at 0)' do
+          expect(manager.pusher.queues.count(&:is_full?)).to eq(600)
+        end
+
+        it 'has pusher queues that are not really full' do
+          expect(manager.pusher.queues.count { |x| x.elements.empty? }).to eq(600)
+        end
+      end
+
+      context 'after fill!' do
+        before do
+          manager.fill!
+        end
+
+        it 'calculates the correct popper total elements' do
+          expect(manager.popper.count_all_elements).to eq(0)
+        end
+
+        it 'calculates the correct popper primary elements' do
+          expect(manager.popper.count_primary_elements).to eq(0)
+        end
+
+        it 'calculates the correct pusher total elements' do
+          expect(manager.pusher.count_all_elements).to eq(2400)
+        end
+
+        it 'has correct number of pusher queues' do
+          expect(manager.pusher.queues.length).to eq(600)
+        end
+
+        it 'has pusher queues that are full' do
+          expect(manager.pusher.queues.count(&:is_full?)).to eq(600)
+        end
+
+        it 'has pusher queues that are not too full' do
+          elements_per_queue = 2400 / 600
+          expect(manager.pusher.queues.count { |x| x.elements.length == elements_per_queue }).to eq(600)
+        end
+      end
+    end
+  end
 end