answer-factory 0.0.9 → 0.0.10

data/spec/factories/workstation_spec.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), "./../spec_helper")
 
+
 describe "Workstation" do
   
   describe "names" do
@@ -37,7 +38,6 @@ describe "Workstation" do
   end
   
   
-  
   describe "capacity" do
     it "should accept a #capacity attribute in initialization" do
       w1 = Workstation.new(:ws, capacity:12)
@@ -62,8 +62,8 @@ describe "Workstation" do
   
   
   describe "answers" do
-    it "should be an Array that's empty initially" do
-      Workstation.new(:place).answers.should == []
+    it "should be a Batch that's empty initially" do
+      Workstation.new(:place).answers.should be_a_kind_of(Batch)
     end
   end
   
@@ -92,7 +92,6 @@ describe "Workstation" do
   
   
   
-  
   describe "#cycle" do
     it "should invoke #receive!, #build!, #ship! and #scrap!" do
       w1 = Workstation.new(:place)
@@ -103,37 +102,212 @@ describe "Workstation" do
       w1.cycle
     end
     
+    describe "the #before method" do
+      it "should empty @answers"
+    end
+    
+    describe "the #after method" do
+      it "should save everything in @answers to the persistent store"
+    end
     
     describe "#receive!" do
-      it "should access its persistent store"
-      it "should gather its 'current' work_in_process into self#answers"
-      it "should gather its 'current' collaborators' work_in_process into self#collaborator_answers"
+      # the superclass we're testing (Workstation) should do nothing here,
+      # but there are some helper methods defined for use in subclasses;
+      # we should test those
+      
+      describe "gather_mine" do
+        before(:each) do
+          @w1 = Workstation.new(:ws1, factory_name:"this_factory")
+          @uri = "http://127.0.0.1:5984/this_factory"
+          @design_doc = "ws1/current"  # we'll assume this has been set up!
+          @view_uri = "http://127.0.0.1:5984/this_factory/_design/ws1/_view/current"
+          FakeWeb.allow_net_connect = false
+          @canned = '{"total_rows":1,"offset":0,"rows":[{"id":"0f60c293ad736abfdb083d33f71ef9ab","key":"ws1","value":{"_id":"0f60c293ad736abfdb083d33f71ef9ab","_rev":"1-473467b6dc1a4cba3498dd6eeb8e3206","blueprint":"do bar","tags":[],"scores":{"badness": 12.345},"progress":12,"timestamp":"2010/04/14 17:09:14 +0000"}}]}'
+        end
+        
+        it "should use the Batch#load_from_couch method" do
+          FakeWeb.register_uri(:any, @view_uri, :body => @canned, :status => [200, "OK"])
+          Batch.should_receive(:load_from_couch).with(@uri,@design_doc).and_return(Batch.new)
+          @w1.gather_mine
+        end
+        
+        it "should add that Batch into self#answers" do
+          FakeWeb.register_uri(:any, @view_uri, :body => @canned, :status => [200, "OK"])
+          @w1.answers.length.should == 0
+          @w1.gather_mine
+          @w1.answers.length.should == 1
+          @w1.answers[0].scores[:badness].should == 12.345
+        end
+      end
+      
+      
+      describe "gather_into" do
+      end
     end
     
     
     describe "#build!" do
+      # the superclass we're testing (Workstation) should do nothing here,
+      # but there are some helper methods defined for use in subclasses;
+      # we should test those
       
+      describe "process_with" do
+        before(:each) do
+          @w1 = Workstation.new(:pity_foo)
+          @w1.answers = Batch[Answer.new("block{}")]
+          @sampler = AnyOneSampler.new
+        end
+        
+        it "should accept one parameter" do
+          @w1.method(:process_with).arity.should == 1
+        end
+        
+        it "should only accept a search operator" do
+          lambda{@w1.process_with(8)}.should raise_error(ArgumentError)
+          lambda{@w1.process_with(AnyOneSampler.new)}.should_not raise_error
+        end
+        
+        it "should call the search operator's '#generate" do
+          @sampler.should_receive(:generate)
+          @w1.process_with(@sampler)
+        end
+        
+        it "should pass in self#answers to the call to #generate" do
+          @sampler.should_receive(:generate).with(@w1.answers)
+          @w1.process_with(@sampler)
+        end
+        
+        it "should return a Batch" do
+          @w1.process_with(@sampler).should be_a_kind_of(Batch)
+        end
+      end
     end
     
     
     describe "#ship!" do
-      it "should be an Array of stored procedures"
-      it "should always include (as a last entry) a Proc that returns 'false'"
-      it "should call all the Procs in order, for every member of its population"
-      it "should select a random downstream destination if none is specified by the rule"
-      it "should fail silently if there are no downstream stations"
-      it "should call every rule, in turn, sending every Answer off before moving on"
+      # the superclass we're testing (Workstation) should do nothing here,
+      # but there are some helper methods defined for use in subclasses;
+      # we should test those
+      
+      describe "ship_to" do
+        before(:each) do
+          @w2 = Workstation.new(:lulu)
+          @a1 = Answer.new("do fun_stuff", tags:[:lulu])
+          @a2 = Answer.new("do sad_stuff", tags:[:lulu])
+          @w2.answers = Batch[@a1,@a2]
+        end
+        
+        it "should accept a single argument" do
+          @w2.method(:ship_to).arity.should == 1
+        end
+        
+        it "should check the argument is a symbol" do
+          lambda{@w2.ship_to(8)}.should raise_error(ArgumentError)
+          lambda{@w2.ship_to(:heaven)}.should_not raise_error
+        end
+        
+        it "should pass every element of @answers into the associated block" do
+          Math.should_receive(:sin).exactly(2).times
+          @w2.ship_to(:heaven) {|a| Math.sin(12.0)}
+        end
+        
+        it "should add a new location tag to the answers in the filtered subset" do
+          @a1.should_receive(:add_tag).with(:xyzzy)
+          @a2.should_receive(:add_tag).with(:xyzzy)
+          @w2.ship_to(:xyzzy) {|a| true}
+        end
+        
+        it "should remove the old location tag to the answers in the filtered subset" do
+          @a1.should_receive(:remove_tag).with(:lulu)
+          @a2.should_receive(:remove_tag).with(:lulu)
+          @w2.ship_to(:xyzzy) {|a| true}
+        end
+        
+        it "should not touch the tags of answers not in the filtered subset" do
+          @a1.should_receive(:remove_tag).with(:lulu)
+          @a2.should_not_receive(:remove_tag)
+          @w2.ship_to(:xyzzy) {|a| a.blueprint.include? "fun"}
+        end
+      end
     end
     
     
     describe "scrap!" do
-      it "should be an Array of stored procedures"
-      it "should return 'true' to indicate that a particular Answer should be scrapped"
-      it "should use an Array of stored procedures"
-      it "should return a single boolean to indicate that scrapping should continue"
-      it "should always include (as a last entry) a Proc that checks whether population > capacity"
-      it "should set the workstation of scrapped Answers to Scrapyard"
-      it "should call rules in order, scrapping all indicated Answers, until scrap_trigger? is false"
+      
+      # the superclass we're testing (Workstation) should do nothing here,
+      # but there are some helper methods defined for use in subclasses;
+      # we should test those
+      
+      describe "scrap_if" do
+        before(:each) do
+          @w3 = Workstation.new(:falafel)
+          @a1 = Answer.new("do fun_stuff", progress:1, tags:[:falafel])
+          @a2 = Answer.new("do sad_stuff", progress:99, tags:[:falafel])
+          @w3.answers = Batch[@a1,@a2]
+        end
+        
+        it "should accept a single argument" do
+          @w3.method(:scrap_if).arity.should == 1
+        end
+        
+        it "should pass every element of @answers into a block" do
+          Math.should_receive(:cos).exactly(2).times
+          @w3.scrap_if("Math says so") {|a| Math.cos(12.0)}
+        end
+        
+        it "should add a new location tag :SCRAP to the answers in the filtered subset" do
+          @a1.should_receive(:add_tag).with(:SCRAP)
+          @a2.should_receive(:add_tag).with(:SCRAP)
+          @w3.scrap_if("everything dies") {|a| true}
+        end
+        
+        it "should remove the old location tag to the answers in the filtered subset" do
+          @a1.should_receive(:remove_tag).with(:falafel)
+          @a2.should_receive(:remove_tag).with(:falafel)
+          @w3.scrap_if("entropy") {|a| true}
+        end
+        
+        it "should not touch the tags of answers not in the filtered subset" do
+          @a1.should_receive(:remove_tag).with(:falafel)
+          @a2.should_not_receive(:remove_tag)
+          @w3.scrap_if("insufficient progress") {|a| a.progress < 10}
+        end
+      end
+      
+      describe "scrap_everything" do
+        before(:each) do
+          @w4 = Workstation.new(:ice_station_zebra)
+          @a1 = Answer.new("do anything", tags:[:ice_station_zebra])
+          @a2 = Answer.new("do whatevz", tags:[:ice_station_zebra])
+          @w4.answers = Batch[@a1,@a2]
+        end
+        
+        it "should have arity 0" do
+          @w4.method(:scrap_everything).arity.should == 0
+        end
+        
+        it "should call scrap_if" do
+          @w4.should_receive(:scrap_if)
+          @w4.scrap_everything
+        end
+        
+        it "should send every answer to :SCRAP" do
+          @w4.answers.each {|a| a.tags.should_not include(:SCRAP)}
+          @w4.scrap_everything
+          @w4.answers.each {|a| a.tags.should include(:SCRAP)}
+        end
+        
+        it "should remove the current location from every answer" do
+          @w4.answers.each {|a| a.tags.should include(:ice_station_zebra)}
+          @w4.scrap_everything
+          @w4.answers.each {|a| a.tags.should_not include(:ice_station_zebra)}
+        end
+        
+        it "should be safe to repeat the statement" do
+          @w4.scrap_everything
+          lambda{@w4.scrap_everything}.should_not raise_error
+        end
+      end
     end
   end
 end

data/spec/operators/evaluators/program_point_evaluator_spec.rb

@@ -11,7 +11,7 @@ describe ProgramPointEvaluator do
   
   describe "#evaluate" do
     before(:each) do
-      @ppe = ProgramPointEvaluator.new(:name => :point_count)
+      @ppe = ProgramPointEvaluator.new(:score_label => :point_count)
       @dudes = Batch[
         Answer.new("block {}"),
         Answer.new("block { block {}}"),

data/spec/operators/evaluators/test_case_evaluator_spec.rb

@@ -39,7 +39,7 @@ describe TestCaseEvaluator do
   describe "initialize" do
     it "should have a name" do
       lambda{TestCaseEvaluator.new()}.should raise_error(ArgumentError)
-      lambda{TestCaseEvaluator.new(name:"boolean_multiplexer_SSE")}.should_not raise_error
+      lambda{TestCaseEvaluator.new(score_label:"boolean_multiplexer_SSE")}.should_not raise_error
     end
     
     it "should have all the info it needs to set up an Interpreter"
@@ -47,7 +47,7 @@ describe TestCaseEvaluator do
   
   describe "evaluate" do
     before(:each) do
-      @tce = TestCaseEvaluator.new(:name => :error)
+      @tce = TestCaseEvaluator.new(:score_label => :error)
       @dudes = Batch[
         Answer.new("value «int»\n«int» 12"),
         Answer.new("value «int»\n«int» -9912"),

data/spec/operators/nondominated_subset_spec.rb

@@ -6,7 +6,7 @@ describe "nondominated_subset operator" do
     @myNondominatedScreener = NondominatedSubsetSelector.new
     @params = {points:3, instruction_names:[:int_add, :int_multiply], type_names:["int"]}
     @myGuesser = RandomGuessOperator.new(@params)
-    @twoGuys = @myGuesser.generate(2)
+    @twoGuys = @myGuesser.generate(Batch.new,how_many:2)
   end
   
   it "should be a kind of SearchOperator" do
@@ -20,7 +20,7 @@ describe "nondominated_subset operator" do
   end
   
   it "the #all_shared_scores method should return an Array of the keys of the #scores hashes in the crowd" do
-    twoGuys = @myGuesser.generate(2)
+    twoGuys = @myGuesser.generate(Batch.new,how_many:2)
     twoGuys[0].scores = {x2:612, x1:77, x3:712}
     twoGuys[1].scores = {x2:2,   x1:3,  x3:4}
     @myNondominatedScreener.all_shared_scores(twoGuys).sort.should == [:x1,:x2, :x3].sort
@@ -31,7 +31,7 @@ describe "nondominated_subset operator" do
   end
   
   it "should produce a Batch of Answer objects when it receives #generate; at least one" do
-    twoGuys = @myGuesser.generate(2)
+    twoGuys = @myGuesser.generate(Batch.new,how_many:2)
     twoGuys[0].scores = {:x2 => 612, :x1 => 77, :x3 => 712}
     twoGuys[1].scores = {:x2 => 2, :x1 => 3, :x3 => 4}
     @myNondominatedScreener.generate(twoGuys).should be_a_kind_of(Batch)
@@ -39,7 +39,7 @@ describe "nondominated_subset operator" do
   end
   
   it "should work, passing along references not clones to the original guys" do
-    twoGuys = @myGuesser.generate(2)
+    twoGuys = @myGuesser.generate(Batch.new,how_many:2)
     twoGuys[0].scores = {x2:612, x1:77, x3:712}
     twoGuys[1].scores = {x2:2,   x1:3,  x3:4}
     @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
@@ -54,7 +54,7 @@ describe "nondominated_subset operator" do
   end
   
   it "should work the same no matter what the scores hash order" do
-    twoGuys = @myGuesser.generate(2)
+    twoGuys = @myGuesser.generate(Batch.new,how_many:2)
     twoGuys[0].scores = {:x1 => 77, :x3 => 712,:x2 => 612}
     twoGuys[1].scores = {:x2 => 2, :x1 => 3, :x3 => 4}
     @myNondominatedScreener.generate(twoGuys).should include(twoGuys[1])
@@ -62,7 +62,7 @@ describe "nondominated_subset operator" do
   end
   
   it "can use the 'template' parameter to compare individuals by a specified vector of scores" do
-    threeGuys = @myGuesser.generate(3)
+    threeGuys = @myGuesser.generate(Batch.new,how_many:3)
     threeGuys[0].scores = {:x1 => 1, :x2 => 2, :x3 => 3}
     threeGuys[1].scores = {:x1 => 2, :x2 => 1, :x3 => 1}
     threeGuys[2].scores = {:x1 => 4, :x2 => 0, :x3 => 2}
@@ -83,7 +83,7 @@ describe "nondominated_subset operator" do
   
   
   it "should use a default 'template' parameter that's the intersection of scores keys in the crowd" do
-    twoGuys = @myGuesser.generate(2)
+    twoGuys = @myGuesser.generate(Batch.new,how_many:2)
     twoGuys[0].scores = {x1:1, x2:2, x3:3}
     twoGuys[1].scores = {      x2:0,      x4:12}
     
@@ -93,7 +93,7 @@ describe "nondominated_subset operator" do
   end
   
   it "should return Answers that belonged to crowd passed in" do
-    twoGuys = @myGuesser.generate(2)
+    twoGuys = @myGuesser.generate(Batch.new,how_many:2)
     orig_IDs = twoGuys.collect {|dude| dude.object_id}
     twoGuys[0].scores = {:x1 => 1, :x2 => 2, :x3 => 3}
     twoGuys[1].scores = {          :x2 => 1,           :x4 => 3}

data/spec/operators/random_guess_spec.rb

@@ -18,9 +18,8 @@ describe "random_guess operator" do
     thisGuesser.incoming_options[:foo].should == 99
   end
   
-  
   it "should produce a Batch of Answers when it receives #generate" do
-    newDudes = @myGuesser.generate
+    newDudes = @myGuesser.generate(Batch.new)
     newDudes.should be_a_kind_of(Batch)
     newDudes[0].should be_a_kind_of(Answer)
     newDudes[0].blueprint.should_not == nil
@@ -28,12 +27,12 @@ describe "random_guess operator" do
   end
   
   it "should produce one as a default, more if a higher number is passed in" do
-    @myGuesser.generate.length.should == 1
-    @myGuesser.generate(4).length.should == 4
+    @myGuesser.generate(Batch.new).length.should == 1
+    @myGuesser.generate(Batch.new,how_many:4).length.should == 4
   end
   
   it "should have a parsed blueprint as its #program attribute" do
-    newDudes = @myGuesser.generate
+    newDudes = @myGuesser.generate(Batch.new)
     newDudes[0].program.should be_a_kind_of(NudgeProgram)
   end
   
@@ -44,31 +43,37 @@ describe "random_guess operator" do
       reference_names: ["x1", "x2", "x3"])
       
     lambda{@myNewGuesser.generate(
-      3,
+      Batch.new,
+      how_many:3,
       target_size_in_points: 12,
       reference_names: ["y1"])}.should_not raise_error
       
     @myNewGuesser.generate(
-      3,
+      Batch.new,
+      how_many:3,
       target_size_in_points: 12)[0].program.points.should_not == 7
       
     @myNewGuesser.generate(
-      3,
+      Batch.new,
+      how_many:3,
       target_size_in_points: 12)[0].program.points.should == 12
       
     @myNewGuesser.generate(
-      1,
+      Batch.new,
+      how_many:1,
       target_size_in_points: 16,
       probabilities:{b:0,r:1,v:0,i:0},
       reference_names: ["y1"])[0].blueprint.should include("y1")
   end
   
   it "should produce a Batch that contains Answers with progress=0 only" do
-    @myGuesser.generate(12).each {|dude| dude.progress.should == 0}
+    @myGuesser.generate(Batch.new,how_many:12).each {|dude| dude.progress.should == 0}
   end
   
   it "should handle generated footnotes correctly" do
-    @myGuesser.generate(1,
+    @myGuesser.generate(
+      Batch.new,
+      how_many:1,
       target_size_in_points: 52,
       type_names:["int"],
       probabilities: {b:0,v:1,i:0,r:0})[0].program.footnote_section.scan(/«int»/).length.should == 51

data/spec/operators/resample_and_clone_spec.rb

@@ -12,7 +12,7 @@ describe "resample_and_clone operator" do
   end
 
   it "should produce a list of Answers when it receives #generate" do
-    newDudes = @mySampler.generate(@myGuesser.generate(3))
+    newDudes = @mySampler.generate(@myGuesser.generate(Batch.new,how_many:3))
     newDudes.should be_a_kind_of(Batch)
     newDudes[0].should be_a_kind_of(Answer)
     newDudes[0].blueprint.should_not == nil
@@ -20,35 +20,35 @@ describe "resample_and_clone operator" do
   end
   
   it "should produce one Answer with a blueprint identical to one of the passed in crowd's" do
-    pop = @myGuesser.generate(1)
+    pop = @myGuesser.generate(Batch.new,how_many:1)
     newDudes = @mySampler.generate(pop)
     newDudes[0].blueprint.should == pop[0].blueprint
   end
   
   it "should return more than one individual when asked to, resampling as needed" do
-    newDudes = @mySampler.generate(@myGuesser.generate(10))
+    newDudes = @mySampler.generate(@myGuesser.generate(Batch.new,how_many:10))
     newDudes.length.should == 1
-    newDudes = @mySampler.generate(@myGuesser.generate(3),2)
+    newDudes = @mySampler.generate(@myGuesser.generate(Batch.new,how_many:3),2)
     newDudes.length.should == 2
-    newDudes = @mySampler.generate(@myGuesser.generate(1),2)
+    newDudes = @mySampler.generate(@myGuesser.generate(Batch.new,how_many:1),2)
     newDudes.length.should == 2
     newDudes[0].blueprint.should == newDudes[1].blueprint
   end
   
   it "should not return links to the original program copies in the new clones" do
-    pop = @myGuesser.generate(3)
+    pop = @myGuesser.generate(Batch.new,how_many:3)
     newDudes = @mySampler.generate(pop)
     pop.collect {|old_dude| old_dude.program.object_id}.should_not include(newDudes[0].program.object_id)
   end
   
   it "should have a parsed blueprint as its #program attribute" do
-    pop = @myGuesser.generate(3)
+    pop = @myGuesser.generate(Batch.new,how_many:3)
     newDudes = @mySampler.generate(pop)
     newDudes[0].program.should be_a_kind_of(NudgeProgram)
   end
   
   it "should increment the #progress of each clone" do
-    pop = @myGuesser.generate(3)
+    pop = @myGuesser.generate(Batch.new,how_many:3)
     pop.each {|donor| donor.stub(:progress).and_return(12)}
     newDudes = @mySampler.generate(pop)
     newDudes.each {|kid| kid.progress.should == 13}