ruote-cukes 2.1.9

data/CHANGELOG.txt

@@ -0,0 +1,8 @@
+
+= ruote-cukes - CHANGELOG.txt
+
+
+== ruote-cukes - 2.1.9    released 2010/06/14
+
+- initial release
+

data/CREDITS.txt

@@ -0,0 +1,11 @@
+
+= CREDITS.txt
+
+John Mettraux - http://jmettraux.wordpress.com
+
+Nicholas Faiz - http://github.com/biv
+Kenneth Kalmer - http://github.com/kennethkalmer
+
+
+Many thanks to the authors of Cucumber : http://cukes.info/
+

data/README.rdoc

@@ -0,0 +1,78 @@
+
+= ruote-cukes
+
+Cucumber helpers (steps) for testing ruote process definitions and participants.
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    When I launch the flow
+      """
+      Ruote.process_definition do
+        sequence do
+          alpha
+          participant :ref => '${f:next}'
+        end
+      end
+      """
+    Then the process should reach alpha
+    When I get the first workitem of participant alpha
+    And I update the workitem with
+      | next | charly |
+    And I reply with the workitem
+    Then the process should reach charly
+
+Note the usage of two columns cucumber tables for storing fields (or variables). The first column hold the keys, while the second one the values.
+
+Look at features/ for the whole range of examples.
+
+
+== using them
+
+  gem install ruote-cukes
+
+then make sure to include
+
+  require 'ruote-cukes'
+
+in your feature support or step definitions.
+
+
+== complex fields
+
+When using cucumber tables to represent fields (or variables), ruote-cukes will always try to decode the values via JSON. This thus becomes possible :
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    And the initial fields are
+      | targets | ["alice","bob"] |
+    When I launch the flow
+      """
+      Ruote.process_definition do
+        concurrent_iterator :on_field => 'targets', :to_f => 'f' do
+          participant :ref => '${f:f}'
+        end
+      end
+      """
+    Then the process should reach alice
+    And the process should reach bob
+
+
+== running the example features
+
+Make sure the ruote and cucumber gems are installed and run
+
+  cucumber
+
+
+== author
+
+John Mettraux
+http://jmettraux.wordpress.com
+
+
+== license
+
+MIT
+

data/Rakefile

@@ -0,0 +1,43 @@
+
+require 'lib/ruote/cukes/version.rb'
+
+require 'rubygems'
+require 'rake'
+
+
+begin
+
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+
+    gem.version = Ruote::Cukes::VERSION
+    gem.name = 'ruote-cukes'
+    gem.summary = 'cucumber helpers for testing ruote definitions and participants'
+    gem.description = %{
+cucumber helpers (steps) for testing ruote process definitions and participants
+    }
+    gem.email = 'jmettraux@gmail.com'
+    gem.homepage = 'http://ruote.rubyforge.org'
+    gem.authors = [ 'John Mettraux' ]
+    gem.rubyforge_project = 'ruote'
+    #gem.test_file = 'test/test.rb'
+
+    gem.add_dependency 'ruote', '>= 2.1.9'
+    gem.add_dependency 'cucumber'
+
+    gem.add_development_dependency 'rake'
+    gem.add_development_dependency 'jeweler'
+
+    # Gem::Specification http://www.rubygems.org/read/chapter/20
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end
+
+require 'rake/clean'
+CLEAN.include('pkg')
+
+task :default => [ :clean ]
+

data/TODO.txt

@@ -0,0 +1,7 @@
+
+[o] use tables for field input
+[o] "When I update the workitem with" should do storage_participant.first if
+    there is no workitem present
+
+[ ] something about participants
+

data/features/basic.feature

@@ -0,0 +1,14 @@
+
+Feature: basic
+
+  a basic feature example
+
+  Scenario: from a to b
+    Given I have a ruote engine
+    And the catchall participant is registered
+    And I launch the flow at flows/a_to_b.rb
+    When I get the first workitem of participant alpha
+    Then I should have a workitem
+    And the process should be alive
+    And the process should have no errors
+

data/features/embedded.feature

@@ -0,0 +1,20 @@
+
+Feature: I launch the flow
+
+  the process definition is embedded in the feature
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    And I launch the flow
+      """
+      Ruote.process_definition do
+        sequence do
+          alpha
+          bravo
+        end
+      end
+      """
+    When I get the first workitem of participant alpha
+    Then I should have a workitem
+

data/features/fields_and_json.feature

@@ -0,0 +1,21 @@
+
+Feature: the fields table can hold json values
+
+  the second column of 
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    And the initial fields are
+      | targets | ["alice","bob"] |
+    When I launch the flow
+      """
+      Ruote.process_definition do
+        concurrent_iterator :on_field => 'targets', :to_f => 'f' do
+          participant :ref => '${f:f}'
+        end
+      end
+      """
+    Then the process should reach alice
+    And the process should reach bob
+

data/features/initial_fields.feature

@@ -0,0 +1,17 @@
+
+Feature: When the initial fields are
+
+  using a cucumber table to set the initial fields of a workitem (launchitem)
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    And the initial fields are
+      | customer | Alain-san |
+      | company  | super asia exchange |
+    And I launch the flow at flows/a_to_b.rb
+    When I get the first workitem of participant alpha
+    Then the workitem should include
+      | customer | Alain-san |
+      | company  | super asia exchange |
+

data/features/over.feature

@@ -0,0 +1,13 @@
+
+Feature: When I launch
+
+  of course, launch may be a Given or a When
+
+  Scenario: from alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    When I launch the flow at flows/a.rb
+    Then the process should reach alpha
+    When I reply
+    Then the process should be over
+

data/features/reply.feature

@@ -0,0 +1,14 @@
+
+Feature: When I reply with the workitem
+
+  a step definition for letting a workitem resume in its flow
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    When I launch the flow at flows/a_to_b.rb
+    Then the process should reach alpha
+    When I get the first workitem of alpha
+    And I reply with the workitem
+    Then the process should reach bravo
+

data/features/step_definitions/requiring.rb

@@ -0,0 +1,5 @@
+
+$:.unshift('lib')
+
+require 'ruote/cukes'
+

data/features/update.feature

@@ -0,0 +1,18 @@
+
+Feature: When I update the workitem with
+
+  changing the fields (payload) of a workitem
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    When I launch the flow at flows/a_to_b.rb
+    Then the process should reach alpha
+    When I get the first workitem of alpha
+    And I update the workitem with
+      | customer | Alf |
+    And I reply with the workitem
+    Then the process should reach bravo
+    And the workitem should include
+      | customer | Alf |
+

data/features/when.feature

@@ -0,0 +1,12 @@
+
+Feature: When I launch
+
+  of course, launch may be a Given or a When
+
+  Scenario: from alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    When I launch the flow at flows/a_to_b.rb
+    Then the process should reach alpha
+    And the process should reach participant alpha
+

data/features/whole.feature

@@ -0,0 +1,24 @@
+
+Feature: ruote-cukes features
+
+  showing a rather complete example
+
+  Scenario: alpha to bravo
+    Given I have a ruote engine
+    And the catchall participant is registered
+    When I launch the flow
+      """
+      Ruote.process_definition do
+        sequence do
+          alpha
+          participant :ref => '${f:next}'
+        end
+      end
+      """
+    Then the process should reach alpha
+    When I get the first workitem of participant alpha
+    And I update the workitem with
+      | next | charly |
+    And I reply with the workitem
+    Then the process should reach charly
+

data/flows/a.rb

@@ -0,0 +1,8 @@
+
+#
+# a tiny process with only a stop to participant alpha
+#
+Ruote.process_definition do
+  alpha
+end
+

data/flows/a_to_b.rb

@@ -0,0 +1,8 @@
+
+Ruote.process_definition do
+  sequence do
+    alpha
+    bravo
+  end
+end
+

data/lib/ruote/cukes.rb

@@ -0,0 +1,213 @@
+#--
+# Copyright (c) 2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+require 'test/unit/assertions'
+include Test::Unit::Assertions
+  # not sure about that for now...
+
+require 'json'
+require 'ruote'
+
+require 'ruote/cukes/version'
+
+
+#
+# a variable container in a singleton, or something like that
+#
+module Ruote::Cukes
+
+  def self.method_missing (m, *args)
+    m = m.to_s
+    if args.size == 1 && mm = m.match(/^(.+)=$/)
+      (@vars ||= {})[mm[1]] = args.first
+    elsif args.size == 0
+      (@vars ||= {})[m]
+    else
+      super
+    end
+  end
+
+  def self.workitem
+
+    if wi = @vars['workitem']
+      return wi
+    end
+
+    wi = @vars['storage_participant'].first
+
+    @vars['workitem'] = wi
+  end
+end
+
+#
+# re-opening the cucumber table class to add a fancy to_hash method
+#
+class Cucumber::Ast::Table
+
+  def to_hash
+
+    self.raw.inject({}) do |h, (k, v)|
+      h[k] = (Rufus::Json.decode(v) rescue v)
+      h
+    end
+  end
+end
+
+
+#
+# ENGINE
+
+Given /I have a ruote engine/ do
+
+  Ruote::Cukes.engine =
+    Ruote::Engine.new(
+      Ruote::Worker.new(
+        Ruote::HashStorage.new(
+          's_logger' => [ 'ruote/log/test_logger', 'Ruote::TestLogger' ])))
+end
+
+
+#
+# PARTICIPANTS
+
+Given /the catch[- ]?all participant is registered/ do
+
+  Ruote::Cukes.storage_participant =
+    Ruote::Cukes.engine.register_participant('.+', Ruote::StorageParticipant)
+
+  Ruote::Cukes.storage_participant.context = Ruote::Cukes.engine.context
+    # due to a bug in ruote 2.1.7, remove when 2.1.8 is out
+end
+
+Given /I get the first workitem of (?:participant )?(.+)$/ do |pname|
+
+  sleep 0.100 # give some time to the engine
+
+  Ruote::Cukes.workitem =
+    Ruote::Cukes.storage_participant.by_participant(pname).first
+end
+
+
+#
+# LAUNCH
+
+Given /the initial fields are$/ do |table|
+
+  Ruote::Cukes.launch_fields = table.to_hash
+end
+
+Given /the initial variables are (.+)$/ do |table|
+
+  Ruote::Cukes.launch_variables = table.to_hash
+end
+
+Given /I launch the flow at (.+)$/ do |path|
+
+  Ruote::Cukes.last_wfid = Ruote::Cukes.engine.launch(
+    path,
+    Ruote::Cukes.launch_fields || {},
+    Ruote::Cukes.launch_variables || {})
+end
+
+Given /I launch the flow$/ do |process_definition|
+
+  Ruote::Cukes.last_wfid = Ruote::Cukes.engine.launch(
+    process_definition,
+    Ruote::Cukes.launch_fields || {},
+    Ruote::Cukes.launch_variables || {})
+end
+
+
+#
+# WORKITEMS
+
+When /^I reply with the workitem$/ do
+
+  Ruote::Cukes.storage_participant.reply(Ruote::Cukes.workitem)
+  Ruote::Cukes.workitem = nil
+end
+
+When /^I update the workitem with$/ do |table|
+
+  Ruote::Cukes.workitem.fields.merge!(table.to_hash)
+end
+
+When /^I reply$/ do
+
+  sleep 0.100 # give some time to the engine
+
+  Ruote::Cukes.storage_participant.reply(
+    Ruote::Cukes.storage_participant.all.first)
+end
+
+Then /I should have a workitem/ do
+
+  assert_not_nil Ruote::Cukes.workitem
+end
+
+Then /^the workitem (?:fields )?should include$/ do |table|
+
+  fields = table.to_hash
+
+  assert_nil fields.find { |k, v|
+    Ruote::Cukes.workitem.fields[k] != v
+  }
+end
+
+
+
+#
+# PROCESSES
+
+Then /^the process should be alive$/ do
+
+  assert_not_nil Ruote::Cukes.engine.process(Ruote::Cukes.last_wfid)
+end
+
+Then /^the process should have no errors$/ do
+
+  assert_equal [], Ruote::Cukes.engine.process(Ruote::Cukes.last_wfid).errors
+end
+
+Then /^the process should reach (?:participant )?(.+)$/ do |pname|
+
+  sleep 0.100 # give some time to the engine
+
+  assert_not_nil Ruote::Cukes.storage_participant.all.find { |wi|
+    wi.fei.wfid == Ruote::Cukes.last_wfid && wi.participant_name == pname
+  }
+end
+
+Then /^the process should be over$/ do
+
+  sleep 0.100 # give some time to the engine
+
+  assert_not_nil Ruote::Cukes.engine.context.logger.log.find do |r|
+    r['action'] == 'terminated' && r['wfid'] == Ruote::Cukes.last_wfid
+  end
+
+  assert_nil Ruote::Cukes.engine.process(Ruote::Cukes.last_wfid)
+end
+

data/lib/ruote/cukes/version.rb

@@ -0,0 +1,8 @@
+
+module Ruote
+module Cukes
+
+  VERSION = '2.1.9'
+end
+end
+

data/ruote-cukes.gemspec

@@ -0,0 +1,71 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruote-cukes}
+  s.version = "2.1.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Mettraux"]
+  s.date = %q{2010-06-14}
+  s.description = %q{
+cucumber helpers (steps) for testing ruote process definitions and participants
+    }
+  s.email = %q{jmettraux@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "CHANGELOG.txt",
+     "CREDITS.txt",
+     "README.rdoc",
+     "Rakefile",
+     "TODO.txt",
+     "features/basic.feature",
+     "features/embedded.feature",
+     "features/fields_and_json.feature",
+     "features/initial_fields.feature",
+     "features/over.feature",
+     "features/reply.feature",
+     "features/step_definitions/requiring.rb",
+     "features/update.feature",
+     "features/when.feature",
+     "features/whole.feature",
+     "flows/a.rb",
+     "flows/a_to_b.rb",
+     "lib/ruote/cukes.rb",
+     "lib/ruote/cukes/version.rb",
+     "ruote-cukes.gemspec"
+  ]
+  s.homepage = %q{http://ruote.rubyforge.org}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{ruote}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{cucumber helpers for testing ruote definitions and participants}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ruote>, [">= 2.1.9"])
+      s.add_runtime_dependency(%q<cucumber>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+    else
+      s.add_dependency(%q<ruote>, [">= 2.1.9"])
+      s.add_dependency(%q<cucumber>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<ruote>, [">= 2.1.9"])
+    s.add_dependency(%q<cucumber>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: ruote-cukes
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 2
+  - 1
+  - 9
+  version: 2.1.9
+platform: ruby
+authors: 
+- John Mettraux
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-14 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruote
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 9
+        version: 2.1.9
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: "\n\
+  cucumber helpers (steps) for testing ruote process definitions and participants\n    "
+email: jmettraux@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- CHANGELOG.txt
+- CREDITS.txt
+- README.rdoc
+- Rakefile
+- TODO.txt
+- features/basic.feature
+- features/embedded.feature
+- features/fields_and_json.feature
+- features/initial_fields.feature
+- features/over.feature
+- features/reply.feature
+- features/step_definitions/requiring.rb
+- features/update.feature
+- features/when.feature
+- features/whole.feature
+- flows/a.rb
+- flows/a_to_b.rb
+- lib/ruote/cukes.rb
+- lib/ruote/cukes/version.rb
+- ruote-cukes.gemspec
+has_rdoc: true
+homepage: http://ruote.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ruote
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: cucumber helpers for testing ruote definitions and participants
+test_files: []
+