qfill 0.0.1

data/lib/qfill/pusher.rb

@@ -0,0 +1,85 @@
+#pusher = Qfill::Pusher.new(
+#  Qfill::Result.new( :name => "Best Results",
+#                        :filter => filter3,
+#                        :ratio => 0.5,
+#                        :list_ratios => {
+#                          "High List" => 0.4,
+#                          "Medium List" => 0.2,
+#                          "Low List" => 0.4
+#                        }
+#  ),
+#  Qfill::Result.new( :name => "More Results",
+#                        :ratio => 0.5,
+#                        :list_ratios => {
+#                          "High List" => 0.2,
+#                          "Medium List" => 0.4,
+#                          "Low List" => 0.4
+#                        }
+#  )
+#)
+#
+#pusher = Qfill::Pusher.from_array_of_hashes([
+#  { :name => "First Result",
+#    :ratio => 0.125,
+#    :filter => filter3,
+#    :list_ratios => {
+#      "High List" => 0.4,
+#      "Medium List" => 0.2,
+#      "Low List" => 0.4
+#    }
+#  },
+#  { :name => "Second Result",
+#    :ratio => 0.25 },
+#  { :name => "Third Result",
+#    :ratio => 0.125 },
+#  { :name => "Fourth Result",
+#    :ratio => 0.50 },
+#])
+#
+# Pusher is made up of an array (called queues) of Result objects.
+module Qfill
+  class Pusher < Qfill::ListSet
+
+    def initialize(*args)
+      super(*args)
+      with_ratio = self.queues.map {|x| x.ratio}.compact
+      ratio_to_split = (1 - with_ratio.inject(0, :+))
+      if ratio_to_split < 0
+        raise ArgumentError, "#{self.class}: mismatched ratios for queues #{with_ratio.join(' + ')} must not total more than 1"
+      end
+      num_without_ratio = self.queues.length - with_ratio.length
+      if num_without_ratio > 0 && ratio_to_split < 1
+        equal_portion = ratio_to_split / num_without_ratio
+        self.queues.each do |queue|
+          if queue.ratio.nil?
+            queue.tap do |q|
+              q.ratio = equal_portion
+            end
+          end
+        end
+      end
+    end
+
+    def current_list
+      self.queues[self.current_index]
+    end
+
+    def set_next_as_current!
+      next_index = self.current_index + 1
+      if (next_index) == self.queues.length
+        # If we have iterated through all the queues, then we reset
+        self.reset!
+      else
+        self.current_index = next_index
+      end
+    end
+
+    def self.from_array_of_hashes(array_of_hashes = [])
+      args = array_of_hashes.map do |hash|
+        Qfill::Result.new(hash)
+      end
+      Qfill::Pusher.new(*args)
+    end
+
+  end
+end

data/lib/qfill/result.rb

@@ -0,0 +1,116 @@
+# Qfill::Result.new(:name => "Best Results",
+#                      :filter => filter3,
+#                      :ratio => 0.5,
+#                      :list_ratios => {
+#                        "High List" => 0.4,
+#                        "Medium List" => 0.2,
+#                        "Low List" => 0.4 } )
+module Qfill
+  class Result < Qfill::List
+    attr_accessor :ratio, :list_ratios, :fill_tracker, :fill_count, :validate, :filter, :current_list_ratio_index, :max
+
+    def self.get_limit_from_max_and_ratio(all_list_max, ratio)
+      limit = (all_list_max * ratio).round(0)
+      # If we rounded down to zero we have to keep at least one.
+      # This is because with small origin sets all ratios might round down to 0.
+      if limit == 0
+        limit += 1
+      end
+      limit
+    end
+
+    def initialize(options = {})
+      super(options)
+      @list_ratios = options[:list_ratios] || {}
+      with_ratio = self.list_ratio_as_array.map {|tuple| tuple[1]}.compact
+      ratio_leftover = (1 - with_ratio.inject(0, :+))
+      if ratio_leftover < 0
+        raise ArgumentError, "#{self.class}: invalid list_ratios for queue '#{self.name}'. List Ratios (#{with_ratio.join(' + ')}) must not total more than 1"
+      end
+      @ratio = options[:ratio]
+      @max = 0
+      @fill_tracker = {}
+      @fill_count = 0
+      @current_list_ratio_index = 0 # Used by :sample strategy
+      @validate = self.use_validation?
+    end
+
+    def list_ratio_full?(list_name, max_from_list)
+      self.fill_tracker[list_name] >= max_from_list
+    end
+
+    def push(objects, list_name)
+      self.validate!(list_name)
+      added = 0
+      objects.each do |object|
+        if self.allow?(object, list_name)
+          self.bump_fill_tracker!(list_name)
+          self.add!(object)
+          added += 1
+          #self.print(list_name)
+        end
+      end
+      return added
+    end
+
+    def print(list_name)
+      puts "Added to #{list_name}.\nResult List #{self.name} now has #{self.elements.length} total objects.\nSources:\n #{self.fill_tracker.inspect} "
+    end
+
+    def add!(object)
+      self.elements << object
+    end
+
+    def allow?(object, list_name)
+      !self.filter.respond_to?(:call) ||
+        # If there is a filter, then it must return true to proceed
+        self.filter.run(object, list_name)
+    end
+
+    def bump_fill_tracker!(list_name)
+      self.fill_tracker[list_name] ||= 0
+      self.fill_tracker[list_name] += 1
+      self.fill_count += 1
+    end
+
+    # Does the queue being pushed into match one of the list_ratios
+    def valid?(list_name)
+      self.list_ratios.has_key?(list_name)
+    end
+
+    def validate!(list_name)
+      raise ArgumentError, "#{self.class}: #{list_name} is an invalid list_name.  Valid list_names are: #{self.list_ratios.keys}" if self.validate && !self.valid?(list_name)
+    end
+
+    def use_validation?
+      !self.list_ratios.empty?
+    end
+
+    def list_ratio_as_array
+      # [["high",0.4],["medium",0.4],["low",0.2]]
+      @list_ratio_as_array ||= self.list_ratios.to_a
+    end
+
+    def current_list_ratio
+      self.list_ratio_as_array[self.current_list_ratio_index]
+    end
+
+    def set_next_as_current!
+      next_index = self.current_list_ratio_index + 1
+      if (next_index) == self.list_ratio_as_array.length
+        # If we have iterated through all the list_ratios, then we reset
+        self.reset!
+      else
+        self.current_list_ratio_index = next_index
+      end
+    end
+
+    def reset!
+      self.current_list_ratio_index = 0
+    end
+
+    def is_full?
+      self.elements.length >= self.max
+    end
+  end
+end

data/lib/qfill/version.rb

@@ -0,0 +1,3 @@
+module Qfill
+  VERSION = "0.0.1"
+end

data/qfill.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qfill/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "qfill"
+  gem.version       = Qfill::VERSION
+  gem.authors       = ["Peter Boling"]
+  gem.email         = ["peter.boling@gmail.com"]
+  gem.description   = %q{Advanced Queue Transformation}
+  gem.summary       = %q{You have a set of arrays that need to be turned into a different set of arrays
+according to a potentially non-uniform set of rules.
+
+Now you can easily turn this:
+
+source_a # => [1,2,3,4]
+source_b # => [5,6,7,8,9]
+
+into this:
+
+result_a # => [1,2]
+result_b # => [3,5,7,9]
+result_c # => [4,6,8]
+
+by specifying filters for handling each transformation.
+}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rspec'
+end

data/spec/qfill/filter_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+describe Qfill::Filter do
+  context "#new" do
+    context "with processor" do
+      before :each do
+        @lambda = -> (object) { !object.nil? }
+      end
+      it "should instantiate with processor" do
+        Qfill::Filter.new(@lambda).should be_a(Qfill::Filter)
+      end
+    end
+
+    context "with processor and arguments" do
+      before :each do
+        @lambda = -> (object, first, second) { !object.nil? && first == first && second == 'second' }
+        @arguments = ['first','second']
+      end
+      it "should instantiate with processor" do
+        Qfill::Filter.new(@lambda, *@arguments).should be_a(Qfill::Filter)
+      end
+    end
+  end
+
+  context "#run" do
+    before :each do
+      @lambda = -> (object, first, second) { !object.nil? && first == first && second == 'second' }
+      @arguments = ['first','second']
+      @filter = Qfill::Filter.new(@lambda, *@arguments)
+    end
+    it "should return the correct result" do
+      @filter.run('not nil').should == true
+    end
+    context "with extra arguments" do
+      before :each do
+        @lambda = -> (object, special_arg1, special_arg2, first, second, third) { !object.nil? && first == first && second == 'second' && special_arg1 = 'this' && special_arg2 == 'thing' && third == 'third' }
+        @arguments = ['first','second','third']
+        @filter = Qfill::Filter.new(@lambda, *@arguments)
+      end
+      it "should properly use arity" do
+        @filter.run('not nil', 'this', 'thing').should == true
+      end
+    end
+  end
+end

data/spec/qfill/list_set_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+describe Qfill::ListSet do
+  context "#new" do
+    context "with no arguments" do
+      it "should raise ArgumentError" do
+        expect { Qfill::ListSet.new() }.to raise_error(ArgumentError)
+      end
+    end
+    context "with arguments" do
+      before :each do
+        @filter = Qfill::Filter.new( -> (object) { object.is_a?(Numeric)} )
+        @origin_queues = [
+          Qfill::List.new(
+            :name => "High List",
+            :elements => [1, 2, 3, 'c'],
+            :filter => @filter),
+          Qfill::List.new( :name => "Medium List",
+                               :elements => ['e', 'f', 4, 5],
+                               :filter => @filter),
+          Qfill::List.new( :name => "Low List",
+                               :elements => [7, 8, 'd'],
+                               :filter => @filter)
+        ]
+      end
+      it "should not raise any errors" do
+        expect { Qfill::ListSet.new(*@origin_queues) }.to_not raise_error
+      end
+      it "should instantiate with name" do
+        popper = Qfill::ListSet.new(*@origin_queues)
+        popper.queues.first.elements.should == [1,2,3,'c']
+        popper.queues.last.elements.should == [7,8,'d']
+      end
+    end
+  end
+
+end

data/spec/qfill/list_spec.rb

@@ -0,0 +1,44 @@
+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)
+      end
+    end
+    context "with name" do
+      before :each do
+        @arguments = { :name => "High List" }
+      end
+      it "should not raise any errors" do
+        expect { Qfill::List.new(@arguments) }.to_not raise_error
+      end
+      it "should instantiate with name" do
+        Qfill::List.new(@arguments).name.should == 'High List'
+      end
+    end
+    context "with elements" do
+      before :each do
+        @arguments = {  :name => "High List",
+                        :elements => [1,2] }
+      end
+      it "should instantiate with elements" do
+        Qfill::List.new(@arguments).elements.should == [1,2]
+      end
+    end
+    context "with filter" do
+      before :each do
+        lambda = -> (object) { !object.nil? }
+        @filter = Qfill::Filter.new(lambda)
+        @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
+      end
+    end
+  end
+
+end

data/spec/qfill/manager_spec.rb

@@ -0,0 +1,418 @@
+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(
+          # 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 => {
+               '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
+        }
+      end
+      context "#new" do
+        it "should not raise any errors" do
+          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+        end
+      end
+      context "#fill!" do
+        it "should instantiate with pusher" do
+          expect { Qfill::Manager.new(@arguments).fill!  }.to_not 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
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 36
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 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 == 0
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 0
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 36
+          end
+        end
+      end
+    end
+    context "backfill => true" do
+      before :each do
+        @popper = 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 => {
+               '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
+        }
+      end
+      context "#new" do
+        it "should not raise any errors" do
+          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+        end
+      end
+      context "#fill!" do
+        it "should instantiate with pusher" do
+          expect { Qfill::Manager.new(@arguments).fill!  }.to_not 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
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 27
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 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 == 9
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 0
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 27
+          end
+        end
+      end
+    end
+  end
+  context "strategy :drain" 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.
+          # 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 => {
+               '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
+        }
+      end
+      context "#new" do
+        it "should not raise any errors" do
+          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+        end
+      end
+      context "#fill!" do
+        it "should instantiate with pusher" do
+          expect { Qfill::Manager.new(@arguments).fill!  }.to_not 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
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 36
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 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 == 0 # With drain the results do not exactly match the requested ratios.
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 0
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 36
+          end
+        end
+      end
+    end
+    context "backfill => true" do
+      before :each do
+        @popper = 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 => {
+               '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
+        }
+      end
+      context "#new" do
+        it "should not raise any errors" do
+          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+        end
+      end
+      context "#fill!" do
+        it "should instantiate with pusher" do
+          expect { Qfill::Manager.new(@arguments).fill!  }.to_not 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
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 27
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 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 == 7 # With drain the results do not exactly match the requested ratios.
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.get_primary_elements == 0
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 29
+          end
+        end
+      end
+    end
+  end
+end