shared_workforce 0.1.2 → 0.2.0

data/spec/task_request/http_spec.rb

@@ -3,121 +3,78 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe "TaskRequest::Http" do
   describe "#create" do
     it "should invoke a task request" do
-  
-        task = SharedWorkforce::Task.define "Approve photo" do |h|
-
-        h.directions = "Please classify this photo by choosing the appropriate tickboxes."
-        h.image_url = "http://www.google.com/logo.png"
-        h.answer_type = "tags"
-        h.answer_options = ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children']
-        h.responses_required = 3
-        h.replace = false
       
-        h.on_completion do |result|
-          puts "Complete"
-        end
-
-        h.on_failure do |result|
-          puts "Failed"
-        end
-
-      end
-    
-      task_request = SharedWorkforce::TaskRequest::Http.new(task, :callback_params=>{:resource_id=>'1234'})
+      task = ApprovePhotoTask.new
+      task_request = SharedWorkforce::TaskRequest::Http.new(task, :image_url=>"http://www.google.com/logo.png", :callback_params=>{:resource_id=>'1234'})
     
       stub_request(:post, "api.sharedworkforce.com/tasks")
       task_request.create
       a_request(:post, "http://api.sharedworkforce.com/tasks").with(:body=>{'task'=>
         {
-          'name'=>"Approve photo",
-          'directions'=>"Please classify this photo by choosing the appropriate tickboxes.",
+          'title'=>"Approve Photo",
+          'instruction'=>"Please classify this photo by choosing the appropriate tickboxes.",
           'image_url'=>"http://www.google.com/logo.png",
           'answer_options'=> ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children'],
           'responses_required'=>3,
           'answer_type'=>'tags',
           'callback_url'=>"#{SharedWorkforce.configuration.callback_host}/hci_task_result",
           'callback_params'=>{'resource_id'=>'1234'},
-          'replace'=>false
+          'replace'=>true
         }, :api_key=>'test-api-key'}).should have_been_made.once
     
     end
     
-    it "should allow options to be overridden when making the request" do
-
-       task = SharedWorkforce::Task.define "Approve photo" do |h|
-
-         h.directions = "Please classify this photo by choosing the appropriate tickboxes."
-         h.image_url = "http://www.google.com/logo.png"
-         h.answer_type = "tags"
-         h.answer_options = ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children']
-         h.responses_required = 3
-
-         h.on_completion do |result|
-           puts "Complete"
-         end
-
-         h.on_failure do |result|
-           puts "Failed"
-         end
-
-       end
+    it "should allow options to be overridden when making the request" do     
+      task = Class.new do
+        include SharedWorkforce::Task
+ 
+        title 'Approve Photo'
+        instruction 'Please classify this photo by choosing the appropriate tickboxes.'
+        responses_required 3
+        image_url "http://www.google.com/logo.png"
+        answer_type :tags
+        replace false
+ 
+        answer_options ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children']
+      end
 
-       task_request = SharedWorkforce::TaskRequest::Http.new(task, {:callback_params=>{:resource_id=>'1234'}, :image_url=>"http://www.example.com/image.jpg"})
+      task_request = SharedWorkforce::TaskRequest::Http.new(task.new, {:callback_params=>{:resource_id=>'1234'}, :image_url=>"http://www.example.com/image.jpg"})
 
-       stub_request(:post, "api.sharedworkforce.com/tasks")
-       task_request.create
-       a_request(:post, "http://api.sharedworkforce.com/tasks").with(:body=>{'task'=>
-         {
-           'name'=>"Approve photo",
-           'directions'=>"Please classify this photo by choosing the appropriate tickboxes.",
-           'image_url'=>"http://www.example.com/image.jpg",
-           'answer_options'=> ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children'],
-           'responses_required'=>3,
-           'answer_type'=>'tags',
-           'callback_url'=>"#{SharedWorkforce.configuration.callback_host}/hci_task_result",
-           'callback_params'=>{'resource_id'=>'1234'},
-           'replace'=>false,
-         }, :api_key=>'test-api-key'}).should have_been_made.once
+      stub_request(:post, "api.sharedworkforce.com/tasks")
+      task_request.create
+      a_request(:post, "http://api.sharedworkforce.com/tasks").with(:body=>{'task'=>
+        {
+          'title'=>"Approve Photo",
+          'instruction'=>"Please classify this photo by choosing the appropriate tickboxes.",
+          'image_url'=>"http://www.example.com/image.jpg",
+          'answer_options'=> ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children'],
+          'responses_required'=>3,
+          'answer_type'=>'tags',
+          'callback_url'=>"#{SharedWorkforce.configuration.callback_host}/hci_task_result",
+          'callback_params'=>{'resource_id'=>'1234'},
+          'replace'=>false,
+        }, :api_key=>'test-api-key'}).should have_been_made.once
      end
   end
   
   describe "#cancel" do
     it "should invoke a task cancellation" do
     
-      task = SharedWorkforce::Task.define "Approve photo" do |h|
-
-        h.directions = "Please classify this photo by choosing the appropriate tickboxes."
-        h.image_url = "http://www.google.com/logo.png"
-        h.answer_type = "tags"
-        h.answer_options = ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children']
-        h.responses_required = 3
-        h.replace = false
-      
-        h.on_completion do |result|
-          puts "Complete"
-        end
-
-        h.on_failure do |result|
-          puts "Failed"
-        end
-
-      end
-    
-      task_request = SharedWorkforce::TaskRequest::Http.new(task, :callback_params=>{:resource_id=>'1234'})
+      task_request = SharedWorkforce::TaskRequest::Http.new(ApprovePhotoTask.new, :callback_params=>{:resource_id=>'1234'})
     
       stub_request(:post, "api.sharedworkforce.com/tasks/cancel")
       task_request.cancel
       a_request(:post, "http://api.sharedworkforce.com/tasks/cancel").with(:body=>{'task'=>
         {
-          'name'=>"Approve photo",
-          'directions'=>"Please classify this photo by choosing the appropriate tickboxes.",
+          'title'=>"Approve Photo",
+          'instruction'=>"Please classify this photo by choosing the appropriate tickboxes.",
           'image_url'=>"http://www.google.com/logo.png",
           'answer_options'=> ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children'],
           'responses_required'=>3,
           'answer_type'=>'tags',
           'callback_url'=>"#{SharedWorkforce.configuration.callback_host}/hci_task_result",
           'callback_params'=>{'resource_id'=>'1234'},
-          'replace'=>false
+          'replace'=>true
         }, :api_key=>'test-api-key'}).should have_been_made.once
     
     end

data/spec/task_result_spec.rb

@@ -2,36 +2,30 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "TaskResult" do
   describe "#process!" do
-    it "should invoke a tasks complete callback" do
-      
-      resources = {}
-      resources['1'] = OpenStruct.new(:approved=>false)
-      resources['2'] = OpenStruct.new(:approved=>false)
-      resources['3'] = OpenStruct.new(:approved=>false)
-        
-      task = SharedWorkforce::Task.define("Approve photo") do |h|
-        
-        h.on_completion do |result|
-          if result.responses.first.answer == 'yes'
-            resources[result.callback_params['resource_id']].approved = true
-          end
-        end
-        
-      end
-      
-      SharedWorkforce::TaskResult.new({'callback_params'=>{'resource_id' => '2'}, 'responses'=>[{'answer'=>'yes'}], 'name'=>"Approve photo"}).process!
-      
-      resources['1'].approved.should == false
-      resources['2'].approved.should == true
-      resources['3'].approved.should == false
-      
+    it "should invoke Task#process_result" do
+      ApprovePhotoTask.any_instance.should_receive(:process_result).once
+      SharedWorkforce::TaskResult.new({'callback_params'=>{'_task'=>{'class_name'=>'ApprovePhotoTask'}, 'resource_id' => '2', 'responses'=>[{'answer'=>'yes'}], 'name'=>"Approve photo please"}}).process!
     end
   end
   
-  describe "#answers" do
-    it "should collect the answers" do  
-      r = SharedWorkforce::TaskResult.new({'callback_params'=>{'resource_id' => '2'}, 'responses'=>[{'answer'=>'yes'}, {'answer'=>'no'}, {'answer'=>'yes'}], 'name'=>"Approve photo"})
-      r.answers.should == ['yes', 'no', 'yes']
+  describe "#responses" do
+    it "should convert the result to a hash" do
+      r = SharedWorkforce::TaskResult.new(
+        {'callback_params'=>{'resource_id' => '2'},
+         'responses'=>[
+            {'answer'=>'yes', 'username'=>'bilbo'},
+            {'answer'=>'no', 'username'=>'frodo'},
+            {'answer'=>'yes', 'username'=>'sam'}
+          ],
+        'name'=>"Approve photo"
+        }
+      )
+
+      r.responses.should == [
+        {:answer=>'yes', :answered_by=>'bilbo'},
+        {:answer=>'no', :answered_by=>'frodo'},
+        {:answer=>'yes', :answered_by=>'sam'}
+      ]
     end
   end
   
@@ -41,4 +35,5 @@ describe "TaskResult" do
       r.usernames.should == ['bilbo', 'frodo', 'sam']
     end
   end
+
 end

data/spec/task_spec.rb

@@ -1,112 +1,327 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'ostruct'
 
 describe "Task" do
-  it "should define a task" do
-    
-    SharedWorkforce::Task.define "Approve photo" do |h|
-      
-      h.directions = "Please classify this photo by choosing the appropriate tickboxes."
-      h.image_url = "http://www.google.com/logo.png"
-      h.answer_options = ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways', 'Contains more than one person in the foreground', 'Has people in the background', 'Contains children']
-      h.responses_required = 3
-
-      h.on_completion do |result|
+
+  before(:each) do
+    @resource_class = Class.new { def self.name; "Resource"; end; def self.find; end; def id; 333; end }
+  end
+
+  it "should define a task with default attributes" do
+    task_class = Class.new do
+      include SharedWorkforce::Task
+
+      title 'Approve Photo'
+      instruction 'Please classify this photo by choosing the appropriate tickboxes.'
+      responses_required 3
+      image_url "http://www.google.com/logo.png"
+
+      answer_options ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways']
+
+      on_complete :puts_complete
+      on_failure :puts_failure
+
+      def puts_complete(results)
         puts "Complete"
       end
 
-      h.on_failure do |result|
-        puts "Failed"
+      def puts_failure(results)
+        puts "Failure"
       end
-
     end
     
-    SharedWorkforce::Task.tasks.first[1].directions.should == "Please classify this photo by choosing the appropriate tickboxes."
-    
+    task = task_class.new
+    task.instruction.should == "Please classify this photo by choosing the appropriate tickboxes."
+    task.title.should == "Approve Photo"
+    task.responses_required.should == 3
+    task.image_url.should == "http://www.google.com/logo.png"
+    task.answer_options.should == ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways']
   end
-  
-  it "should run a completion callback" do
-    
-    object = OpenStruct.new(:test=>nil)
-    
-    task = SharedWorkforce::Task.define "Approve photo" do |h|
-      
-      h.on_completion do |result|
-        object.test = "Complete"
+
+  it "should allow certain default attributes to be overwritten" do
+    task_class = Class.new do
+      include SharedWorkforce::Task
+
+      title 'Approve Photo'
+      instruction 'Please classify this photo by choosing the appropriate tickboxes.'
+      responses_required 3
+      image_url "http://www.google.com/logo.png"
+      replace false
+
+      answer_options ['Obscenity', 'Nudity', 'Blurry', 'Upside down or sideways']
+
+      text "A photo"
+
+      on_complete :puts_complete
+      on_failure :puts_failure
+
+      def puts_complete(results)
+        puts "Complete"
+      end
+
+      def puts_failure(results)
+        puts "Failure"
       end
-      
     end
     
-    object.test.should == nil
-    task.complete!({})
-    object.test.should == "Complete"
+    task = task_class.new
+    
+    task.image_url = "http://www.bing.com"
+    task.answer_options = ['Poor quality']
+    task.responses_required = 10
+    task.instruction = nil
+    task.replace = true
+
+    task.image_url.should == "http://www.bing.com"
+    task.answer_options.should == ['Poor quality']
+    task.responses_required.should == 10
+    task.instruction.should == nil
+    task.replace.should == true
+    task.text.should == "A photo"
+  end
+
+  describe ".new" do
+    it "should set the attributes from the task result callback params" do
+      task_class = Class.new { include SharedWorkforce::Task; on_success :do_work; def do_work(*args); end; def setup(*args); end }
+      task_class.any_instance.should_receive(:success!)
+      task_class.any_instance.should_receive(:complete!)
+      task = task_class.new(SharedWorkforce::TaskResult.new({'callback_params'=>{'key'=>'value'}}))
+      task.attributes[:key].should == 'value'
+    end
+  end
+
+  describe ".create" do
+    it "should create a new task instance" do
+      resource = @resource_class.new
+      task_class = Class.new { include SharedWorkforce::Task }
+      task_class.any_instance.should_receive(:request)
+      task = task_class.create(resource, :field=>'name')
+      task.resource.should == resource
+      task.attributes[:field].should == 'name'
+    end
+
+    it "should pass the arguments through to Task#request" do
+      resource = @resource_class.new
+      task_class = Class.new { include SharedWorkforce::Task }
+      task_class.any_instance.should_receive(:request)
+      task_class.create(resource, :field=>'name')
+    end
   end
   
-  it "should run a failure callback" do
-    
-    object = OpenStruct.new(:test=>nil)
+  describe "#process_result" do
+    it "should call success! and complete! with the results" do # Will become more important once we have task failure event handling
+      task_class = Class.new { include SharedWorkforce::Task; on_success :do_work; def do_work(*args); end; def setup(*args); end }
+      task = task_class.new
+      task.should_receive(:success!)
+      task.should_receive(:complete!)
+      task.process_result(SharedWorkforce::TaskResult.new({}))
+    end
+  end
+
+  describe "the callback" do
+
+    before(:each) do
+      @task_class = Class.new { 
+        include SharedWorkforce::Task
+        on_success :do_work
+        on_complete :do_log
+        on_failure :try_again
+        def do_work(*args); end;
+        def setup(*args); end
+      }
+
+      @resource = @resource_class.new
+      @task = @task_class.new(@resource)
+      @result = SharedWorkforce::TaskResult.new(
+        {
+         'responses'=>[
+            {'answer'=>'yes', 'username'=>'bilbo'},
+            {'answer'=>'no', 'username'=>'frodo'},
+            {'answer'=>'yes', 'username'=>'sam'}
+          ],
+        'name'=>"Approve photo",
+        'callback_params'=>@task.attributes
+        }
+      )
+    end
     
-    task = SharedWorkforce::Task.define "Approve photo" do |h|
-      
-      h.on_failure do |result|
-        object.test = "Failed"
+    describe "#success!" do
+      it "should run a success callback" do
+        @task.should_receive(:do_work)
+        @task.success!(@result)
+      end
+
+      it "should pass the resource to the callback method as the first argument and the result as the second argument" do
+        result = SharedWorkforce::TaskResult.new(:callback_params=>@task.attributes)
+        @task.should_receive(:do_work).with(@resource, @result.responses)
+        @task.success!(@result)
+      end
+    end
+
+    describe "#complete!" do
+      it "should run a complete callback" do
+        @task.should_receive(:do_log)
+        @task.complete!(@result)
+      end
+
+      it "should pass the resource to the callback method as the first argument and the result as the second argument" do
+        result = SharedWorkforce::TaskResult.new({})
+        @task.should_receive(:do_log).with(@resource, @result.responses)
+        @task.complete!(@result)
+      end
+    end
+
+    describe "#fail!" do
+      it "should run a failure callback" do
+        @task.should_receive(:try_again)
+        @task.fail!(@result)
+      end
+
+      it "should pass the resource to the callback method as the first argument and the result as the second argument" do
+        result = SharedWorkforce::TaskResult.new({})
+        @task.should_receive(:try_again).with(@resource, @result.responses)
+        @task.fail!(@result)  
+      end
+
+      it "should not raise an error if there is no callback defined" do
+        lambda {
+          task = Class.new { include SharedWorkforce::Task }
+          task.new.fail!({})
+        }.should_not raise_error
       end
-      
     end
-    
-    object.test.should == nil
-    task.fail!({})
-    object.test.should == "Failed"
   end
-  
-  it "should not raise an error if there is no callback defined" do
-    lambda {
-      task = SharedWorkforce::Task.define("Approve photo") { }
-      task.fail!({})
-    }.should_not raise_error
+
+  describe ".new" do
+    before do
+      @task_class = Class.new { include SharedWorkforce::Task; def setup(*args); end }
+    end
+
+    it "should call setup after initialization" do
+      @task_class.any_instance.should_receive(:setup).once
+      @task_class.new
+    end
+
+    it "should pass the resource as an argument to setup" do
+      @resource = @resource_class.new
+      @task_class.any_instance.should_receive(:setup).with(@resource).once
+      @task_class.new(@resource)
+    end
+
+    it "should set the callback params when passed as an argument" do
+      @resource = @resource_class.new
+      attributes = {:profile_field=>'introduction'}
+      task = @task_class.new(@resource, attributes)
+      task.attributes[:profile_field].should == 'introduction'
+    end
+
+    it "should symbolize the keys of the callback params when passed as an argument" do
+      @resource = @resource_class.new
+      attributes = {'profile_field'=>'introduction'}
+      task = @task_class.new(@resource, attributes)
+      task.attributes[:profile_field].should == 'introduction'
+    end
   end
-  
-  it "should request a task" do
-    task = SharedWorkforce::Task.define("Approve photo") { }
-    task.should_receive(:request).with(:request_id=>'123')
-    SharedWorkforce::Task.request("Approve photo", :request_id=>'123')
+
+  describe ".attributes[]" do
+    it "should allow callback params to be set" do
+      task = Class.new { include SharedWorkforce::Task }.new(@resource_class.new, {})
+      task.attributes[:profile_field] = 'introduction'
+      task.attributes[:profile_field].should == 'introduction'
+    end
   end
-  
-  it "should cancel a task" do
-    task = SharedWorkforce::Task.define("Approve photo") { }
-    task.should_receive(:request).with(:request_id=>'123')
-    SharedWorkforce::Task.request("Approve photo", :request_id=>'123')
-    
-    task.should_receive(:cancel).with(:request_id=>'123')
-    SharedWorkforce::Task.cancel("Approve photo", :request_id=>'123')
+
+  describe "#request" do
+    it "should make a new task http request" do
+      task = Class.new { include SharedWorkforce::Task }
+
+      stub_request(:post, "http://api.sharedworkforce.com/tasks")
+      task.new.request(:request_id=>'123')
+      a_request(:post, "http://api.sharedworkforce.com/tasks").should have_been_made.once
+    end
   end
   
-  it "should find a task" do
-    SharedWorkforce::Task.define("Approve photo") { }
-    SharedWorkforce::Task.define("Check profile text") { }
-    SharedWorkforce::Task.define("Check content") { }
-    
-    
-    SharedWorkforce::Task.find("Check profile text").name.should == "Check profile text"
+  describe "#cancel" do
+    it "should send a cancel task http request" do
+      task_class = Class.new { include SharedWorkforce::Task }
+
+      stub_request(:post, "http://api.sharedworkforce.com/tasks/cancel")
+      task_class.cancel(@resource_class.new)
+      a_request(:post, "http://api.sharedworkforce.com/tasks/cancel").should have_been_made.once
+    end
+
+    it "should raise a ConfigurationError if a callback host is not set" do
+      task = Class.new { include SharedWorkforce::Task }
+      with_configuration do |config|
+        config.callback_host = nil
+        lambda {
+          task.new.cancel(:request_id=>'123')
+        }.should raise_error SharedWorkforce::ConfigurationError
+      end
+    end
     
+    it "should raise a ConfigurationError if an API key is not set" do
+      task = Class.new { include SharedWorkforce::Task }
+      with_configuration do |config|
+        config.api_key = nil
+        lambda {
+          task.new.cancel(:request_id=>'123')
+        }.should raise_error SharedWorkforce::ConfigurationError
+      end
+    end
   end
-  
-  it "should raise a ConfigurationError if a callback host is not set" do
-    SharedWorkforce::Task.define("Approve photo") {}
-    with_configuration do |config|
-      config.callback_host = nil
+
+  describe "#resource" do
+    it "should return the resource that passed to as an argument to new" do
+      task_class = Class.new { include SharedWorkforce::Task }
+      resource = @resource_class.new
+      task = task_class.new(resource)
+      task.resource.should == resource
+    end
+
+    it "should raise an ArgumentError if the resource does not respond to #find" do
+      task_class = Class.new { include SharedWorkforce::Task }
+      resource = double
       lambda {
-        SharedWorkforce::Task.request("Approve photo", {})
-      }.should raise_error SharedWorkforce::ConfigurationError
+        task = task_class.new(resource)
+      }.should raise_error ArgumentError
+    end
+
+    it "should return the resource from the callback params" do
+      class ResourceFinder; def self.find(id); return "#{id}ABCD"; end; end
+      task_class = Class.new { include SharedWorkforce::Task }
+      task = task_class.new(SharedWorkforce::TaskResult.new({'callback_params'=>{'_task'=>{'resource'=>{'class_name'=>'ResourceFinder', 'id' => '2'}}}}))
+      task.resource.should == "2ABCD"
+    end
+
+    it "should return nil if the callback params do not specify a resource" do
+      task_class = Class.new { include SharedWorkforce::Task }
+      task = task_class.new(SharedWorkforce::TaskResult.new({'callback_params'=>{}}))
+      task.resource.should == nil
     end
   end
-  
-  it "should raise a ConfigurationError if an API key is not set" do
-    SharedWorkforce::Task.define("Approve photo") {}
-    with_configuration do |config|
-      config.api_key = nil
-      lambda {
-        SharedWorkforce::Task.request("Approve photo", {})
-      }.should raise_error SharedWorkforce::ConfigurationError
+
+  describe "#to_hash" do
+    it "should include the class name and id of the resource in the callback params" do
+      task_class = Class.new { include SharedWorkforce::Task }
+      task = task_class.new(@resource_class.new)
+      task.to_hash[:callback_params][:_task][:resource][:id].should == 333
+      task.to_hash[:callback_params][:_task][:resource][:class_name].should == "Resource"
+    end
+
+    it "should include custom callback params in the callback params" do
+      task_class = Class.new { include SharedWorkforce::Task }
+      task = task_class.new(@resource_class.new, :profile_field=>'introduction')
+      task.to_hash[:callback_params][:_task][:resource][:id].should == 333
+      task.to_hash[:callback_params][:_task][:resource][:class_name].should == "Resource"
+      task.to_hash[:callback_params][:profile_field].should == 'introduction'
+    end
+
+    it "should include the class name of the task" do
+      task = ApprovePhotoTask.new(@resource_class.new, :profile_field=>'introduction')
+      task.to_hash[:callback_params][:_task][:resource][:id].should == 333
+      task.to_hash[:callback_params][:_task][:resource][:class_name].should == "Resource"
+      task.to_hash[:callback_params][:_task][:class_name].should == 'ApprovePhotoTask'
     end
   end
 end