ruote-kit 2.2.0.3 → 2.3.0.2

data/spec/resources/schedules_spec.rb

@@ -1,121 +1,137 @@
 
-require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'spec_helper'
 
 
-describe 'GET /_ruote/schedules' do
+describe '/_ruote/schedules' do
 
   before(:each) do
-
     prepare_engine_with_participants
-
-    @wfid0 = RuoteKit.engine.launch(Ruote.define do
-      wait :for => '3d'
-    end)
-    @wfid1 = RuoteKit.engine.launch(Ruote.define do
-      sequence do
-        alpha :timeout => '2d'
-      end
-    end)
-    @wfid2 = RuoteKit.engine.launch(Ruote.define do
-       nada
-    end)
-
-    RuoteKit.engine.wait_for(:alpha)
   end
-
   after(:each) do
-
     shutdown_and_purge_engine
   end
 
-  it 'should list schedules (HTML)' do
+  describe 'GET /_ruote/schedules' do
 
-    get '/_ruote/schedules'
+    before(:each) do
 
-    last_response.status.should be(200)
+      @wfid0 = RuoteKit.engine.launch(Ruote.define do
+        wait :for => '3d'
+      end)
+      @wfid1 = RuoteKit.engine.launch(Ruote.define do
+        sequence do
+          alpha :timeout => '2d'
+        end
+      end)
+      @wfid2 = RuoteKit.engine.launch(Ruote.define do
+         nada
+      end)
 
-    last_response.should have_selector(
-      'a[rel="http://ruote.rubyforge.org/rels.html#process_schedules"]')
+      RuoteKit.engine.wait_for(:alpha)
+    end
 
-    last_response.should contain('1 to 2 of 2 schedules')
-  end
+    it 'lists schedules (HTML)' do
+
+      get '/_ruote/schedules'
 
-  it 'should list schedules (JSON)' do
+      last_response.status.should be(200)
 
-    get '/_ruote/schedules.json'
+      last_response.should have_selector(
+        'a[rel="http://ruote.rubyforge.org/rels.html#process_schedules"]')
 
-    last_response.status.should be(200)
+      last_response.should contain('1 to 2 of 2 schedules')
+    end
 
-    json = last_response.json_body
-    #puts Rufus::Json.pretty_encode(json)
+    it 'lists schedules (JSON)' do
 
-    schedules = json['schedules']
+      get '/_ruote/schedules.json'
 
-    schedules.size.should == 2
+      last_response.status.should be(200)
 
-    schedules.first.keys.sort.should == %w[
-      _id action at flavour links original owner put_at target type wfid
-    ]
+      json = last_response.json_body
+      #puts Rufus::Json.pretty_encode(json)
 
-    schedules.first['target'].should be_kind_of(Hash)
-    schedules.first['owner'].should be_kind_of(Hash)
+      schedules = json['schedules']
 
-    hrefs = schedules.collect { |s| s['links'].first['href'] }
-    prefixes = hrefs.collect { |h| h.split('!').first }.sort
-    suffixes = hrefs.collect { |h| h.split('!').last }.sort
+      schedules.size.should == 2
 
-    hrefs = schedules.collect { |s|
-      s['links'].first['href']
-    }.collect { |h|
-      pieces = h.split('!')
-      pieces.first + '/' + pieces.last
-    }.sort
+      schedules.first.keys.sort.should == %w[
+        _id action at flavour links original owner put_at target type wfid
+      ]
 
-    hrefs.should ==
-      [ "/_ruote/expressions/0_0/#{@wfid0}",
-        "/_ruote/expressions/0_0_0/#{@wfid1}" ]
+      schedules.first['target'].should be_kind_of(Hash)
+      schedules.first['owner'].should be_kind_of(Hash)
+
+      hrefs = schedules.collect { |s| s['links'].first['href'] }
+      prefixes = hrefs.collect { |h| h.split('!').first }.sort
+      suffixes = hrefs.collect { |h| h.split('!').last }.sort
+
+      hrefs = schedules.collect { |s|
+        s['links'].first['href']
+      }.collect { |h|
+        pieces = h.split('!')
+        pieces.first + '/' + pieces.last
+      }.sort
+
+      hrefs.should ==
+        [ "/_ruote/expressions/0_0/#{@wfid0}",
+          "/_ruote/expressions/0_0_0/#{@wfid1}" ]
+    end
   end
-end
 
-describe 'GET /_ruote/schedules/wfid' do
+  describe 'GET /_ruote/schedules/:wfid' do
 
-  before(:each) do
+    before(:each) do
 
-    prepare_engine_with_participants
+      @wfid0 = RuoteKit.engine.launch(Ruote.define do
+        wait :for => '3d'
+      end)
+      @wfid1 = RuoteKit.engine.launch(Ruote.define do
+        sequence do
+          alpha :timeout => '2d'
+        end
+      end)
 
-    @wfid0 = RuoteKit.engine.launch(Ruote.define do
-      wait :for => '3d'
-    end)
-    @wfid1 = RuoteKit.engine.launch(Ruote.define do
-      sequence do
-        alpha :timeout => '2d'
-      end
-    end)
+      RuoteKit.engine.wait_for(:alpha)
 
-    RuoteKit.engine.wait_for(:alpha)
-  end
+      @wfid2 = RuoteKit.engine.launch(Ruote.define do
+        bravo :timers => '1d: x, 2d: timeout'
+      end)
 
-  after(:each) do
+      RuoteKit.engine.wait_for(:bravo)
+    end
 
-    shutdown_and_purge_engine
-  end
+    it 'lists schedules (HTML)' do
 
-  it 'should list schedules (HTML)' do
+      get "/_ruote/schedules/#{@wfid1}"
 
-    get "/_ruote/schedules/#{@wfid1}"
+      last_response.status.should be(200)
+    end
 
-    last_response.status.should be(200)
-  end
+    it 'lists schedules (JSON)' do
+
+      get "/_ruote/schedules/#{@wfid0}.json"
+
+      last_response.status.should be(200)
+
+      #puts Rufus::Json.pretty_encode(last_response.json_body)
+
+      last_response.json_body['schedules'].size.should == 1
+    end
+
+    it 'list schedules with timers (nil target) (HTML)' do
 
-  it 'should list schedules (JSON)' do
+      get "/_ruote/schedules/#{@wfid2}"
 
-    get "/_ruote/schedules/#{@wfid0}.json"
+      last_response.status.should be(200)
+    end
 
-    last_response.status.should be(200)
+    it 'list schedules with timers (nil target) (JSON)' do
 
-    #puts Rufus::Json.pretty_encode(last_response.json_body)
+      get "/_ruote/schedules/#{@wfid2}.json"
 
-    last_response.json_body['schedules'].size.should == 1
+      last_response.status.should be(200)
+    end
   end
 end
 

data/spec/resources/workitems_spec.rb

@@ -1,542 +1,551 @@
 
-require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'spec_helper'
 
 
-def workitem_count(from, to, of)
-  [
-    from, 'to', to, 'of', of, 'workitems'
-  ].collect { |e|
-    e.to_s
-  }.join("\n          ")
-end
-
-
-describe 'GET /_ruote/workitems' do
+describe '/_ruote/workitems' do
 
   before(:each) do
-
     prepare_engine
   end
-
   after(:each) do
-
     shutdown_and_purge_engine
   end
 
-  describe 'without any workitems' do
+  def workitem_count(from, to, of)
 
-    it 'should report no workitems (HTML)' do
-
-      get '/_ruote/workitems'
+    /\s#{from}\s+to\s+#{to}\s+of\s+#{of}\s/
+  end
 
-      last_response.should be_ok
+  describe 'GET /_ruote/workitems' do
 
-      last_response.should match(workitem_count(0, 0, 0))
-    end
+    context 'without any workitems' do
 
-    it 'should report no workitems (JSON)' do
+      it 'reports no workitems (HTML)' do
 
-      get '/_ruote/workitems.json'
+        get '/_ruote/workitems'
 
-      last_response.should be_ok
-      json = last_response.json_body
+        last_response.should be_ok
 
-      json.should have_key('workitems')
-      json['workitems'].should be_empty
-    end
-  end
+        last_response.should match(workitem_count(0, 0, 0))
+      end
 
-  describe 'with workitems' do
+      it 'reports no workitems (JSON)' do
 
-    before(:each) do
+        get '/_ruote/workitems.json'
 
-      register_participants
+        last_response.should be_ok
+        json = last_response.json_body
 
-      @wfid = RuoteKit.engine.launch(Ruote.process_definition do
-        sequence do
-          nada :activity => 'Work your magic'
-        end
-      end)
-
-      RuoteKit.engine.wait_for(:nada)
-      RuoteKit.engine.wait_for(1)
+        json.should have_key('workitems')
+        json['workitems'].should be_empty
+      end
     end
 
-    it 'should have a list of workitems (HTML)' do
+    context 'with workitems' do
 
-      get '/_ruote/workitems'
+      before(:each) do
 
-      last_response.should match(workitem_count(1, 1, 1))
-    end
+        register_participants
 
-    it 'should have a list of workitems (JSON)' do
+        @wfid = RuoteKit.engine.launch(Ruote.process_definition do
+          sequence do
+            nada :activity => 'Work your magic'
+          end
+        end)
 
-      get '/_ruote/workitems.json'
+        RuoteKit.engine.wait_for(:nada)
+        RuoteKit.engine.wait_for(1)
+      end
 
-      last_response.should be_ok
-      json = last_response.json_body
+      it 'returns a list of workitems (HTML)' do
 
-      json['workitems'].size.should == 1
+        get '/_ruote/workitems'
 
-      wi = json['workitems'][0]
+        last_response.should match(workitem_count(1, 1, 1))
+        last_response.should have_selector('td', :content => @wfid)
+      end
 
-      wi.keys.should include('fei', 'participant_name', 'fields')
-      wi['wfid'].should == @wfid
-      wi['participant_name'].should == 'nada'
-      wi['fields']['params']['activity'].should == 'Work your magic'
-    end
-  end
-end
+      it 'returns a list of workitems (JSON)' do
 
-describe 'GET /_ruote/workitems/wfid' do
+        get '/_ruote/workitems.json'
 
-  before(:each) do
+        last_response.status.should == 200
 
-    prepare_engine
-  end
+        json = last_response.json_body
 
-  after(:each) do
+        json['workitems'].size.should == 1
 
-    shutdown_and_purge_engine
-  end
+        wi = json['workitems'][0]
 
-  describe 'with workitems' do
+        wi.keys.should include('fei', 'participant_name', 'fields')
+        wi['wfid'].should == @wfid
+        wi['participant_name'].should == 'nada'
+        wi['fields']['params']['activity'].should == 'Work your magic'
+      end
 
-    before(:each) do
+      it 'respects skip and limit (HTML)' do
 
-      register_participants
+        get '/_ruote/workitems?limit=100&skip=0'
 
-      @wfid = RuoteKit.engine.launch(Ruote.process_definition do
-        concurrence do
-          nada :activity => 'This'
-          nada :activity => 'Or that'
-        end
-      end)
+        last_response.should match(workitem_count(1, 1, 1))
+        last_response.should have_selector('td', :content => @wfid)
+      end
 
-      RuoteKit.engine.wait_for(:nada)
-      RuoteKit.engine.wait_for(1)
-    end
+      it 'respects skip and limit (JSON)' do
 
-    it 'should list the workitems (HTML)' do
+        get '/_ruote/workitems.json?limit=100&skip=0'
 
-      get "/_ruote/workitems/#{@wfid}"
+        last_response.status.should == 200
 
-      last_response.should be_ok
+        json = last_response.json_body
 
-      last_response.should have_selector(
-        'div#pagination', :content => '2 workitems')
+        json['workitems'].size.should == 1
+      end
     end
+  end
 
-    it 'should list the workitems (JSON)' do
+  describe 'GET /_ruote/workitems/:wfid' do
 
-      get "/_ruote/workitems/#{@wfid}.json"
+    context 'with workitems' do
 
-      last_response.should be_ok
+      before(:each) do
 
-      json = last_response.json_body
+        register_participants
 
-      json.should have_key('workitems')
-      json['workitems'].should_not be_empty
-    end
-  end
+        @wfid = RuoteKit.engine.launch(Ruote.process_definition do
+          concurrence do
+            nada :activity => 'This'
+            nada :activity => 'Or that'
+          end
+        end)
 
-  describe 'without workitems' do
+        RuoteKit.engine.wait_for(:nada)
+        RuoteKit.engine.wait_for(1)
+      end
 
-    it 'should report no workitems (HTML)' do
+      it 'lists the workitems (HTML)' do
 
-      get '/_ruote/workitems/foo'
+        get "/_ruote/workitems/#{@wfid}"
 
-      last_response.should be_ok
+        last_response.should be_ok
 
-      last_response.should have_selector(
-        'div#pagination', :content => '0 workitems')
-    end
+        last_response.should have_selector(
+          'div#pagination', :content => '2 workitems')
+      end
 
-    it 'should report an empty list (JSON)' do
+      it 'lists the workitems (JSON)' do
 
-      get '/_ruote/workitems/foo.json'
+        get "/_ruote/workitems/#{@wfid}.json"
 
-      last_response.should be_ok
+        last_response.should be_ok
 
-      json = last_response.json_body
+        json = last_response.json_body
 
-      json.should have_key('workitems')
-      json['workitems'].should be_empty
+        json.should have_key('workitems')
+        json['workitems'].should_not be_empty
+      end
     end
-  end
-end
 
-describe 'GET /_ruote/workitems/expid!subid!wfid' do
+    context 'without workitems' do
 
-  before(:each) do
+      it 'reports no workitems (HTML)' do
 
-    prepare_engine_with_participants
-  end
+        get '/_ruote/workitems/foo'
 
-  after(:each) do
+        last_response.should be_ok
 
-    shutdown_and_purge_engine
-  end
+        last_response.should have_selector(
+          'div#pagination', :content => '0 workitems')
+      end
 
-  describe 'with a workitem' do
+      it 'reports an empty list (JSON)' do
 
-    before(:each) do
+        get '/_ruote/workitems/foo.json'
 
-      @wfid = RuoteKit.engine.launch(Ruote.process_definition do
-        sequence do
-          nada :activity => 'Work your magic'
-        end
-      end)
+        last_response.should be_ok
 
-      RuoteKit.engine.wait_for(:nada)
+        json = last_response.json_body
 
-      @fei = engine.process(@wfid).expressions.last.fei
+        json.should have_key('workitems')
+        json['workitems'].should be_empty
+      end
     end
+  end
 
-    it 'should return it (HTML)' do
+  describe 'GET /_ruote/workitems/expid!subid!wfid' do
 
-      get "/_ruote/workitems/#{@fei.sid}"
+    context 'with a workitem' do
 
-      last_response.should be_ok
-    end
+      before(:each) do
 
-    it 'should return it (JSON)' do
+        register_participants
 
-      get "/_ruote/workitems/#{@fei.sid}.json"
+        @wfid = RuoteKit.engine.launch(
+          Ruote.process_definition(:name => 'x', :rev => 'y') do
+            sequence do
+              nada :activity => 'Work your magic'
+            end
+          end)
 
-      last_response.should be_ok
-    end
+        RuoteKit.engine.wait_for(:nada)
 
-    it 'should provide a workitem with the correct links (JSON)' do
+        @fei = engine.process(@wfid).expressions.last.fei
+      end
 
-      get "/_ruote/workitems/#{@fei.sid}.json"
+      it 'returns it (HTML)' do
 
-      last_response.json_body['workitem']['links'].collect { |li|
-        li['rel']
-      }.should == %w[
-        self
-        http://ruote.rubyforge.org/rels.html#process
-        http://ruote.rubyforge.org/rels.html#process_expressions
-        http://ruote.rubyforge.org/rels.html#process_errors
-      ]
-    end
+        get "/_ruote/workitems/#{@fei.sid}"
 
-    it 'should include an etag header (HTML)' do
+        last_response.should be_ok
+      end
 
-      get "/_ruote/workitems/#{@fei.sid}"
+      it 'returns it (JSON)' do
 
-      last_response.headers.should include('ETag')
-      last_response.headers['ETag'].should == "\"#{find_workitem(@wfid, @nada_exp_id).to_h['_rev'].to_s}\""
-    end
+        get "/_ruote/workitems/#{@fei.sid}.json"
 
-    it 'should include an etag header (JSON)' do
+        last_response.should be_ok
+      end
 
-      get "/_ruote/workitems/#{@fei.sid}.json"
+      it 'provides a workitem with the correct links (JSON)' do
+
+        get "/_ruote/workitems/#{@fei.sid}.json"
+
+        last_response.json_body['workitem']['links'].collect { |li|
+          li['rel']
+        }.should == %w[
+          self
+          http://ruote.rubyforge.org/rels.html#process
+          http://ruote.rubyforge.org/rels.html#expression
+          http://ruote.rubyforge.org/rels.html#process_expressions
+          http://ruote.rubyforge.org/rels.html#process_errors
+        ]
+
+        link_for(
+          last_response.json_body['workitem']['links'], 'self'
+        ).should ==
+          "/_ruote/workitems/#{@fei.sid}"
+
+        link_for(
+          last_response.json_body['workitem']['links'], '#expression'
+        ).should ==
+          "/_ruote/expressions/#{@fei.sid}"
+
+        link_for(
+          last_response.json_body['workitem']['links'], '#process_expressions'
+        ).should ==
+          "/_ruote/expressions/#{@fei.wfid}"
+      end
 
-      last_response.headers.should include('ETag')
-      last_response.headers['ETag'].should == "\"#{find_workitem(@wfid, @nada_exp_id).to_h['_rev'].to_s}\""
-    end
-  end
+      it 'includes an etag header (HTML)' do
 
-  describe 'without a workitem' do
+        get "/_ruote/workitems/#{@fei.sid}"
 
-    it 'should return a 404 (HTML)' do
+        last_response.headers.should include('ETag')
+        last_response.headers['ETag'].should == "\"#{find_workitem(@wfid, @nada_exp_id).to_h['_rev'].to_s}\""
+      end
 
-      get '/_ruote/workitems/foo/bar'
+      it 'includes an etag header (JSON)' do
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
-    end
+        get "/_ruote/workitems/#{@fei.sid}.json"
 
-    it 'should return a 404 (JSON)' do
+        last_response.headers.should include('ETag')
+        last_response.headers['ETag'].should == "\"#{find_workitem(@wfid, @nada_exp_id).to_h['_rev'].to_s}\""
+      end
+
+      it 'includes a wf_name and a wf_revision (JSON)' do
 
-      get '/_ruote/workitems/foo/bar.json'
+        get "/_ruote/workitems/#{@fei.sid}.json"
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
+        last_response.json_body['workitem']['wf_name'].should_not == nil
+        last_response.json_body['workitem']['wf_revision'].should_not == nil
+      end
     end
-  end
-end
 
-describe 'PUT /_ruote/workitems/fei' do
+    context 'without a workitem' do
 
-  before(:each) do
+      it 'returns a 404 (HTML)' do
 
-    prepare_engine_with_participants
+        get '/_ruote/workitems/foo/bar'
 
-    @wfid = RuoteKit.engine.launch(Ruote.process_definition do
-      sequence do
-        nada :activity => 'Work your magic'
-        echo '${f:foo}'
+        last_response.should_not be_ok
+        last_response.status.should be(404)
       end
-    end)
 
-    RuoteKit.engine.wait_for(:nada)
+      it 'returns a 404 (JSON)' do
 
-    @fei = engine.process(@wfid).expressions.last.fei
+        get '/_ruote/workitems/foo/bar.json'
 
-    @fields = {
-      'params' => { 'activity' => 'Work your magic' }, 'foo' => 'bar'
-    }
-  end
-
-  after(:each) do
-
-    shutdown_and_purge_engine
+        last_response.should_not be_ok
+        last_response.status.should be(404)
+      end
+    end
   end
 
-  it 'should update the workitem fields (HTML)' do
+  describe 'PUT /_ruote/workitems/:fei' do
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
-      :fields => Rufus::Json.encode(@fields))
+    before(:each) do
 
-    last_response.should be_redirect
+      register_participants
 
-    last_response['Location'].should ==
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}"
+      @wfid = RuoteKit.engine.launch(Ruote.process_definition do
+        sequence do
+          nada :activity => 'Work your magic'
+          echo '${f:foo}'
+        end
+      end)
 
-    find_workitem(@wfid, @nada_exp_id).fields.should == @fields
+      RuoteKit.engine.wait_for(:nada)
 
-    sleep 0.4
+      @fei = engine.process(@wfid).expressions.last.fei
 
-    @tracer.to_s.should == ''
-  end
+      @fields = {
+        'params' => { 'activity' => 'Work your magic' }, 'foo' => 'bar'
+      }
+    end
 
-  it 'should update the workitem fields (JSON)' do
+    it 'updates the workitem fields (HTML)' do
 
-    params = { 'fields' => @fields }
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
+        :fields => Rufus::Json.encode(@fields))
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-      Rufus::Json.encode(params),
-      { 'CONTENT_TYPE' => 'application/json' })
+      last_response.should be_redirect
 
-    last_response.should be_ok
+      last_response['Location'].should ==
+        "http://example.org/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}"
 
-    find_workitem(@wfid, @nada_exp_id).fields.should == @fields
+      find_workitem(@wfid, @nada_exp_id).fields.should == @fields
 
-    sleep 0.4
+      sleep 0.4
 
-    @tracer.to_s.should == ''
-  end
+      @tracer.to_s.should == ''
+    end
 
-  it 'should update the fields when passed {"workitem":...} (JSON)' do
+    it 'updates the workitem fields (JSON)' do
 
-    params = { 'workitem' => { 'fields' => @fields } }
+      params = { 'fields' => @fields }
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-      Rufus::Json.encode(params),
-      { 'CONTENT_TYPE' => 'application/json' })
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+        Rufus::Json.encode(params),
+        { 'CONTENT_TYPE' => 'application/json' })
 
-    last_response.should be_ok
+      last_response.should be_ok
 
-    find_workitem(@wfid, @nada_exp_id).fields.should == @fields
-  end
+      find_workitem(@wfid, @nada_exp_id).fields.should == @fields
 
-  it 'should reply to the engine (HTML)' do
+      sleep 0.4
 
-    fields = Rufus::Json.encode(@fields)
+      @tracer.to_s.should == ''
+    end
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
-      :fields => fields,
-      :_proceed => '1')
+    it 'updates the fields when passed {"workitem":...} (JSON)' do
 
-    last_response.should be_redirect
-    last_response['Location'].should == "/_ruote/workitems/#{@wfid}"
+      params = { 'workitem' => { 'fields' => @fields } }
 
-    #engine.context[:s_logger].wait_for([
-    #  [ :processes, :terminated, { :wfid => @wfid } ],
-    #  [ :errors, nil, { :wfid => @wfid } ]
-    #])
-    sleep 0.5
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+        Rufus::Json.encode(params),
+        { 'CONTENT_TYPE' => 'application/json' })
 
-    @tracer.to_s.should == 'bar'
-  end
+      last_response.should be_ok
 
-  it 'should reply to the engine (JSON)' do
+      find_workitem(@wfid, @nada_exp_id).fields.should == @fields
+    end
 
-    params = { 'fields' => @fields, '_proceed' => '1' }
+    it 'replies to the engine (HTML)' do
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-      Rufus::Json.encode(params),
-      { 'CONTENT_TYPE' => 'application/json' })
+      fields = Rufus::Json.encode(@fields)
 
-    last_response.should be_ok
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
+        :fields => fields,
+        :_proceed => '1')
 
-    #engine.context[:s_logger].wait_for([
-    #  [ :processes, :terminated, { :wfid => @wfid } ],
-    #  [ :errors, nil, { :wfid => @wfid } ]
-    #])
-    sleep 0.5
+      last_response.should be_redirect
+      last_response['Location'].should == "http://example.org/_ruote/workitems/#{@wfid}"
 
-    @tracer.to_s.should == 'bar'
-  end
+      #engine.context[:s_logger].wait_for([
+      #  [ :processes, :terminated, { :wfid => @wfid } ],
+      #  [ :errors, nil, { :wfid => @wfid } ]
+      #])
+      sleep 0.5
 
-  it 'should 400 when passed bogus JSON fields (HTML)' do
+      @tracer.to_s.should == 'bar'
+    end
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-      :fields => '{"bogus"}')
+    it 'replies to the engine (JSON)' do
 
-    last_response.status.should be(400)
-  end
+      params = { 'fields' => @fields, '_proceed' => '1' }
 
-  it 'should 400 when passed bogus JSON fields (JSON)' do
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+        Rufus::Json.encode(params),
+        { 'CONTENT_TYPE' => 'application/json' })
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-      "{'bogus'}",
-      { 'CONTENT_TYPE' => 'application/json' })
+      last_response.should be_ok
 
-    last_response.status.should be(400)
-  end
+      #engine.context[:s_logger].wait_for([
+      #  [ :processes, :terminated, { :wfid => @wfid } ],
+      #  [ :errors, nil, { :wfid => @wfid } ]
+      #])
+      sleep 0.5
 
-  it 'should 412 if the etags do not match (HTML)' do
+      @tracer.to_s.should == 'bar'
+    end
 
-    workitem = find_workitem(@wfid, @nada_exp_id)
-    old_rev  = workitem.to_h['_rev']
+    it 'goes 400 when passed bogus JSON fields (HTML)' do
 
-    workitem.fields = {'baz' => 'bar'}.merge!(@fields)
-    RuoteKit.engine.storage_participant.update(workitem)
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+        :fields => '{"bogus"}')
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
-      { :fields => Rufus::Json.encode(@fields) },
-      { 'HTTP_IF_MATCH' => ('"%s"' % old_rev) }
-    )
+      last_response.status.should be(400)
+    end
 
-    last_response.status.should be(412)
-  end
+    it 'goes 400 when passed bogus JSON fields (JSON)' do
 
-  it 'should 412 if the etags do not match (JSON)' do
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+        "{'bogus'}",
+        { 'CONTENT_TYPE' => 'application/json' })
 
-    workitem = find_workitem(@wfid, @nada_exp_id)
+      last_response.status.should be(400)
+    end
 
-    old_rev = workitem.to_h['_rev']
+    it 'goes 412 if the etags do not match (HTML)' do
 
-    workitem.fields = {'baz' => 'bar'}.merge!(@fields)
-    RuoteKit.engine.storage_participant.update(workitem)
+      workitem = find_workitem(@wfid, @nada_exp_id)
+      old_rev  = workitem.to_h['_rev']
 
-    params = { 'workitem' => { 'fields' => @fields } }
+      workitem.fields = {'baz' => 'bar'}.merge!(@fields)
+      RuoteKit.engine.storage_participant.update(workitem)
 
-    put(
-      "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-      Rufus::Json.encode(params),
-      {
-        'CONTENT_TYPE'  => 'application/json',
-        'HTTP_IF_MATCH' => ('"%s"' % old_rev)
-      }
-    )
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
+        { :fields => Rufus::Json.encode(@fields) },
+        { 'HTTP_IF_MATCH' => ('"%s"' % old_rev) }
+      )
 
-    last_response.status.should be(412)
-  end
-end
+      last_response.status.should be(412)
+    end
 
-describe 'Filtering workitems' do
+    it 'goes 412 if the etags do not match (JSON)' do
 
-  before(:each) do
+      workitem = find_workitem(@wfid, @nada_exp_id)
 
-    prepare_engine_with_participants
+      old_rev = workitem.to_h['_rev']
 
-    @wfid = RuoteKit.engine.launch(Ruote.process_definition do
-      set 'foo' => 'bar'
-      concurrence do
-        sequence do
-          set 'wands' => 101
-          set 'hinkypinky' => 'honkytonky'
-          jack :activity => 'Fetch a pale'
-        end
-        sequence do
-          set 'hinkypinky' => 'honkytonky'
-          jill :activity => 'Chase Jack'
-        end
-        well :activity => 'Ready water'
-      end
-    end)
+      workitem.fields = {'baz' => 'bar'}.merge!(@fields)
+      RuoteKit.engine.storage_participant.update(workitem)
 
-    RuoteKit.engine.wait_for(:jack)
-    RuoteKit.engine.wait_for(1)
-  end
+      params = { 'workitem' => { 'fields' => @fields } }
 
-  after(:each) do
+      put(
+        "/_ruote/workitems/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+        Rufus::Json.encode(params),
+        {
+          'CONTENT_TYPE'  => 'application/json',
+          'HTTP_IF_MATCH' => ('"%s"' % old_rev)
+        }
+      )
 
-    shutdown_and_purge_engine
+      last_response.status.should be(412)
+    end
   end
 
-  describe 'on participants' do
+  describe 'Filtering workitems' do
 
-    it 'should narrow results down to a single participant (JSON)' do
+    before(:each) do
 
-      get '/_ruote/workitems.json', :participant => 'jack'
+      register_participants
 
-      last_response.should be_ok
+      @wfid = RuoteKit.engine.launch(Ruote.process_definition do
+        set 'foo' => 'bar'
+        concurrence do
+          sequence do
+            set 'wands' => 101
+            set 'hinkypinky' => 'honkytonky'
+            jack :activity => 'Fetch a pale'
+          end
+          sequence do
+            set 'hinkypinky' => 'honkytonky'
+            jill :activity => 'Chase Jack'
+          end
+          well :activity => 'Ready water'
+        end
+      end)
 
-      last_response.json_body['workitems'].size.should == 1
+      RuoteKit.engine.wait_for(:jack)
+      RuoteKit.engine.wait_for(1)
     end
 
-    it 'should narrow results down to a single participant (HTML)' do
+    context 'on participants' do
 
-      get '/_ruote/workitems', :participant => 'jack'
+      it 'narrows results down to a single participant (JSON)' do
 
-      last_response.should be_ok
+        get '/_ruote/workitems.json', :participant => 'jack'
 
-      last_response.should match(workitem_count(1, 3, 3))
-    end
+        last_response.should be_ok
+        last_response.json_body['workitems'].size.should == 1
+      end
 
-  end
+      it 'narrows results down to a single participant (HTML)' do
 
-  describe 'on field values' do
+        get '/_ruote/workitems', :participant => 'jack'
 
-    it 'should find workitems with fields set to a given value (JSON)' do
+        last_response.should be_ok
+        last_response.should match(workitem_count(1, 3, 3))
+      end
 
-      get '/_ruote/workitems.json', :hinkypinky => 'honkytonky'
+    end
 
-      last_response.should be_ok
+    context 'on field values' do
 
-      last_response.json_body['workitems'].size.should == 2
-    end
+      it 'finds workitems with fields set to a given value (JSON)' do
 
-    it 'should find workitems with fields set to a given value (HTML)' do
+        get '/_ruote/workitems.json', :hinkypinky => 'honkytonky'
 
-      get '/_ruote/workitems', :hinkypinky => 'honkytonky'
+        last_response.should be_ok
+        last_response.json_body['workitems'].size.should == 2
+      end
 
-      last_response.should be_ok
-    end
+      it 'finds workitems with fields set to a given value (HTML)' do
 
-    it 'should respect JSON encoded filter vars (JSON)' do
+        get '/_ruote/workitems', :hinkypinky => 'honkytonky'
 
-      get '/_ruote/workitems.json', :wands => 101
+        last_response.should be_ok
+      end
 
-      last_response.should be_ok
+      it 'respects JSON encoded filter vars (JSON)' do
 
-      last_response.json_body['workitems'].size.should == 1
-    end
+        get '/_ruote/workitems.json', :wands => 101
 
-    it 'should respect JSON encoded filter vars (HTML)' do
+        last_response.should be_ok
+        last_response.json_body['workitems'].size.should == 1
+      end
 
-      get '/_ruote/workitems', :wands => 101
+      it 'respects JSON encoded filter vars (HTML)' do
 
-      last_response.should be_ok
-    end
+        get '/_ruote/workitems', :wands => 101
 
-    it "should combine search criteria by 'and' (JSON)" do
+        last_response.should be_ok
+      end
 
-      get '/_ruote/workitems.json', :hinkypinky => 'honkytonky', :wands => 101
+      it "should combine search criteria by 'and' (JSON)" do
 
-      last_response.should be_ok
+        get '/_ruote/workitems.json', :hinkypinky => 'honkytonky', :wands => 101
 
-      last_response.json_body['workitems'].size.should == 1
-    end
+        last_response.should be_ok
+        last_response.json_body['workitems'].size.should == 1
+      end
 
-    it "should combine search criteria by 'and' (HMTL)" do
+      it "should combine search criteria by 'and' (HMTL)" do
 
-      get '/_ruote/workitems', :hinkypinky => 'honkytonky', :wands => 101
+        get '/_ruote/workitems', :hinkypinky => 'honkytonky', :wands => 101
 
-      last_response.should be_ok
+        last_response.should be_ok
+      end
     end
   end
 end