answer-factory 0.0.1

data/spec/config_spec.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), "./spec_helper")
+
+
+describe "Factory configuration methods" do
+  describe "configatron integration" do
+    it "should respond to #configatron" do
+      Factory.new.should respond_to(:configatron)
+    end
+  end
+  
+  
+  describe "configure_paths" do
+    it "should respond to #configure_paths" do
+      Factory.new.should respond_to(:configure_paths!)
+    end
+    
+    it "should populate self.configatron.factory_root as the path to the project folder" do
+      this_spec_file_parent_path = File.expand_path("#{File.dirname(__FILE__)}/..")
+      f1 = Factory.new
+      f1.configure_paths!
+      f1.configatron.factory_root.should == this_spec_file_parent_path
+    end
+  end
+  
+  
+  describe "factory name" do
+    it "should populate self.configatron.factory_name" do
+      f1 = Factory.new
+      f1.configure_constants!
+      f1.configatron.factory_name.should == "my_factory"
+      
+      f1 = Factory.new("super_fancy")
+      f1.configure_constants!
+      f1.configatron.factory_name.should == "super_fancy"
+    end
+  end
+  
+  
+  describe "database setup" do
+    describe "paths" do
+      it "should read from database.yml" do
+        f1 = Factory.new("super_fancy")
+        f1.configatron.should_receive(:configure_from_yaml)
+        f1.configure!
+      end
+      
+      describe "subject" do
+        before(:each) do
+          @f1 = Factory.new()
+          @f1.configure!
+        end
+        
+        it "should populate configatron.main_database.db_root" do
+          @f1.configatron.main_database.db_root.should == "http://127.0.0.1:5984"
+        end
+        
+        it "should populate configatron.main_database.db_name" do
+          @f1.configatron.main_database.db_name.should == "my_factory" # from the config file
+        end
+
+        it "should populate configatron.main_database.tag_filter" do
+          @f1.configatron.main_database.tag_filter.should == "_design/routing/_view/by_tag"
+        end
+      end
+      
+    end
+
+    describe "checking for CouchDB access" do
+      it "should call Factory#couch_db?"
+    end
+
+    describe "setting up initial db" do
+      it "should not remove old records unless asked to do so"
+      it "should be possible to erase the db if a flag is set"
+      it "should set up the design document"
+      it "should write the search-by-tag filter view to the design document"
+    end
+  end
+
+
+  describe "Nudge language setup" do
+    it "should set up the Instructions"
+
+    it "should set up the Types"
+
+  end
+  
+end
+
+
+
+
+
+

data/spec/factories/factory_spec.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe "Factory" do
+
+  it "should have a name" do
+    Factory.new("foo_factory").name.should == "foo_factory"
+  end
+  
+  it "should have a default name of 'something here'" do
+    Factory.new.name.should == "my_factory"
+  end
+  
+  describe "ontology" do
+    it "should have a master Instruction list" do
+      Factory.new("foo").instruction_library.should == Instruction.all_instructions
+    end
+    
+    it "should be possible to override the default with an option" do
+      short_list = [IntAddInstruction, CodeNoopInstruction]
+      Factory.new("foo", instruction_library:short_list).instruction_library.should ==
+        short_list
+    end
+    
+    it "should have a master NudgeType list" do
+      Factory.new("foo").type_library.should == NudgeType.all_types
+    end
+    
+    it "should be possible to override the default with an option" do
+      short_list = [CodeType, BoolType]
+      Factory.new("foo", type_library:short_list).type_library.should ==
+        short_list
+    end
+    
+    it "should save all the Hash options it was called with" do
+      Factory.new("bar", my_option:1, my_other_option:[1,2,3]).original_options_hash.should ==
+        {:my_option=>1, :my_other_option=>[1, 2, 3]}
+    end
+    
+  end
+  
+  describe "workstations" do
+    it "should have a list of extant workstation names" do
+      Factory.new.workstation_names.should == []
+    end
+    
+    describe "build_workstation" do
+      it "should create a new workstation"
+      it "should set up all the interior dynamics of the workstation"
+      it "should use the master config for defaults of the new workstation"
+      it "should suffice to create a pass-through workstation just to name it"
+    end
+  end
+  
+  describe "activate" do
+    it "should have an #activate method"
+  end
+  
+  describe "databases" do
+    
+    describe "#couch_available?" do
+      it "should have a method to check that couchDB is accessible" do
+        f1 = Factory.new("boo")
+        lambda{f1.couch_available?}.should_not raise_error
+      end
+      
+      it "should return true if the uri is reachable" do
+        uri = "http://mycouch.db/boo"
+        f1 = Factory.new("boo")
+        f1.configatron.couchdb_uri = uri
+        FakeWeb.register_uri(:any, uri, :body => "We are here!", :status => [200, "OK"])
+        f1.couch_available?.should == true
+      end
+      
+      it "should return false if the uri is offline or 404's out" do
+        uri = "http://mycouch.db/boo"
+        f1 = Factory.new("boo", couchdb_uri:uri)
+        FakeWeb.register_uri(:any, uri, :body => "Go away!", :status => [404, "Not Found"])
+        f1.couch_available?.should == false
+        
+        f1 = Factory.new("boo", couchdb_uri:"http://127.0.0.1:9991/place") # depends on this being wrong
+        f1.couch_available?.should == false
+      end
+    end
+  end
+end

data/spec/factories/workstation_spec.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+describe "Workstation" do
+  
+  describe "names" do
+    it "should have a name" do
+      Workstation.new(:my_workthing).name.should == :my_workthing
+    end
+    
+    it "needs to have a symbol as a name" do
+      lambda{Workstation.new("foo")}.should raise_error(ArgumentError)
+      lambda{Workstation.new}.should raise_error(ArgumentError)
+    end
+    
+    it "should have a factory_name" do
+      Workstation.new(:ws).factory_name.should be_a_kind_of(String)
+    end
+    
+    it "should have a default factory_name of 'factory_name'" do
+      Workstation.new(:ws).factory_name.should == 'factory_name'
+    end
+    
+    it "should be possible to set the factory_name via an initialization option" do
+      Workstation.new(:ws, factory_name:'foo').factory_name.should == 'foo'
+    end
+  end
+  
+  
+  describe "database" do
+    it "should have a URI for a CouchDB instance" do
+      Workstation.new(:ws).couchdb_uri.should be_a_kind_of(String)
+    end
+    
+    it "should default to http://127.0.0.1:5984/\#{@factory_name}" do
+      Workstation.new(:ws).couchdb_uri.should == "http://127.0.0.1:5984/factory_name"
+    end
+  end
+  
+  
+  
+  describe "capacity" do
+    it "should accept a #capacity attribute in initialization" do
+      w1 = Workstation.new(:ws, capacity:12)
+      w1.capacity.should == 12
+    end
+    
+    it "should have a default capacity of 100" do
+       Workstation.new(:ws).capacity.should == 100
+    end
+  end
+  
+  
+  describe "downstream_stations" do
+    it "should have an Array attribute called #downstream_stations" do
+      Workstation.new(:place).downstream_stations.should be_a_kind_of(Array)
+    end
+    
+    it "#downstream_stations should default to an empty Array" do
+      Workstation.new(:place).downstream_stations.should == []
+    end
+  end
+  
+  
+  describe "answers" do
+    it "should be an Array that's empty initially" do
+      Workstation.new(:place).answers.should == []
+    end
+  end
+  
+  
+  describe "transfer_answer" do
+    before(:each) do
+      @a1 = Answer.new("do a", tags:[:here])
+      @w1 = Workstation.new(:here)
+    end
+    
+    it "should change the location tag of the Answer by removing self.name and adding destination.name" do
+      @w1.transfer_answer(@a1, :there)
+      @a1.tags.should include(:there)
+      @a1.tags.should_not include(:here)
+    end
+    
+    it "should validate that the new location (tag) is a Symbol" do
+      lambda{@w1.transfer_answer(@a1, "garbage")}.should raise_error(ArgumentError)
+    end
+    
+    it "should not change state if the ne location name is invalid" do
+      lambda{@w1.transfer_answer(@a1, "garbage")}.should raise_error(ArgumentError)
+      @a1.tags.should include(:here)
+    end
+  end
+  
+  
+  
+  
+  describe "#cycle" do
+    it "should invoke #receive!, #build!, #ship! and #scrap!" do
+      w1 = Workstation.new(:place)
+      w1.should_receive(:receive!)
+      w1.should_receive(:build!)
+      w1.should_receive(:ship!)
+      w1.should_receive(:scrap!)
+      w1.cycle
+    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"
+    end
+    
+    
+    describe "#build!" do
+      
+    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"
+    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"
+    end
+  end
+end

data/spec/operators/any_one_sampler_spec.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+describe AnyOneSampler do
+  before(:each) do
+    @ao = AnyOneSampler.new
+  end
+  
+  
+  describe "#generate" do
+    before(:each) do
+      @dudes = Batch[Answer.new(""), Answer.new(""), Answer.new("")]
+      @dudes[0].scores = Hash["first", 2,   "second", 20,  "third", 200]
+      @dudes[1].scores = Hash["first", 20,  "second", 200, "third", 2]
+      @dudes[2].scores = Hash["first", 200, "second", 2,   "third", 20]
+    end
+    
+    it "should take a Batch as a first parameter" do
+      lambda{@ao.generate()}.should raise_error(ArgumentError)
+      lambda{@ao.generate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+
+    it "should return a Batch" do
+      @ao.generate(@dudes).should be_a_kind_of(Batch)
+    end
+    
+    it "should return a Batch containing references to Answers in the original Batch" do
+      one = @ao.generate(@dudes)
+      one.length.should == 1
+      one.each {|dude| @dudes.should include(dude)}
+    end
+    
+    it "should invoke Batch#sample" do
+      @dudes.should_receive(:sample).and_return(@dudes[0])
+      one = @ao.generate(@dudes)
+    end
+    
+  end
+  
+end

data/spec/operators/dominated_quantile_spec.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(__FILE__), "./../spec_helper")
+
+
+describe DominatedQuantileSampler do
+  before(:each) do
+    @dq = DominatedQuantileSampler.new
+  end
+  
+  
+  describe "domination_classes" do
+    before(:each) do
+      @dudes = Batch[Answer.new("block {}"), Answer.new("do int_add")]
+      @dudes[0].scores["first"] = 120
+      @dudes[1].scores["first"] = 2
+      @dudes[0].scores["second"] = 2
+      @dudes[1].scores["second"] = 120
+      @dudes[0].scores["third"] = 20
+      @dudes[1].scores["third"] = 1200
+    end
+    
+    it "should take a Batch as an argument" do
+      lambda{@dq.domination_classes()}.should raise_error(ArgumentError)
+      lambda{@dq.domination_classes(@dudes)}.should_not raise_error(ArgumentError)
+      
+    end
+    
+    it "can take a template of objective names to use" do
+      lambda{@dq.domination_classes(@dudes, ["first"])}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should return a Hash" do
+      @dq.domination_classes(@dudes, ["first"]).should be_a_kind_of(Hash)
+    end
+    
+    it "should use the count of dominating Answers as the key" do
+      @dq.domination_classes(@dudes, ["second"]).keys.should == [0,1]
+      @dq.domination_classes(@dudes).keys.should == [0]
+      
+    end
+    
+    it "should have an Array of the Answers in that class as the value" do
+      @dq.domination_classes(@dudes, ["first"])[0].length.should == 1
+      @dq.domination_classes(@dudes, ["first"])[0][0].should == @dudes[1]
+      @dq.domination_classes(@dudes, ["second"])[0].length.should == 1
+      @dq.domination_classes(@dudes, ["second"])[0][0].should == @dudes[0]
+      @dq.domination_classes(@dudes, ["second", "third"])[0].length.should == 1
+      @dq.domination_classes(@dudes, ["second", "third"])[0][0].should == @dudes[0]
+    end
+  end
+  
+  
+  describe "#generate" do
+    before(:each) do
+      @dudes = Batch[Answer.new("do int_subtract"), Answer.new("do int_add")]
+      @dudes[0].scores["first"] = 120
+      @dudes[1].scores["first"] = 2
+      @dudes[0].scores["second"] = 2
+      @dudes[1].scores["second"] = 120
+      @dudes[0].scores["third"] = 20
+      @dudes[1].scores["third"] = 1200
+    end
+    
+    it "should take a Batch as a first parameter" do
+      lambda{@dq.generate()}.should raise_error(ArgumentError)
+      lambda{@dq.generate(@dudes)}.should_not raise_error(ArgumentError)
+    end
+
+    it "should return a Batch" do
+      @dq.generate(@dudes).should be_a_kind_of(Batch)
+    end
+    
+    it "should return a Batch containing references to individuals in the original Batch" do
+      half = @dq.generate(@dudes)
+      half.length.should be > 0
+      half.each {|dude| @dudes.should include(dude)}
+    end
+    
+    it "should have a parameter that specifies what fraction to return" do
+      some = @dq.generate(@dudes,1.0)
+      some.length.should == 2
+      
+      some = @dq.generate(@dudes,0.5)
+      some.length.should == 1
+    end
+    
+    it "should always return at least one for a non-zero fraction" do
+      some = @dq.generate(@dudes,0.01)
+      some.length.should be > 0
+      some.each {|dude| @dudes.should include(dude)}
+      
+      some = @dq.generate(@dudes,0)
+      some.length.should == 0
+    end
+    
+    
+    it "should take a template of objectives to use in sorting" do
+      @dq.generate(@dudes,0.5,["first"]).should include(@dudes[0])
+      @dq.generate(@dudes,0.5,["second"]).should include(@dudes[1])
+      @dq.generate(@dudes,0.5,["second", "third"]).should include(@dudes[1])
+    end
+    
+    it "should return the most-dominated Answers first, nondominated last" do
+      some = @dq.generate(@dudes,1, ["first"])
+      some[0].should == @dudes[0]
+      
+      some = @dq.generate(@dudes,1, ["second"])
+      some[0].should == @dudes[1]
+    end
+  end
+  
+end