ruote-kit 2.2.0.3 → 2.3.0.2

data/spec/resources/index_spec.rb

@@ -1,10 +1,10 @@
 
-require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'spec_helper'
 
 
 describe 'GET /' do
 
-  it 'should return a welcome message in HTML be default' do
+  it 'returns a welcome message in HTML be default' do
 
     get '/_ruote'
 
@@ -15,7 +15,7 @@ describe 'GET /' do
     last_response.should match(/<title>/)
   end
 
-  it 'should return a version string if JSON is requested' do
+  it 'returns a version string if JSON is requested' do
 
     header 'Accept', 'application/json'
 
@@ -32,7 +32,7 @@ end
 
 describe 'Generic error handling' do
 
-  it 'should give our own 404 page (HTML)' do
+  it 'gives our own 404 page (HTML)' do
 
     get '/kenneth'
 
@@ -43,7 +43,7 @@ describe 'Generic error handling' do
     last_response.should match(/resource not found/)
   end
 
-  it 'should give our own 404 data (JSON)' do
+  it 'gives our own 404 data (JSON)' do
 
     get '/kenneth.json'
 

data/spec/resources/participants_spec.rb

@@ -1,119 +1,108 @@
 
-require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require 'spec_helper'
 
 
-describe 'GET /_ruote/participants' do
+describe '/_ruote/participants' do
 
   before(:each) do
-
     prepare_engine
   end
-
   after(:each) do
-
     shutdown_and_purge_engine
   end
 
-  describe 'without any participant' do
+  describe 'GET /_ruote/participants' do
 
-    it 'should give an empty list (HTML)' do
+    context 'without any participant' do
 
-      get '/_ruote/participants'
+      it 'gives an empty list (HTML)' do
 
-      last_response.status.should be(200)
-    end
+        get '/_ruote/participants'
 
-    it 'should give an empty array (JSON)' do
+        last_response.status.should be(200)
+      end
 
-      get '/_ruote/participants.json'
+      it 'gives an empty array (JSON)' do
 
-      last_response.status.should be(200)
+        get '/_ruote/participants.json'
 
-      body = last_response.json_body
-      body.should have_key('participants')
+        last_response.status.should be(200)
 
-      body['participants'].should be_empty
-    end
-  end
+        body = last_response.json_body
+        body.should have_key('participants')
 
-  describe 'with participant' do
+        body['participants'].should be_empty
+      end
+    end
 
-    before(:each) do
+    context 'with participant' do
 
-      register_participants
-    end
+      before(:each) do
+        register_participants
+      end
 
-    it 'should give participant information back (HTML)' do
+      it 'gives participant information back (HTML)' do
 
-      get '/_ruote/participants'
+        get '/_ruote/participants'
 
-      last_response.status.should be(200)
-    end
+        last_response.status.should be(200)
+      end
 
-    it 'should give participant information back (JSON)' do
+      it 'gives participant information back (JSON)' do
 
-      get '/_ruote/participants.json'
+        get '/_ruote/participants.json'
 
-      last_response.status.should be(200)
-      last_response.json_body['participants'].should_not be_empty
+        last_response.status.should be(200)
+        last_response.json_body['participants'].should_not be_empty
+      end
     end
   end
-end
 
-describe 'PUT /_ruote/participants' do
+  describe 'PUT /_ruote/participants' do
 
-  before(:each) do
+    it 'updates the list (HTML)' do
 
-    prepare_engine
-  end
+      put(
+        '/_ruote/participants',
+        'regex_0' => '^alice$',
+        'classname_0' => 'Ruote::StorageParticipant',
+        'options_0' => '{}',
+        'regex_1' => '^bravo$',
+        'classname_1' => 'Ruote::StorageParticipant',
+        'options_1' => '{}')
 
-  after(:each) do
+      last_response.should be_redirect
+      last_response['Location'].should == 'http://example.org/_ruote/participants'
 
-    shutdown_and_purge_engine
-  end
-
-  it 'should update the list (HTML)' do
+      RuoteKit.engine.participant_list.collect { |pe| pe.regex }.should == [
+        '^alice$', '^bravo$'
+      ]
+    end
 
-    put(
-      '/_ruote/participants',
-      'regex_0' => '^alice$',
-      'classname_0' => 'Ruote::StorageParticipant',
-      'options_0' => '{}',
-      'regex_1' => '^bravo$',
-      'classname_1' => 'Ruote::StorageParticipant',
-      'options_1' => '{}')
+    it 'updates the list (JSON)' do
 
-    last_response.should be_redirect
-    last_response['Location'].should == '/_ruote/participants'
+      list = {
+        'participants' => [
+          { 'regex' => '^alice$',
+            'classname' => 'Ruote::StorageParticipant',
+            'options' => {} },
+          { 'regex' => '^bravo$',
+            'classname' => 'Ruote::StorageParticipant',
+            'options' => {} }
+        ]
+      }
 
-    RuoteKit.engine.participant_list.collect { |pe| pe.regex }.should == [
-      '^alice$', '^bravo$'
-    ]
-  end
+      put(
+        '/_ruote/participants.json',
+        Rufus::Json.encode(list),
+        { 'CONTENT_TYPE' => 'application/json' })
 
-  it 'should update the list (JSON)' do
+      last_response.status.should be(200)
 
-    list = {
-      'participants' => [
-        { 'regex' => '^alice$',
-          'classname' => 'Ruote::StorageParticipant',
-          'options' => {} },
-        { 'regex' => '^bravo$',
-          'classname' => 'Ruote::StorageParticipant',
-          'options' => {} }
+      RuoteKit.engine.participant_list.collect { |pe| pe.regex }.should == [
+        '^alice$', '^bravo$'
       ]
-    }
-
-    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
 end
 

data/spec/resources/processes_spec.rb

@@ -1,436 +1,555 @@
 
-require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
-
-
-def process_links(wfid)
-  [
-    { 'href' => "/_ruote/processes/#{wfid}",
-      'rel' => 'self' },
-    { 'href' => "/_ruote/processes/#{wfid}",
-      'rel' => 'http://ruote.rubyforge.org/rels.html#process' },
-    { 'href' => "/_ruote/expressions/#{wfid}",
-      'rel' => 'http://ruote.rubyforge.org/rels.html#process_expressions' },
-    { 'href' => "/_ruote/workitems/#{wfid}",
-      'rel' => 'http://ruote.rubyforge.org/rels.html#process_workitems' },
-    { 'href' => "/_ruote/errors/#{wfid}",
-      'rel' => 'http://ruote.rubyforge.org/rels.html#process_errors' },
-    { 'href' => "/_ruote/schedules/#{wfid}",
-      'rel' => 'http://ruote.rubyforge.org/rels.html#process_schedules' }
-  ]
-end
+require 'spec_helper'
 
 
-describe 'GET /_ruote/processes' do
+describe '/_ruote/processes' do
 
   before(:each) do
-
     prepare_engine_with_participants
   end
-
   after(:each) do
-
     shutdown_and_purge_engine
   end
 
-  describe 'without any running processes' do
+  def process_links(wfid)
+    [
+      { 'href' => "/_ruote/processes/#{wfid}",
+        'rel' => 'self' },
+      { 'href' => "/_ruote/processes/#{wfid}",
+        'rel' => 'http://ruote.rubyforge.org/rels.html#process' },
+      { 'href' => "/_ruote/expressions/#{wfid}",
+        'rel' => 'http://ruote.rubyforge.org/rels.html#process_expressions' },
+      { 'href' => "/_ruote/workitems/#{wfid}",
+        'rel' => 'http://ruote.rubyforge.org/rels.html#process_workitems' },
+      { 'href' => "/_ruote/errors/#{wfid}",
+        'rel' => 'http://ruote.rubyforge.org/rels.html#process_errors' },
+      { 'href' => "/_ruote/schedules/#{wfid}",
+        'rel' => 'http://ruote.rubyforge.org/rels.html#process_schedules' }
+    ]
+  end
+
+  describe 'GET /_ruote/processes' do
 
-    it 'should give no processes back (HTML)' do
+    context 'without any running processes' do
 
-      get '/_ruote/processes?limit=100&skip=0'
+      it 'gives no processes back (HTML)' do
 
-      last_response.status.should == 200
+        get '/_ruote/processes?limit=100&skip=0'
+
+        last_response.status.should == 200
+
+        last_response.should have_selector(
+          'a', :content => 'as JSON')
+        last_response.should have_selector(
+          'a', :href => '/_ruote/processes.json?limit=100&skip=0')
+      end
 
-      last_response.should have_selector(
-        'a', :content => 'as JSON')
-      last_response.should have_selector(
-        'a', :href => '/_ruote/processes.json?limit=100&skip=0')
+      it 'gives an empty array (JSON)' do
+
+        get '/_ruote/processes.json'
+
+        last_response.status.should == 200
+
+        body = last_response.json_body
+        body.should have_key('processes')
+
+        body['processes'].should be_empty
+      end
     end
 
-    it 'should give an empty array (JSON)' do
+    context 'with running processes' do
 
-      get '/_ruote/processes.json'
+      before(:each) do
+        @wfid = launch_nada_process
+      end
 
-      last_response.status.should == 200
+      it 'gives process information back (HTML)' do
 
-      body = last_response.json_body
-      body.should have_key('processes')
+        get '/_ruote/processes'
+
+        last_response.status.should == 200
+      end
 
-      body['processes'].should be_empty
+      it 'gives process information back (JSON)' do
+
+        get '/_ruote/processes.json'
+
+        last_response.status.should == 200
+
+        body = last_response.json_body
+
+        body['processes'].should_not be_empty
+
+        body['links'].should == [
+          { 'href' => '/_ruote',
+            'rel' => 'http://ruote.rubyforge.org/rels.html#root' },
+          { 'href' => '/_ruote/processes',
+            'rel' => 'http://ruote.rubyforge.org/rels.html#processes' },
+          { 'href' => '/_ruote/workitems',
+            'rel' => 'http://ruote.rubyforge.org/rels.html#workitems' },
+          { 'href' => '/_ruote/errors',
+            'rel' => 'http://ruote.rubyforge.org/rels.html#errors' },
+          { 'href' => '/_ruote/participants',
+            'rel' => 'http://ruote.rubyforge.org/rels.html#participants' },
+          { 'href' => '/_ruote/schedules',
+            'rel' => 'http://ruote.rubyforge.org/rels.html#schedules' },
+          { 'href' => '/_ruote/history',
+            'rel' => 'http://ruote.rubyforge.org/rels.html#history' },
+          { 'href' => '/_ruote/processes',
+            'rel' => 'self' },
+          { 'href' => '/_ruote/processes',
+            'rel' => 'all' },
+          { 'href' => '/_ruote/processes?limit=100&skip=0',
+            'rel' => 'first' },
+          { 'href' => '/_ruote/processes?limit=100&skip=0',
+            'rel' => 'last' },
+          { 'href' => '/_ruote/processes?limit=100&skip=0',
+            'rel' => 'previous' },
+          { 'href' => '/_ruote/processes?limit=100&skip=0',
+            'rel' => 'next' } ]
+
+        body['processes'].first['links'].should == process_links(@wfid)
+      end
     end
   end
 
-  describe 'with running processes' do
+  describe 'GET /_ruote/processes/:wfid' do
 
-    before(:each) do
-      @wfid = launch_nada_process
-    end
+    context 'with a running process' do
 
-    it 'should give process information back (HTML)' do
+      before(:each) do
+        @wfid = launch_nada_process
+      end
 
-      get '/_ruote/processes'
+      it 'gives process information back (HTML)' do
 
-      last_response.status.should == 200
-    end
+        get "/_ruote/processes/#{@wfid}"
 
-    it 'should give process information back (JSON)' do
+        last_response.status.should == 200
 
-      get '/_ruote/processes.json'
+        last_response.should have_selector(
+          'a[rel="http://ruote.rubyforge.org/rels.html#process_schedules"]')
 
-      last_response.status.should == 200
+        last_response.should have_selector(
+          'td')
+        last_response.should have_selector(
+          'input[name="_method"][type="hidden"][value="DELETE"]')
+        last_response.should have_selector(
+          'input[name="_method"][type="hidden"][value="PUT"]')
+      end
+
+      it 'gives process information back (JSON)' do
 
-      body = last_response.json_body
-
-      body['processes'].should_not be_empty
-
-      body['links'].should == [
-        { 'href' => '/_ruote',
-          'rel' => 'http://ruote.rubyforge.org/rels.html#root' },
-        { 'href' => '/_ruote/processes',
-          'rel' => 'http://ruote.rubyforge.org/rels.html#processes' },
-        { 'href' => '/_ruote/workitems',
-          'rel' => 'http://ruote.rubyforge.org/rels.html#workitems' },
-        { 'href' => '/_ruote/errors',
-          'rel' => 'http://ruote.rubyforge.org/rels.html#errors' },
-        { 'href' => '/_ruote/participants',
-          'rel' => 'http://ruote.rubyforge.org/rels.html#participants' },
-        { 'href' => '/_ruote/schedules',
-          'rel' => 'http://ruote.rubyforge.org/rels.html#schedules' },
-        { 'href' => '/_ruote/history',
-          'rel' => 'http://ruote.rubyforge.org/rels.html#history' },
-        { 'href' => '/_ruote/processes',
-          'rel' => 'self' },
-        { 'href' => '/_ruote/processes',
-          'rel' => 'all' },
-        { 'href' => '/_ruote/processes?limit=100&skip=0',
-          'rel' => 'first' },
-        { 'href' => '/_ruote/processes?limit=100&skip=0',
-          'rel' => 'last' },
-        { 'href' => '/_ruote/processes?limit=100&skip=0',
-          'rel' => 'previous' },
-        { 'href' => '/_ruote/processes?limit=100&skip=0',
-          'rel' => 'next' } ]
-
-      body['processes'].first['links'].should == process_links(@wfid)
+        get "/_ruote/processes/#{@wfid}.json"
+
+        last_response.status.should == 200
+
+        body = last_response.json_body
+
+        body.should have_key('process')
+
+        body['process']['links'].should == process_links(@wfid)
+
+        body['process'].keys.sort.should == %w[
+          current_tree definition_name definition_revision detailed errors
+          expressions last_active launched_time links original_tree
+          root_expression_state stored_workitems tags type variables wfid
+          workitems
+        ]
+      end
     end
-  end
-end
 
-describe 'GET /_ruote/processes/wfid' do
+    context 'without a running process' do
 
-  before(:each) do
+      it 'goes 404 correctly (HTML)' do
 
-    prepare_engine_with_participants
-  end
+        get '/_ruote/processes/foo'
 
-  after(:each) do
+        last_response.status.should == 404
 
-    shutdown_and_purge_engine
-  end
+        last_response.should match(/resource not found/)
+      end
 
-  describe 'with a running process' do
+      it 'goes 404 correctly (JSON)' do
 
-    before(:each) do
+        get '/_ruote/processes/foo.json'
+
+        last_response.status.should == 404
+
+        last_response.json_body.keys.should include('http_error')
 
-      @wfid = launch_nada_process
+        last_response.json_body['http_error'].should == {
+          'code' => 404, 'message' => 'resource not found', 'cause' => ''
+        }
+      end
     end
+  end
+
+  describe 'GET /_ruote/processes/new' do
 
-    it 'should give process information back (HTML)' do
+    it 'returns a launch form' do
 
-      get "/_ruote/processes/#{@wfid}"
+      get '/_ruote/processes/new'
 
       last_response.status.should == 200
 
-      last_response.should have_selector(
-        'a[rel="http://ruote.rubyforge.org/rels.html#process_schedules"]')
+      last_response.should_not have_selector('a', :content => 'as JSON')
     end
+  end
 
-    it 'should give process information back (JSON)' do
+  describe 'PUT /_ruote/processes/:wfid' do
 
-      get "/_ruote/processes/#{@wfid}.json"
+    context 'without a valid process' do
 
-      last_response.status.should == 200
+      it 'goes 404 (HTML)' do
 
-      body = last_response.json_body
+        put('/_ruote/processes/123-nada', :state => 'paused')
 
-      body.should have_key('process')
+        last_response.status.should == 404
+      end
+
+      it 'goes 404 (JSON)' do
 
-      body['process']['links'].should == process_links(@wfid)
+        put(
+          '/_ruote/processes/456-nada.json',
+          Rufus::Json.encode({ 'state' => 'paused' }),
+          { 'CONTENT_TYPE' => 'application/json' })
+
+        last_response.status.should == 404
+      end
     end
-  end
 
-  describe 'without a running process' do
+    context 'with a valid process' do
 
-    it 'should 404 correctly (HTML)' do
+      before(:each) do
+        @wfid = launch_nada_process
+      end
 
-      get '/_ruote/processes/foo'
+      it 'pauses the process (HTML)' do
 
-      last_response.status.should == 404
+        put(
+          "/_ruote/processes/#{@wfid}",
+          :state => 'paused')
 
-      last_response.should match(/resource not found/)
-    end
+        last_response.status.should == 200
+        last_response.content_type.should match(/^text\/html\b/)
 
-    it 'should 404 correctly (JSON)' do
+        sleep 0.500
 
-      get '/_ruote/processes/foo.json'
+        RuoteKit.engine.ps(@wfid).root_expression.state.should == 'paused'
+      end
 
-      last_response.status.should == 404
+      it 'resumes the process if paused (HTML)' do
 
-      last_response.json_body.keys.should include('http_error')
+        RuoteKit.engine.pause(@wfid)
 
-      last_response.json_body['http_error'].should == {
-        'code' => 404, 'message' => 'resource not found', 'cause' => ''
-      }
-    end
-  end
-end
+        sleep 0.500
 
-describe 'GET /_ruote/processes/new' do
+        RuoteKit.engine.ps(@wfid).root_expression.state.should == 'paused'
 
-  before(:each) do
+        put(
+          "/_ruote/processes/#{@wfid}",
+          :state => 'resuming')
 
-    prepare_engine
-  end
+        last_response.status.should == 200
+        last_response.content_type.should match(/^text\/html\b/)
 
-  after(:each) do
+        sleep 0.500
 
-    shutdown_and_purge_engine
-  end
+        RuoteKit.engine.ps(@wfid).root_expression.state.should == nil
+      end
 
-  it 'should return a launch form' do
+      it 'pauses the process (JSON)' do
 
-    get '/_ruote/processes/new'
+        put(
+          "/_ruote/processes/#{@wfid}.json",
+          Rufus::Json.encode({ 'state' => 'paused' }),
+          { 'CONTENT_TYPE' => 'application/json' })
 
-    last_response.status.should == 200
+        last_response.status.should == 200
+        last_response.json_body['process'].should_not == nil
 
-    last_response.should_not have_selector('a', :content => 'as JSON')
-  end
-end
+        sleep 0.500
 
-describe 'POST /_ruote/processes' do
+        RuoteKit.engine.ps(@wfid).root_expression.state.should == 'paused'
+      end
 
-  before(:each) do
+      it 'resumes the process if paused (JSON)' do
 
-    prepare_engine
-  end
+        RuoteKit.engine.pause(@wfid)
 
-  after(:each) do
+        sleep 0.500
 
-    shutdown_and_purge_engine
+        RuoteKit.engine.ps(@wfid).root_expression.state.should == 'paused'
+
+        put(
+          "/_ruote/processes/#{@wfid}.json",
+          Rufus::Json.encode({ 'state' => 'resuming' }),
+          { 'CONTENT_TYPE' => 'application/json' })
+
+        last_response.status.should == 200
+        last_response.json_body['process'].should_not == nil
+
+        sleep 0.500
+
+        RuoteKit.engine.ps(@wfid).root_expression.state.should == nil
+      end
+    end
   end
 
-  it 'should launch a valid process definition (JSON)' do
+  describe 'POST /_ruote/processes' do
 
-    params = {
-      :definition => %q{
-        Ruote.process_definition :name => 'test' do
-          wait '1m'
-        end
+    it 'launches a valid process definition (JSON)' do
+
+      params = {
+        :definition => %q{
+          Ruote.process_definition :name => 'test' do
+            wait '1m'
+          end
+        }
       }
-    }
 
-    post(
-      '/_ruote/processes.json',
-      Rufus::Json.encode(params),
-      { 'CONTENT_TYPE' => 'application/json' })
+      post(
+        '/_ruote/processes.json',
+        Rufus::Json.encode(params),
+        { 'CONTENT_TYPE' => 'application/json' })
 
-    last_response.status.should == 201
+      last_response.status.should == 201
 
-    last_response.json_body['launched'].should match(/[0-9a-z\-]+/)
+      last_response.json_body['launched'].should match(/[0-9a-z\-]+/)
 
-    sleep 0.4
+      sleep 0.4
 
-    engine.processes.should_not be_empty
-  end
+      engine.processes.should_not be_empty
+    end
 
-  it 'should launch a valid process definition with fields (JSON)' do
+    it 'launches a process definition (radial) (JSON)' do
 
-    params = {
-      :definition => %q{
-        Ruote.process_definition :name => 'test' do
-          echo '${f:foo}'
-        end
-      },
-      :fields => { :foo => 'bar' }
-    }
+      params = {
+        :definition => %q{
+          define 'my process'
+            wait '1m'
+        }
+      }
 
-    post(
-      '/_ruote/processes.json',
-      Rufus::Json.encode(params),
-      { 'CONTENT_TYPE' => 'application/json' })
+      post(
+        '/_ruote/processes.json',
+        Rufus::Json.encode(params),
+        { 'CONTENT_TYPE' => 'application/json' })
 
-    last_response.status.should == 201
-    last_response.json_body['launched'].should match(/[0-9a-z\-]+/)
+      last_response.status.should == 201
 
-    sleep 0.5
+      last_response.json_body['launched'].should match(/[0-9a-z\-]+/)
 
-    @tracer.to_s.should == 'bar'
-  end
+      sleep 0.4
 
-  it 'should launch a valid process definition (HTML)' do
+      engine.processes.should_not be_empty
 
-    params = {
-      :definition => %q{
-        Ruote.process_definition :name => 'test' do
-          wait '1m'
-        end
+      engine.processes.first.expressions.last.should be_a(
+        Ruote::Exp::WaitExpression)
+    end
+
+    it 'launches a valid process definition with fields (JSON)' do
+
+      params = {
+        :definition => %q{
+          Ruote.process_definition :name => 'test' do
+            echo '${f:foo}'
+          end
+        },
+        :fields => { :foo => 'bar' }
       }
-    }
 
-    post '/_ruote/processes', params
+      post(
+        '/_ruote/processes.json',
+        Rufus::Json.encode(params),
+        { 'CONTENT_TYPE' => 'application/json' })
 
-    last_response.status.should == 201
+      last_response.status.should == 201
+      last_response.json_body['launched'].should match(/[0-9a-z\-]+/)
 
-    sleep 0.4
+      sleep 0.5
 
-    engine.processes.should_not be_empty
-  end
+      @tracer.to_s.should == 'bar'
+    end
 
-  it 'should launch a process definition with fields (HTML)' do
+    it 'launches a valid process definition (HTML)' do
 
-    params = {
-      :definition => %{
-        Ruote.process_definition :name => 'test' do
-          echo '${f:foo}'
-        end
-      },
-      :fields => '{ "foo": "bar" }'
-    }
+      params = {
+        :definition => %q{
+          Ruote.process_definition :name => 'test' do
+            wait '1m'
+          end
+        }
+      }
 
-    post '/_ruote/processes', params
+      post '/_ruote/processes', params
 
-    last_response.status.should == 201
+      last_response.status.should == 201
 
-    sleep 0.5
+      sleep 0.4
 
-    @tracer.to_s.should == 'bar'
-  end
+      engine.processes.should_not be_empty
 
-  it 'should correct for empty fields sent by browsers' do
+      engine.processes.first.expressions.last.should be_a(
+        Ruote::Exp::WaitExpression)
+    end
 
-    params = {
-      :definition => %q{
-        Ruote.process_definition :name => 'test' do
-          wait '5m'
-        end
-      },
-      :fields => ''
-    }
+    it 'launches a process definition (radial and CRLF) (HTML)' do
 
-    post '/_ruote/processes', params
+      params = {
+        :definition => "define 'my process'\r\n  wait '1m'\r\n"
+      }
 
-    last_response.status.should == 201
+      post '/_ruote/processes', params
 
-    sleep 0.4
+      last_response.status.should == 201
 
-    engine.processes.should_not be_empty
-  end
+      sleep 0.4
 
-  it 'should 400 code when it fails to determine what to launch (JSON)' do
+      engine.processes.should_not be_empty
 
-    params = { :definition => 'http://invalid.invalid' }
+      engine.processes.first.expressions.last.should be_a(
+        Ruote::Exp::WaitExpression)
+    end
 
-    post(
-      '/_ruote/processes.json',
-      Rufus::Json.encode(params),
-      { 'CONTENT_TYPE' => 'application/json' })
+    it 'launches a process definition with fields (HTML)' do
 
-    last_response.status.should == 400
-    last_response.json_body.keys.should include('http_error')
-  end
+      params = {
+        :definition => %{
+          Ruote.process_definition :name => 'test' do
+            echo '${f:foo}'
+          end
+        },
+        :fields => '{ "foo": "bar" }'
+      }
 
-  it 'should 400 when it fails to determine what to launch (HTML)' do
+      post '/_ruote/processes', params
 
-    params = { :definition => %q{http://invalid.invalid} }
+      last_response.status.should == 201
 
-    post '/_ruote/processes', params
+      sleep 0.5
 
-    last_response.status.should == 400
-    last_response.should match(/bad request/)
-  end
+      @tracer.to_s.should == 'bar'
+    end
 
-end
+    it 'corrects empty fields sent by browsers' do
 
-describe 'DELETE /_ruote/processes/wfid' do
+      params = {
+        :definition => %q{
+          Ruote.process_definition :name => 'test' do
+            wait '5m'
+          end
+        },
+        :fields => ''
+      }
 
-  before(:each) do
+      post '/_ruote/processes', params
 
-    prepare_engine
-  end
+      last_response.status.should == 201
 
-  after(:each) do
+      sleep 0.4
 
-    shutdown_and_purge_engine
-  end
+      engine.processes.should_not be_empty
+    end
 
-  before(:each) do
+    it 'goes 400 code when it fails to determine what to launch (JSON)' do
 
-    @wfid = RuoteKit.engine.launch(Ruote.process_definition do
-      sequence :on_cancel => 'bail_out' do
-        echo 'in'
-        wait '1d'
-        echo 'done.'
-      end
+      params = { :definition => 'http://invalid.invalid' }
 
-      define :name => 'bail_out' do
-        echo 'bailout.'
-      end
-    end)
+      post(
+        '/_ruote/processes.json',
+        Rufus::Json.encode(params),
+        { 'CONTENT_TYPE' => 'application/json' })
+
+      last_response.status.should == 400
+      last_response.json_body.keys.should include('http_error')
+    end
+
+    it 'goes 400 when it fails to determine what to launch (HTML)' do
+
+      params = { :definition => %q{http://invalid.invalid} }
+
+      post '/_ruote/processes', params
+
+      last_response.status.should == 400
+      last_response.should match(/bad request/)
+    end
 
-    RuoteKit.engine.wait_for(3)
   end
 
-  it 'should cancel processes (JSON)' do
+  describe 'DELETE /_ruote/processes/:wfid' do
 
-    delete "/_ruote/processes/#{@wfid}.json"
+    before(:each) do
 
-    last_response.status.should == 200
+      @wfid = RuoteKit.engine.launch(Ruote.process_definition do
+        sequence :on_cancel => 'bail_out' do
+          echo 'in'
+          wait '1d'
+          echo 'done.'
+        end
 
-    wait_for(@wfid)
+        define :name => 'bail_out' do
+          echo 'bailout.'
+        end
+      end)
 
-    engine.process(@wfid).should be_nil
+      RuoteKit.engine.wait_for(3)
+    end
 
-    @tracer.to_s.should == "in\nbailout."
-  end
+    it 'cancels processes (JSON)' do
 
-  it 'should cancel processes (HMTL)' do
+      delete "/_ruote/processes/#{@wfid}.json"
 
-    delete "/_ruote/processes/#{@wfid}"
+      last_response.status.should == 200
+
+      wait_for(@wfid)
 
-    last_response.should be_redirect
-    last_response['Location'].should == '/_ruote/processes'
+      engine.process(@wfid).should be_nil
 
-    wait_for(@wfid)
+      @tracer.to_s.should == "in\nbailout."
+    end
 
-    engine.process(@wfid).should be_nil
+    it 'cancels processes (HMTL)' do
 
-    @tracer.to_s.should == "in\nbailout."
-  end
+      delete "/_ruote/processes/#{@wfid}"
 
-  it 'should kill processes (JSON)' do
+      last_response.should be_redirect
+      last_response['Location'].should == 'http://example.org/_ruote/processes'
 
-    delete "/_ruote/processes/#{@wfid}.json?_kill=1"
+      wait_for(@wfid)
 
-    last_response.status.should == 200
+      engine.process(@wfid).should be_nil
 
-    wait_for(@wfid)
+      @tracer.to_s.should == "in\nbailout."
+    end
 
-    engine.process(@wfid).should be_nil
+    it 'kills processes (JSON)' do
 
-    @tracer.to_s.should == 'in'
-  end
+      delete "/_ruote/processes/#{@wfid}.json?_kill=1"
 
-  it 'should kill processes (HTML)' do
+      last_response.status.should == 200
 
-    delete "/_ruote/processes/#{@wfid}?_kill=1"
+      wait_for(@wfid)
 
-    last_response.should be_redirect
-    last_response['Location'].should == '/_ruote/processes'
+      engine.process(@wfid).should be_nil
+
+      @tracer.to_s.should == 'in'
+    end
 
-    wait_for(@wfid)
+    it 'kills processes (HTML)' do
 
-    engine.process(@wfid).should be_nil
+      delete "/_ruote/processes/#{@wfid}?_kill=1"
 
-    @tracer.to_s.should == 'in'
+      last_response.should be_redirect
+      last_response['Location'].should == 'http://example.org/_ruote/processes'
+
+      wait_for(@wfid)
+
+      engine.process(@wfid).should be_nil
+
+      @tracer.to_s.should == 'in'
+    end
   end
 end