ruote-kit 2.2.0.3 → 2.3.0.2

data/spec/resources/expressions_spec.rb

@@ -1,605 +1,723 @@
 
-require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'spec_helper'
 
 
-describe 'GET /_ruote/expressions' do
+describe '/_ruote/expressions' do
 
   before(:each) do
-
-    prepare_engine
+    prepare_engine_with_participants
   end
-
   after(:each) do
-
     shutdown_and_purge_engine
   end
 
-  it 'should 404 (HTML)' do
+  describe 'GET /_ruote/expressions' do
+
+    it 'goes 404 (HTML)' do
 
-    get '/_ruote/expressions'
+      get '/_ruote/expressions'
 
-    last_response.status.should be(404)
+      last_response.status.should be(404)
+    end
   end
-end
 
-describe 'GET /_ruote/expressions/wfid' do
+  describe 'GET /_ruote/expressions/:wfid' do
 
-  before(:each) do
+    context 'with running processes' do
 
-    prepare_engine_with_participants
-  end
+      before(:each) do
+        @wfid = launch_nada_process
+      end
 
-  after(:each) do
+      it 'renders the expressions (HTML)' do
 
-    shutdown_and_purge_engine
-  end
+        get "/_ruote/expressions/#{@wfid}"
 
-  describe 'with running processes' do
+        last_response.should be_ok
+      end
 
-    before(:each) do
-      @wfid = launch_nada_process
-    end
+      it 'renders the expressions (JSON)' do
 
-    it 'should render the expressions (HTML)' do
+        get "/_ruote/expressions/#{@wfid}.json"
 
-      get "/_ruote/expressions/#{@wfid}"
+        last_response.should be_ok
 
-      last_response.should be_ok
+        last_response.json_body['expressions'].first.keys.sort.should == %w[
+          class fei links name parent state
+        ]
+      end
     end
 
-    it 'should render the expressions (JSON)' do
+    context 'without running processes' do
+
+      it 'goes 404 correctly (HTML)' do
+
+        get "/_ruote/expressions/foo"
+
+        last_response.should_not be_ok
+        last_response.status.should be(404)
+      end
 
-      get "/_ruote/expressions/#{@wfid}.json"
+      it 'goes 404 correctly (JSON)' do
 
-      last_response.should be_ok
+        get '/_ruote/expressions/foo.json'
 
-      last_response.json_body['expressions'].first.keys.sort.should == %w[
-        class fei links name parent
-      ]
+        last_response.should_not be_ok
+        last_response.status.should be(404)
+      end
     end
   end
 
-  describe 'without running processes' do
+  describe 'GET /_ruote/expressions/:fei' do
 
-    it 'should 404 correctly (HTML)' do
+    context 'with running processes' do
 
-      get "/_ruote/expressions/foo"
+      before(:each) do
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
-    end
+        @wfid = launch_nada_process
+        @nada_fexp = RuoteKit.engine.process(@wfid).expressions.last
+        @nada_fei = @nada_fexp.fei
+      end
 
-    it 'should 404 correctly (JSON)' do
+      it 'renders the expression (HTML)' do
 
-      get '/_ruote/expressions/foo.json'
+        get "/_ruote/expressions/#{@nada_fei.sid}"
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
-    end
-  end
-end
+        last_response.status.should ==
+          200
+        last_response.should have_selector(
+          'input[name="_method"][type="hidden"][value="DELETE"]')
+        last_response.should have_selector(
+          'input[type="submit"][value="pause"]')
+      end
 
-describe 'GET /_ruote/expressions/fei' do
+      it 'renders the expression (JSON)' do
 
-  before(:each) do
+        get "/_ruote/expressions/#{@nada_fei.sid}.json"
 
-    prepare_engine_with_participants
-  end
+        last_response.should be_ok
 
-  after(:each) do
+        #puts Rufus::Json.pretty_encode(last_response.json_body)
 
-    shutdown_and_purge_engine
-  end
+        last_response.json_body['expression']['links'].size.should == 4
 
-  describe 'with running processes' do
+        last_response.json_body['expression'].keys.sort.should == %w[
+          applied_workitem class fei links name original_tree parent state
+          timeout_schedule_id tree variables
+        ]
+      end
 
-    before(:each) do
+      it 'includes an etag header (HTML)' do
 
-      @wfid = launch_nada_process
-      @nada_fexp = RuoteKit.engine.process(@wfid).expressions.last
-      @nada_fei = @nada_fexp.fei
-    end
+        get "/_ruote/expressions/#{@nada_fei.sid}"
+
+        last_response.headers.should include('ETag')
+
+        last_response.headers['ETag'].should ==
+          "\"#{@nada_fexp.to_h['_rev'].to_s}\""
+      end
+
+      it 'includes an etag header (JSON)' do
 
-    it 'should render the expression (HTML)' do
+        get "/_ruote/expressions/#{@nada_fei.sid}.json"
 
-      get "/_ruote/expressions/#{@nada_fei.sid}"
+        last_response.headers.should include('ETag')
 
-      last_response.should be_ok
+        last_response.headers['ETag'].should ==
+          "\"#{@nada_fexp.to_h['_rev'].to_s}\""
+      end
     end
 
-    it 'should render the expression (JSON)' do
+    context 'without running processes' do
+
+      it 'goes 404 correctly (HTML)' do
 
-      get "/_ruote/expressions/#{@nada_fei.sid}.json"
+        get '/workitems/foo/bar'
 
-      last_response.should be_ok
+        last_response.should_not be_ok
+        last_response.status.should be(404)
+      end
 
-      #puts Rufus::Json.pretty_encode(last_response.json_body)
+      it 'goes 404 correctly (JSON)' do
 
-      last_response.json_body['expression']['links'].size.should == 4
+        get '/workitems/foo/bar.json'
 
-      last_response.json_body['expression'].keys.sort.should == %w[
-        applied_workitem class fei links name original_tree parent
-        timeout_schedule_id tree variables
-      ]
+        last_response.should_not be_ok
+        last_response.status.should be(404)
+      end
     end
 
-    it 'should include an etag header (HTML)' do
+    context 'with an expression that has a schedule' do
 
-      get "/_ruote/expressions/#{@nada_fei.sid}"
+      before(:each) do
 
-      last_response.headers.should include('ETag')
+        @wfid = RuoteKit.engine.launch(Ruote.define do
+          alpha :timeout => '2y'
+        end)
 
-      last_response.headers['ETag'].should ==
-        "\"#{@nada_fexp.to_h['_rev'].to_s}\""
-    end
+        RuoteKit.engine.wait_for(:alpha)
+
+        @fei = RuoteKit.engine.process(@wfid).expressions.last.fei
+      end
+
+      it 'renders the expression (HTML)' do
+
+        get "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}"
+
+        last_response.status.should be(200)
+
+        last_response.should have_selector(
+          'table.details tr td', :content => 'timeout')
+      end
+
+      it 'renders the expression (JSON)' do
 
-    it 'should include an etag header (JSON)' do
+        get "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json"
 
-      get "/_ruote/expressions/#{@nada_fei.sid}.json"
+        last_response.status.should be(200)
 
-      last_response.headers.should include('ETag')
+        #puts Rufus::Json.pretty_encode(last_response.json_body)
 
-      last_response.headers['ETag'].should ==
-        "\"#{@nada_fexp.to_h['_rev'].to_s}\""
+        last_response.json_body['expression'].keys.should include(
+          'timeout_schedule_id')
+      end
     end
   end
 
-  describe 'without running processes' do
+  describe 'DELETE /_ruote/expressions/:fei' do
 
-    it 'should 404 correctly (HTML)' do
+    context 'with running processes' do
 
-      get '/workitems/foo/bar'
+      before(:each) do
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
-    end
+        @wfid = RuoteKit.engine.launch(Ruote.process_definition do
+          sequence do
+            alfred :on_cancel => 'bail_out'
+            echo 'done'
+          end
 
-    it 'should 404 correctly (JSON)' do
+          define 'bail_out' do
+            echo 'bailed'
+          end
+        end)
 
-      get '/workitems/foo/bar.json'
+        RuoteKit.engine.wait_for(:alfred)
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
-    end
-  end
+        @fei = engine.process(@wfid).expressions.last.fei
+      end
 
-  describe 'with an expression that has a schedule' do
+      it 'cancels the expressions (HTML)' do
 
-    before(:each) do
+        delete "/_ruote/expressions/#{@fei.sid}"
 
-      register_participants
+        last_response.should be_redirect
+        last_response['Location'].should == "http://example.org/_ruote/expressions/#{@wfid}"
 
-      @wfid = RuoteKit.engine.launch(Ruote.define do
-        alpha :timeout => '2y'
-      end)
+        wait_for(@wfid)
 
-      RuoteKit.engine.wait_for(:alpha)
+        @tracer.to_s.should == "bailed\ndone"
+      end
 
-      @fei = RuoteKit.engine.process(@wfid).expressions.last.fei
-    end
+      it 'cancels the expressions (JSON)' do
 
-    it 'should render the expression (HTML)' do
+        delete "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json"
 
-      get "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}"
+        last_response.should be_ok
+        last_response.json_body['status'].should == 'ok'
 
-      last_response.status.should be(200)
+        wait_for(@wfid)
 
-      last_response.should have_selector(
-        'table.details tr td', :content => 'timeout')
-    end
+        @tracer.to_s.should == "bailed\ndone"
+      end
+
+      it 'kills the expression (HTML)' do
+
+        delete "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}?_kill=1"
+
+        last_response.should be_redirect
+        last_response['Location'].should == "http://example.org/_ruote/expressions/#{@wfid}"
+
+        wait_for(@wfid)
+
+        @tracer.to_s.should == 'done'
+      end
+
+      it 'kills the expression (JSON)' do
+
+        delete "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json?_kill=1"
+
+        last_response.should be_ok
+        last_response.json_body['status'].should == 'ok'
+
+        wait_for(@wfid)
+
+        @tracer.to_s.should == 'done'
+      end
+
+      it 'goes 412 when the etags do not match (HTML)' do
+
+        delete(
+          "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
+          nil,
+          { 'HTTP_IF_MATCH' => '"foo"' }
+        )
+
+        last_response.status.should == 412
+      end
+
+      it 'goes 412 when the etags do not match (JSON)' do
+
+        delete(
+          "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+          nil,
+          {
+            'HTTP_IF_MATCH' => '"foo"',
+            'CONTENT_TYPE'  => 'application/json',
+          }
+        )
 
-    it 'should render the expression (JSON)' do
+        last_response.status.should == 412
+      end
+
+      it 'does not go 412 when the etags do match (HTML)' do
+
+        exp = RuoteKit.engine.process(@wfid).expressions.find { |e|
+          e.fei.expid == @fei.expid
+        }
+
+        delete(
+          "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
+          nil,
+          { 'HTTP_IF_MATCH' => ('"%s"' % exp.to_h['_rev'] ) }
+        )
+
+        last_response.status.should_not == 412
+      end
 
-      get "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json"
+      it 'does not go 412 when the etags do match (JSON)' do
 
-      last_response.status.should be(200)
+        exp = RuoteKit.engine.process(@wfid).expressions.find { |e|
+          e.fei.expid == @fei.expid
+        }
 
-      #puts Rufus::Json.pretty_encode(last_response.json_body)
+        delete(
+          "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
+          nil,
+          {
+            'HTTP_IF_MATCH' => ('"%s"' % exp.to_h['_rev'] ),
+            'CONTENT_TYPE'  => 'application/json',
+          }
+        )
 
-      last_response.json_body['expression'].keys.should include(
-        'timeout_schedule_id')
+        last_response.status.should_not == 412
+      end
     end
-  end
-end
 
-describe 'DELETE /_ruote/expressions/fei' do
+    context 'without running processes' do
 
-  before(:each) do
+      it 'goes 404 correctly (HTML)' do
 
-    prepare_engine_with_participants
-  end
+        delete '/_ruote/expressions/foo/bar'
 
-  after(:each) do
+        last_response.should_not be_ok
+        last_response.status.should be(404)
+      end
 
-    shutdown_and_purge_engine
+      it 'goes 404 correctly (JSON)' do
+
+        delete '/_ruote/expressions/foo/bar.json'
+
+        last_response.should_not be_ok
+        last_response.status.should be(404)
+      end
+    end
   end
 
-  describe 'with running processes' do
+  describe 'PUT /_ruote/expressions/:fei' do
 
     before(:each) do
 
-      @wfid = RuoteKit.engine.launch(Ruote.process_definition do
-        sequence do
-          alfred :on_cancel => 'bail_out'
-          echo 'done'
-        end
+      @wfid = RuoteKit.engine.launch(
 
-        define 'bail_out' do
-          echo 'bailed'
+        Ruote.process_definition do
+          alpha
         end
-      end)
+      )
 
-      RuoteKit.engine.wait_for(:alfred)
+      RuoteKit.engine.wait_for(:alpha)
+      RuoteKit.engine.wait_for(1)
 
-      @fei = engine.process(@wfid).expressions.last.fei
+      @exp = RuoteKit.engine.process(@wfid).expressions.last
     end
 
-    it 'should cancel the expressions (HTML)' do
+    context 're_apply' do
 
-      delete "/_ruote/expressions/#{@fei.sid}"
+      it 're-applies (HTML)' do
 
-      last_response.should be_redirect
-      last_response['Location'].should == "/_ruote/expressions/#{@wfid}"
+        at0 = RuoteKit.engine.storage_participant.first.dispatched_at
 
-      wait_for(@wfid)
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          :fields => '{}')
 
-      @tracer.to_s.should == "bailed\ndone"
-    end
+        last_response.status.should be(302)
+        last_response.location.should == "http://example.org/_ruote/expressions/#{@wfid}"
 
-    it 'should cancel the expressions (JSON)' do
+        #RuoteKit.engine.wait_for(:alpha)
+        sleep 0.500
 
-      delete "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json"
+        at1 = RuoteKit.engine.storage_participant.first.dispatched_at
 
-      last_response.should be_ok
-      last_response.json_body['status'].should == 'ok'
+        at1.should_not == at0
+      end
 
-      wait_for(@wfid)
+      it 're-applies (JSON)' do
 
-      @tracer.to_s.should == "bailed\ndone"
-    end
+        #RuoteKit.engine.noisy = true
 
-    it 'should kill the expression (HTML)' do
+        at0 = RuoteKit.engine.storage_participant.first.dispatched_at
 
-      delete "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}?_kill=1"
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}.json",
+          Rufus::Json.encode({}),
+          { 'CONTENT_TYPE' => 'application/json' })
 
-      last_response.should be_redirect
-      last_response['Location'].should == "/_ruote/expressions/#{@wfid}"
+        last_response.status.should be(200)
 
-      #sleep 0.4
-      wait_for(@wfid)
+        #RuoteKit.engine.wait_for(:alpha)
+        sleep 0.500
 
-      @tracer.to_s.should == 'done'
-    end
+        at1 = RuoteKit.engine.storage_participant.first.dispatched_at
 
-    it 'should kill the expression (JSON)' do
+        at1.should_not == at0
+      end
 
-      delete "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json?_kill=1"
+      it 're-applies with different fields (HTML)' do
 
-      last_response.should be_ok
-      last_response.json_body['status'].should == 'ok'
+        wi = RuoteKit.engine.storage_participant.first
+        wi.fields['car'].should be(nil)
 
-      #sleep 0.4
-      wait_for(@wfid)
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          :fields => '{"car":"daimler-benz"}')
 
-      @tracer.to_s.should == 'done'
-    end
+        last_response.status.should be(302)
+        last_response.location.should == "http://example.org/_ruote/expressions/#{@wfid}"
 
-    it 'should 412 when the etags do not match (HTML)' do
+        #RuoteKit.engine.wait_for(:alpha)
+        sleep 0.500
 
-      delete(
-        "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
-        nil,
-        { 'HTTP_IF_MATCH' => '"foo"' }
-      )
+        wi = RuoteKit.engine.storage_participant.first
 
-      last_response.status.should == 412
-    end
+        wi.fields['car'].should == 'daimler-benz'
+      end
 
-    it 'should 412 when the etags do not match (JSON)' do
+      it 're-applies with different fields (JSON)' do
 
-      delete(
-        "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-        nil,
-        {
-          'HTTP_IF_MATCH' => '"foo"',
-          'CONTENT_TYPE'  => 'application/json',
-        }
-      )
+        wi = RuoteKit.engine.storage_participant.first
+        wi.fields['car'].should be(nil)
 
-      last_response.status.should == 412
-    end
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}.json",
+          Rufus::Json.encode({ 'fields' => { 'car' => 'bentley' } }),
+          { 'CONTENT_TYPE' => 'application/json' })
 
-    it 'should not 412 when the etags do match (HTML)' do
-      exp = RuoteKit.engine.process(@wfid).expressions.find { |e|
-        e.fei.expid == @fei.expid
-      }
+        last_response.status.should be(200)
 
-      delete(
-        "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}",
-        nil,
-        { 'HTTP_IF_MATCH' => ('"%s"' % exp.to_h['_rev'] ) }
-      )
+        #RuoteKit.engine.wait_for(:alpha)
+        sleep 0.500
 
-      last_response.status.should_not == 412
-    end
+        wi = RuoteKit.engine.storage_participant.first
 
-    it 'should not 412 when the etags do match (JSON)' do
-      exp = RuoteKit.engine.process(@wfid).expressions.find { |e|
-        e.fei.expid == @fei.expid
-      }
-
-      delete(
-        "/_ruote/expressions/#{@fei.expid}!#{@fei.subid}!#{@wfid}.json",
-        nil,
-        {
-          'HTTP_IF_MATCH' => ('"%s"' % exp.to_h['_rev'] ),
-          'CONTENT_TYPE'  => 'application/json',
-        }
-      )
+        wi.fields['car'].should == 'bentley'
+      end
 
-      last_response.status.should_not == 412
-    end
-  end
+      it 're-applies when passed {"expression":{"fields":...}} (JSON)' do
 
-  describe 'without running processes' do
+        exp = { 'expression' => { 'fields' => { 'car' => 'BMW' } } }
 
-    it 'should 404 correctly (HTML)' do
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}.json",
+          Rufus::Json.encode(exp),
+          { 'CONTENT_TYPE' => 'application/json' })
 
-      delete '/_ruote/expressions/foo/bar'
+        last_response.status.should be(200)
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
-    end
+        #RuoteKit.engine.wait_for(:alpha)
+        sleep 0.500
 
-    it 'should 404 correctly (JSON)' do
+        wi = RuoteKit.engine.storage_participant.first
 
-      delete '/_ruote/expressions/foo/bar.json'
+        wi.fields['car'].should == 'BMW'
+      end
 
-      last_response.should_not be_ok
-      last_response.status.should be(404)
-    end
-  end
-end
+      it 're-applies with a different tree (HTML)' do
 
-describe 'PUT /_ruote/expressions/fei' do
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          :tree => '["charly", {}, []]')
 
-  before(:each) do
+        last_response.status.should be(302)
+        last_response.location.should == "http://example.org/_ruote/expressions/#{@wfid}"
 
-    prepare_engine_with_participants
+        #RuoteKit.engine.wait_for(:alpha)
+        sleep 0.500
+
+        wi = RuoteKit.engine.storage_participant.first
 
-    @wfid = RuoteKit.engine.launch(
+        wi.participant_name.should == 'charly'
 
-      Ruote.process_definition do
-        alpha
+        RuoteKit.engine.process(@wfid).current_tree.should == ['define', {}, [
+          [ 'participant', { '_triggered' => 'on_re_apply', 'ref' => 'charly' }, [] ] ] ]
       end
-    )
 
-    RuoteKit.engine.wait_for(:alpha)
-    RuoteKit.engine.wait_for(1)
+      it 're-applies with a different tree (JSON)' do
 
-    @exp = RuoteKit.engine.process(@wfid).expressions.last
-  end
+        wi = RuoteKit.engine.storage_participant.first
+        wi.participant_name.should == 'alpha'
 
-  after(:each) do
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}.json",
+          Rufus::Json.encode({ 'tree' => [ 'bravo', {}, [] ] }),
+          { 'CONTENT_TYPE' => 'application/json' })
 
-    shutdown_and_purge_engine
-  end
+        last_response.status.should be(200)
 
-  it 'should re-apply (HTML)' do
+        #RuoteKit.engine.wait_for(:alpha)
+        sleep 0.500
 
-    at0 = RuoteKit.engine.storage_participant.first.dispatched_at
+        wi = RuoteKit.engine.storage_participant.first
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      :fields => '{}')
+        wi.participant_name.should == 'bravo'
 
-    last_response.status.should be(302)
-    last_response.location.should == "/_ruote/expressions/#{@wfid}"
+        RuoteKit.engine.process(@wfid).current_tree.should == [ 'define', {}, [
+          [ 'participant', { '_triggered' => 'on_re_apply', 'ref' => 'bravo' }, [] ] ] ]
+      end
+    end
 
-    #RuoteKit.engine.wait_for(:alpha)
-    sleep 0.500
+    context 'pausing and resuming' do
 
-    at1 = RuoteKit.engine.storage_participant.first.dispatched_at
+      it 'pauses the expression (branch) (HTML)' do
 
-    at1.should_not == at0
-  end
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          :state => 'paused')
 
-  it 'should re-apply (JSON)' do
+        last_response.status.should ==
+          302
+        last_response.location.should ==
+          "http://example.org/_ruote/expressions/#{@exp.fei.sid}"
 
-    #RuoteKit.engine.noisy = true
+        sleep 0.500
 
-    at0 = RuoteKit.engine.storage_participant.first.dispatched_at
+        exp = RuoteKit.engine.ps(@wfid).expressions.last
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}.json",
-      Rufus::Json.encode({}),
-      { 'CONTENT_TYPE' => 'application/json' })
+        exp.state.should == 'paused'
+      end
 
-    last_response.status.should be(200)
+      it 'pauses the expression (branch) (JSON)' do
 
-    #RuoteKit.engine.wait_for(:alpha)
-    sleep 0.500
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}.json",
+          '{"state":"paused"}',
+          { 'CONTENT_TYPE' => 'application/json' })
 
-    at1 = RuoteKit.engine.storage_participant.first.dispatched_at
+        last_response.status.should ==
+          302
+        last_response.location.should ==
+          "http://example.org/_ruote/expressions/#{@exp.fei.sid}.json"
 
-    at1.should_not == at0
-  end
+        sleep 0.500
 
-  it 'should re-apply with different fields (HTML)' do
+        exp = RuoteKit.engine.ps(@wfid).expressions.last
 
-    wi = RuoteKit.engine.storage_participant.first
-    wi.fields['car'].should be(nil)
+        exp.state.should == 'paused'
+      end
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      :fields => '{"car":"daimler-benz"}')
+      it 'resumes the expression (branch) (HTML)' do
 
-    last_response.status.should be(302)
-    last_response.location.should == "/_ruote/expressions/#{@wfid}"
+        RuoteKit.engine.pause(@exp.fei)
 
-    #RuoteKit.engine.wait_for(:alpha)
-    sleep 0.500
+        sleep 0.500
 
-    wi = RuoteKit.engine.storage_participant.first
+        RuoteKit.engine.ps(@wfid).expressions[-1].state.should == 'paused'
 
-    wi.fields['car'].should == 'daimler-benz'
-  end
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          :state => 'resuming')
 
-  it 'should re-apply with different fields (JSON)' do
+        last_response.status.should ==
+          302
+        last_response.location.should ==
+          "http://example.org/_ruote/expressions/#{@exp.fei.sid}"
 
-    wi = RuoteKit.engine.storage_participant.first
-    wi.fields['car'].should be(nil)
+        sleep 0.500
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}.json",
-      Rufus::Json.encode({ 'fields' => { 'car' => 'bentley' } }),
-      { 'CONTENT_TYPE' => 'application/json' })
+        RuoteKit.engine.ps(@wfid).expressions[-1].state.should == nil
+      end
 
-    last_response.status.should be(200)
+      it 'resumes the expression (branch) (JSON)' do
 
-    #RuoteKit.engine.wait_for(:alpha)
-    sleep 0.500
+        RuoteKit.engine.pause(@exp.fei)
 
-    wi = RuoteKit.engine.storage_participant.first
+        sleep 0.500
 
-    wi.fields['car'].should == 'bentley'
-  end
+        RuoteKit.engine.ps(@wfid).expressions[-1].state.should == 'paused'
+
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}.json",
+          '{"state":"resuming"}',
+          { 'CONTENT_TYPE' => 'application/json' })
 
-  it 'should re-apply when passed {"expression":{"fields":...}} (JSON)' do
+        last_response.status.should ==
+          302
+        last_response.location.should ==
+          "http://example.org/_ruote/expressions/#{@exp.fei.sid}.json"
 
-    exp = { 'expression' => { 'fields' => { 'car' => 'BMW' } } }
+        sleep 0.500
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}.json",
-      Rufus::Json.encode(exp),
-      { 'CONTENT_TYPE' => 'application/json' })
+        RuoteKit.engine.ps(@wfid).expressions[-1].state.should == nil
+      end
+    end
 
-    last_response.status.should be(200)
+    context 'pausing as a breakpoint' do
 
-    #RuoteKit.engine.wait_for(:alpha)
-    sleep 0.500
+      before(:each) do
 
-    wi = RuoteKit.engine.storage_participant.first
+        @wfid = RuoteKit.engine.launch(Ruote.define do
+          sequence do
+            nada
+          end
+        end)
 
-    wi.fields['car'].should == 'BMW'
-  end
+        RuoteKit.engine.wait_for(:nada)
+        RuoteKit.engine.wait_for(1)
 
-  it 'should re-apply with a different tree (HTML)' do
+        @exp = RuoteKit.engine.ps(@wfid).expressions[-2]
+      end
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      :tree => '["charly", {}, []]')
+      it 'pauses the expression (breakpoint) (HTML)' do
 
-    last_response.status.should be(302)
-    last_response.location.should == "/_ruote/expressions/#{@wfid}"
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          :state => 'paused', :breakpoint => true)
 
-    #RuoteKit.engine.wait_for(:alpha)
-    sleep 0.500
+        last_response.status.should ==
+          302
+        last_response.location.should ==
+          "http://example.org/_ruote/expressions/#{@exp.fei.sid}"
 
-    wi = RuoteKit.engine.storage_participant.first
+        sleep 0.500
 
-    wi.participant_name.should == 'charly'
+        states = RuoteKit.engine.ps(@wfid).expressions.collect { |fexp|
+          [ fexp.fei.expid, fexp.state || 'running' ]
+        }.join(' ')
 
-    RuoteKit.engine.process(@wfid).current_tree.should == [ 'define', {}, [
-      [ 'participant', { '_triggered' => 'on_re_apply', 'ref' => 'charly' }, [] ] ] ]
-  end
+        states.should == '0 running 0_0 paused 0_0_0 running'
+      end
 
-  it 'should re-apply with a different tree (JSON)' do
+      it 'pauses the expression (breakpoint) (JSON)' do
 
-    wi = RuoteKit.engine.storage_participant.first
-    wi.participant_name.should == 'alpha'
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          Rufus::Json.dump({ 'state' => 'paused', 'breakpoint' => true }),
+          { 'CONTENT_TYPE' => 'application/json' })
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}.json",
-      Rufus::Json.encode({ 'tree' => [ 'bravo', {}, [] ] }),
-      { 'CONTENT_TYPE' => 'application/json' })
+        last_response.status.should ==
+          302
+        last_response.location.should ==
+          "http://example.org/_ruote/expressions/#{@exp.fei.sid}.json"
 
-    last_response.status.should be(200)
+        sleep 0.500
 
-    #RuoteKit.engine.wait_for(:alpha)
-    sleep 0.500
+        states = RuoteKit.engine.ps(@wfid).expressions.collect { |fexp|
+          [ fexp.fei.expid, fexp.state || 'running' ]
+        }.join(' ')
 
-    wi = RuoteKit.engine.storage_participant.first
+        states.should == '0 running 0_0 paused 0_0_0 running'
+      end
+    end
 
-    wi.participant_name.should == 'bravo'
+    context 'broken JSON' do
 
-    RuoteKit.engine.process(@wfid).current_tree.should == [ 'define', {}, [
-      [ 'participant', { '_triggered' => 'on_re_apply', 'ref' => 'bravo' }, [] ] ] ]
-  end
+      it 'goes 400 when passed broken JSON (HTML)' do
 
-  it 'should 400 when passed bogus JSON (HTML)' do
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          :fields => "{broken}")
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      :fields => "{bogus}")
+        last_response.status.should == 400
+      end
 
-    last_response.status.should == 400
-  end
+      it 'goes 400 when passed broken JSON (JSON)' do
 
-  it 'should 400 when passed bogus JSON (JSON)' do
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}.json",
+          '{"fields":{broken}}',
+          { 'CONTENT_TYPE' => 'application/json' })
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}.json",
-      '{"fields":{bogus}}',
-      { 'CONTENT_TYPE' => 'application/json' })
+        last_response.status.should be(400)
+        last_response.json_body['http_error']['code'].should == 400
+        last_response.json_body['http_error']['message'].should == 'bad request'
+      end
+    end
 
-    last_response.status.should be(400)
-    last_response.json_body['http_error']['code'].should == 400
-    last_response.json_body['http_error']['message'].should == 'bad request'
-  end
+    context 'with etags' do
 
-  it 'should 412 when the etags do not match (HTML)' do
+      it 'goes 412 when the etags do not match (HTML)' do
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      { :fields => '{}' },
-      { 'HTTP_IF_MATCH' => '"foo"' }
-    )
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          { :fields => '{}' },
+          { 'HTTP_IF_MATCH' => '"foo"' }
+        )
 
-    last_response.status.should == 412
-  end
+        last_response.status.should == 412
+      end
 
-  it 'should 412 when the etags do not match (JSON)' do
+      it 'goes 412 when the etags do not match (JSON)' do
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      Rufus::Json.encode({}),
-      {
-        'CONTENT_TYPE' => 'application/json',
-        'HTTP_IF_MATCH' => '"foo"'
-      }
-    )
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          Rufus::Json.encode({}),
+          {
+            'CONTENT_TYPE' => 'application/json',
+            'HTTP_IF_MATCH' => '"foo"'
+          }
+        )
 
-    last_response.status.should == 412
-  end
+        last_response.status.should == 412
+      end
 
-  it 'should not 412 when the etags match (HTML)' do
+      it 'does not go 412 when the etags match (HTML)' do
 
-    rev = @exp.to_h['_rev']
+        rev = @exp.to_h['_rev']
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      { :fields => '{}' },
-      { 'HTTP_IF_MATCH' => ('"%s"' % rev) }
-    )
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          { :fields => '{}' },
+          { 'HTTP_IF_MATCH' => ('"%s"' % rev) }
+        )
 
-    last_response.status.should_not == 412
-  end
+        last_response.status.should_not == 412
+      end
 
-  it 'should not 412 when the etags match (JSON)' do
+      it 'does not go 412 when the etags match (JSON)' do
 
-    rev = @exp.to_h['_rev']
+        rev = @exp.to_h['_rev']
 
-    put(
-      "/_ruote/expressions/#{@exp.fei.sid}",
-      Rufus::Json.encode({}),
-      {
-        'CONTENT_TYPE' => 'application/json',
-        'HTTP_IF_MATCH' => ('"%s"' % rev )
-      }
-    )
+        put(
+          "/_ruote/expressions/#{@exp.fei.sid}",
+          Rufus::Json.encode({}),
+          {
+            'CONTENT_TYPE' => 'application/json',
+            'HTTP_IF_MATCH' => ('"%s"' % rev )
+          }
+        )
 
-    last_response.status.should_not == 412
+        last_response.status.should_not == 412
+      end
+    end
   end
 end