ruote-kit 2.1.10 → 2.1.11

data/spec/resources/expressions_spec.rb

@@ -1,52 +1,63 @@
-require File.dirname(__FILE__) + '/../spec_helper'
 
-describe "GET /_ruote/expressions", :type => :with_engine do
+require 'spec_helper'
 
-  it "should report a friendly message to the user (HTML)" do
-    get "/_ruote/expressions"
+undef :context if defined?(context)
 
-    last_response.should be_ok
-  end
 
-  it "should report a friendly message to the client (JSON)" do
-    get "/_ruote/expressions.json"
+describe 'GET /_ruote/expressions' do
+
+  it_has_an_engine
 
-    last_response.should be_ok
+  it 'should 404 (HTML)' do
 
-    last_response.json_body['status'].should == 'ok'
+    get '/_ruote/expressions'
+
+    last_response.status.should be(404)
   end
 end
 
-describe "GET /_ruote/expressions/wfid", :type => :with_engine do
+describe 'GET /_ruote/expressions/wfid' do
+
+  it_has_an_engine
+
+  describe 'with running processes' do
 
-  describe "with running processes" do
     before(:each) do
       @wfid = launch_test_process
     end
 
-    it "should render the expression tree (HTML)" do
+    it 'should render the expressions (HTML)' do
+
       get "/_ruote/expressions/#{@wfid}"
 
       last_response.should be_ok
     end
 
-    it "should render the expression tree (JSON)" do
+    it 'should render the expressions (JSON)' do
+
       get "/_ruote/expressions/#{@wfid}.json"
 
       last_response.should be_ok
+
+      last_response.json_body['expressions'].first.keys.sort.should == %w[
+        class fei links name parent
+      ]
     end
   end
 
-  describe "without running processes" do
-    it "should 404 correctly (HTML)" do
+  describe 'without running processes' do
+
+    it 'should 404 correctly (HTML)' do
+
       get "/_ruote/expressions/foo"
 
       last_response.should_not be_ok
       last_response.status.should be(404)
     end
 
-    it "should 404 correctly (JSON)" do
-      get "/_ruote/expressions/foo.json"
+    it 'should 404 correctly (JSON)' do
+
+      get '/_ruote/expressions/foo.json'
 
       last_response.should_not be_ok
       last_response.status.should be(404)
@@ -54,49 +65,105 @@ describe "GET /_ruote/expressions/wfid", :type => :with_engine do
   end
 end
 
-describe "GET /_ruote/expressions/wfid/expid", :type => :with_engine do
+describe 'GET /_ruote/expressions/fei' do
+
+  it_has_an_engine
+
+  describe 'with running processes' do
 
-  describe "with running processes" do
     before(:each) do
+
       @wfid = launch_test_process
-      process = engine.process( @wfid )
+      process = engine.process(@wfid)
       @nada_exp_id = process.expressions.last.fei.expid
     end
 
-    it "should render the expression details (HTML)" do
-      get "/_ruote/expressions/#{@wfid}/#{@nada_exp_id}"
+    it 'should render the expression (HTML)' do
+
+      get "/_ruote/expressions/#{@nada_exp_id}!!#{@wfid}"
 
       last_response.should be_ok
     end
 
-    it "should render the expression details (JSON)" do
-      get "/_ruote/expressions/#{@wfid}/#{@nada_exp_id}.json"
+    it 'should render the expression (JSON)' do
+
+      get "/_ruote/expressions/#{@nada_exp_id}!!#{@wfid}.json"
 
       last_response.should be_ok
+
+      #puts Rufus::Json.pretty_encode(last_response.json_body)
+
+      last_response.json_body['expression']['links'].size.should be(4)
+
+      last_response.json_body['expression'].keys.sort.should == %w[
+        applied_workitem class fei links name original_tree parent
+        timeout_schedule_id tree variables
+      ]
     end
   end
 
-  describe "without running processes" do
-    it "should 404 correctly (HTML)" do
-      get "/workitems/foo/bar"
+  describe 'without running processes' do
+
+    it 'should 404 correctly (HTML)' do
+
+      get '/workitems/foo/bar'
 
       last_response.should_not be_ok
       last_response.status.should be(404)
     end
 
-    it "should 404 correctly (JSON)" do
-      get "/workitems/foo/bar.json"
+    it 'should 404 correctly (JSON)' do
+
+      get '/workitems/foo/bar.json'
 
       last_response.should_not be_ok
       last_response.status.should be(404)
     end
   end
+
+  describe 'with an expression that has a schedule' do
+
+    before(:each) do
+
+      @wfid = RuoteKit.engine.launch(Ruote.define do
+        alpha :timeout => '2y'
+      end)
+
+      RuoteKit.engine.wait_for(:alpha)
+    end
+
+    it 'should render the expression (HTML)' do
+
+      get "/_ruote/expressions/0_0!!#{@wfid}"
+
+      last_response.status.should be(200)
+
+      last_response.should have_selector(
+        'table.details tr td', :content => 'timeout')
+    end
+
+    it 'should render the expression (JSON)' do
+
+      get "/_ruote/expressions/0_0!!#{@wfid}.json"
+
+      last_response.status.should be(200)
+
+      #puts Rufus::Json.pretty_encode(last_response.json_body)
+
+      last_response.json_body['expression'].keys.should include(
+        'timeout_schedule_id')
+    end
+  end
 end
 
-describe "DELETE /_ruote/expressions/wfid/expid", :type => :with_engine do
+describe 'DELETE /_ruote/expressions/fei' do
+
+  it_has_an_engine
+
+  describe 'with running processes' do
 
-  describe "with running processes" do
     before(:each) do
+
       @wfid = launch_test_process do
         Ruote.process_definition :name => 'delete' do
           sequence do
@@ -112,72 +179,261 @@ describe "DELETE /_ruote/expressions/wfid/expid", :type => :with_engine do
         end
       end
 
-      wait_exp = engine.process( @wfid ).expressions.last
+      wait_exp = engine.process(@wfid).expressions.last
       @expid = "0_1_0" #wait_exp.fei.expid
     end
 
-    it "should cancel the expressions (HTML)" do
-      delete "/_ruote/expressions/#{@wfid}/#{@expid}"
+    it 'should cancel the expressions (HTML)' do
+
+      delete "/_ruote/expressions/#{@expid}!!#{@wfid}"
 
       last_response.should be_redirect
       last_response['Location'].should == "/_ruote/expressions/#{@wfid}"
 
       #sleep 0.4
-      wait_for( @wfid )
+      wait_for(@wfid)
 
       @tracer.to_s.should == "bailed\ndone"
     end
 
-    it "should cancel the expressions (JSON)" do
-      delete "/_ruote/expressions/#{@wfid}/#{@expid}.json"
+    it 'should cancel the expressions (JSON)' do
+
+      delete "/_ruote/expressions/#{@expid}!!#{@wfid}.json"
 
       last_response.should be_ok
       last_response.json_body['status'].should == 'ok'
 
       #sleep 0.4
-      wait_for( @wfid )
+      wait_for(@wfid)
 
       @tracer.to_s.should == "bailed\ndone"
     end
 
-    it "should kill the expression (HTML)" do
-      delete "/_ruote/expressions/#{@wfid}/#{@expid}?_kill=1"
+    it 'should kill the expression (HTML)' do
+
+      delete "/_ruote/expressions/#{@expid}!!#{@wfid}?_kill=1"
 
       last_response.should be_redirect
       last_response['Location'].should == "/_ruote/expressions/#{@wfid}"
 
       #sleep 0.4
-      wait_for( @wfid )
+      wait_for(@wfid)
 
-      @tracer.to_s.should == "done"
+      @tracer.to_s.should == 'done'
     end
 
-    it "should kill the expression (JSON)" do
-      delete "/_ruote/expressions/#{@wfid}/#{@expid}.json?_kill=1"
+    it 'should kill the expression (JSON)' do
+
+      delete "/_ruote/expressions/#{@expid}!!#{@wfid}.json?_kill=1"
 
       last_response.should be_ok
       last_response.json_body['status'].should == 'ok'
 
       #sleep 0.4
-      wait_for( @wfid )
+      wait_for(@wfid)
 
-      @tracer.to_s.should == "done"
+      @tracer.to_s.should == 'done'
     end
   end
 
-  describe "without running processes" do
-    it "should 404 correctly (HTML)" do
-      delete "/_ruote/expressions/foo/bar"
+  describe 'without running processes' do
+
+    it 'should 404 correctly (HTML)' do
+
+      delete '/_ruote/expressions/foo/bar'
 
       last_response.should_not be_ok
       last_response.status.should be(404)
     end
 
-    it "should 404 correctly (JSON)" do
-      delete "/_ruote/expressions/foo/bar.json"
+    it 'should 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 'PUT /_ruote/expressions/fei' do
+
+  it_has_an_engine
+
+  before(:each) do
+
+    @wfid = launch_test_process do
+      Ruote.process_definition do
+        alpha
+      end
+    end
+
+    @exp = RuoteKit.engine.process(@wfid).expressions.find { |e|
+      e.fei.expid == '0_0'
+    }
+  end
+
+  it 'should re-apply (HTML)' do
+
+    at0 = RuoteKit.engine.storage_participant.first.dispatched_at
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}",
+      :fields => '{}')
+
+    last_response.status.should be(302)
+    last_response.location.should == "/_ruote/expressions/#{@wfid}"
+
+    #RuoteKit.engine.wait_for(:alpha)
+    sleep 0.500
+
+    at1 = RuoteKit.engine.storage_participant.first.dispatched_at
+
+    at1.should_not == at0
+  end
+
+  it 'should re-apply (JSON)' do
+
+    #RuoteKit.engine.noisy = true
+
+    at0 = RuoteKit.engine.storage_participant.first.dispatched_at
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}.json",
+      Rufus::Json.encode({}),
+      { 'CONTENT_TYPE' => 'application/json' })
+
+    last_response.status.should be(200)
+
+    #RuoteKit.engine.wait_for(:alpha)
+    sleep 0.500
+
+    at1 = RuoteKit.engine.storage_participant.first.dispatched_at
+
+    at1.should_not == at0
+  end
+
+  it 'should re-apply with different fields (HTML)' do
+
+    wi = RuoteKit.engine.storage_participant.first
+    wi.fields['car'].should be(nil)
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}",
+      :fields => '{"car":"daimler-benz"}')
+
+    last_response.status.should be(302)
+    last_response.location.should == "/_ruote/expressions/#{@wfid}"
+
+    #RuoteKit.engine.wait_for(:alpha)
+    sleep 0.500
+
+    wi = RuoteKit.engine.storage_participant.first
+
+    wi.fields['car'].should == 'daimler-benz'
+  end
+
+  it 'should re-apply with different fields (JSON)' do
+
+    wi = RuoteKit.engine.storage_participant.first
+    wi.fields['car'].should be(nil)
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}.json",
+      Rufus::Json.encode({ 'fields' => { 'car' => 'bentley' } }),
+      { 'CONTENT_TYPE' => 'application/json' })
+
+    last_response.status.should be(200)
+
+    #RuoteKit.engine.wait_for(:alpha)
+    sleep 0.500
+
+    wi = RuoteKit.engine.storage_participant.first
+
+    wi.fields['car'].should == 'bentley'
+  end
+
+  it 'should re-apply when passed {"expression":{"fields":...}} (JSON)' do
+
+    exp = { 'expression' => { 'fields' => { 'car' => 'BMW' } } }
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}.json",
+      Rufus::Json.encode(exp),
+      { 'CONTENT_TYPE' => 'application/json' })
+
+    last_response.status.should be(200)
+
+    #RuoteKit.engine.wait_for(:alpha)
+    sleep 0.500
+
+    wi = RuoteKit.engine.storage_participant.first
+
+    wi.fields['car'].should == 'BMW'
+  end
+
+  it 'should re-apply with a different tree (HTML)' do
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}",
+      :tree => '["charly", {}, []]')
+
+    last_response.status.should be(302)
+    last_response.location.should == "/_ruote/expressions/#{@wfid}"
+
+    #RuoteKit.engine.wait_for(:alpha)
+    sleep 0.500
+
+    wi = RuoteKit.engine.storage_participant.first
+
+    wi.participant_name.should == 'charly'
+
+    RuoteKit.engine.process(@wfid).current_tree.should == [ 'define', {}, [
+      [ 'participant', { '_triggered' => 'on_re_apply', 'ref' => 'charly' }, [] ] ] ]
+  end
+
+  it 'should re-apply with a different tree (JSON)' do
+
+    wi = RuoteKit.engine.storage_participant.first
+    wi.participant_name.should == 'alpha'
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}.json",
+      Rufus::Json.encode({ 'tree' => [ 'bravo', {}, [] ] }),
+      { 'CONTENT_TYPE' => 'application/json' })
+
+    last_response.status.should be(200)
+
+    #RuoteKit.engine.wait_for(:alpha)
+    sleep 0.500
+
+    wi = RuoteKit.engine.storage_participant.first
+
+    wi.participant_name.should == 'bravo'
+
+    RuoteKit.engine.process(@wfid).current_tree.should == [ 'define', {}, [
+      [ 'participant', { '_triggered' => 'on_re_apply', 'ref' => 'bravo' }, [] ] ] ]
+  end
+
+  it 'should 400 when passed bogus JSON (HTML)' do
+
+    put(
+      "/_ruote/expressions/#{@exp.fei.sid}",
+      :fields => "{bogus}")
+
+    last_response.status.should be(400)
+  end
+
+  it 'should 400 when passed bogus JSON (JSON)' do
+
+    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
+

data/spec/resources/index_spec.rb

@@ -1,44 +1,55 @@
-require File.dirname(__FILE__) + '/../spec_helper'
 
-describe "GET /", :type => :with_engine do
+require 'spec_helper'
 
-  it "should return a welcome message in HTML be default" do
-    get "/_ruote"
+
+describe 'GET /' do
+
+  it_has_an_engine
+
+  it 'should return a welcome message in HTML be default' do
+
+    get '/_ruote'
 
     last_response.should be_ok
-    last_response.content_type.should match("text/html")
+    last_response.content_type.should match('text/html')
 
     last_response.should match(/Hello world/)
     last_response.should match(/<title>/)
   end
 
-  it "should return a version string if JSON is requested" do
-    header "Accept", "application/json"
+  it 'should return a version string if JSON is requested' do
+
+    header 'Accept', 'application/json'
 
-    get "/_ruote"
+    get '/_ruote'
 
     last_response.should be_ok
-    last_response.content_type.should match("application/json")
+    last_response.content_type.should match('application/json')
     body = last_response.json_body
 
-    body["misc"].should == { "ruote-kit" => "welcome", "version" => RuoteKit::VERSION.to_s }
+    body['misc'].should == {
+      'ruote-kit' => 'welcome', 'version' => RuoteKit::VERSION.to_s }
   end
 end
 
-describe "Generic error handling", :type => :with_engine do
+describe 'Generic error handling' do
 
-  it "should give our own 404 page (HTML)" do
-    get "/kenneth"
+  it_has_an_engine
+
+  it 'should give our own 404 page (HTML)' do
+
+    get '/kenneth'
 
     last_response.should_not be_ok
     last_response.status.should be(404)
 
     last_response.should be_html
-    last_response.should match(/Resource not found/)
+    last_response.should match(/resource not found/)
   end
 
-  it "should give our own 404 data (JSON)" do
-    get "/kenneth.json"
+  it 'should give our own 404 data (JSON)' do
+
+    get '/kenneth.json'
 
     last_response.should_not be_ok
     last_response.status.should be(404)
@@ -46,3 +57,4 @@ describe "Generic error handling", :type => :with_engine do
     last_response.should be_json
   end
 end
+

data/spec/resources/participants_spec.rb

@@ -0,0 +1,102 @@
+
+require 'spec_helper'
+
+
+describe 'GET /_ruote/participants' do
+
+  describe 'without any participant' do
+
+    it_has_an_engine_with_no_participants
+
+    it 'should give an empty list (HTML)' do
+      get '/_ruote/participants'
+
+      last_response.status.should be(200)
+    end
+
+    it 'should give an empty array (JSON)' do
+
+      get '/_ruote/participants.json'
+
+      last_response.status.should be(200)
+
+      body = last_response.json_body
+      body.should have_key('participants')
+
+      body['participants'].should be_empty
+    end
+  end
+
+  describe 'with participant' do
+
+    it_has_an_engine
+
+    it 'should give participant information back (HTML)' do
+
+      get '/_ruote/participants'
+
+      last_response.status.should be(200)
+    end
+
+    it 'should give participant information back (JSON)' do
+
+      get '/_ruote/participants.json'
+
+      last_response.status.should be(200)
+
+      body = last_response.json_body
+
+      body['participants'].should_not be_empty
+    end
+  end
+end
+
+describe 'PUT /_ruote/participants' do
+
+  it_has_an_engine
+
+  it 'should update the list (HTML)' do
+
+    put(
+      '/_ruote/participants',
+      'regex_0' => '^alice$',
+      'classname_0' => 'Ruote::StorageParticipant',
+      'options_0' => '{}',
+      'regex_1' => '^bravo$',
+      'classname_1' => 'Ruote::StorageParticipant',
+      'options_1' => '{}')
+
+    last_response.should be_redirect
+    last_response['Location'].should == '/_ruote/participants'
+
+    RuoteKit.engine.participant_list.collect { |pe| pe.regex }.should == [
+      '^alice$', '^bravo$'
+    ]
+  end
+
+  it 'should update the list (JSON)' do
+
+    list = {
+      'participants' => [
+        { 'regex' => '^alice$',
+          'classname' => 'Ruote::StorageParticipant',
+          'options' => {} },
+        { 'regex' => '^bravo$',
+          'classname' => 'Ruote::StorageParticipant',
+          'options' => {} }
+      ]
+    }
+
+    put(
+      '/_ruote/participants.json',
+      Rufus::Json.encode(list),
+      { 'CONTENT_TYPE' => 'application/json' })
+
+    last_response.status.should be(200)
+
+    RuoteKit.engine.participant_list.collect { |pe| pe.regex }.should == [
+      '^alice$', '^bravo$'
+    ]
+  end
+end
+