pione 0.3.0 → 0.3.1

data/test/command/spec_pione-client.rb

@@ -1,56 +1,67 @@
 require 'pione/test-helper'
 require_relative 'command-behavior'
 
-describe "Pione::Command::PioneClient" do
-  behaves_like "command"
-
-  ### is this wrong?
-  # it "should execute a PIONE document" do
-  #   path = Temppath.create
-  #   args = ["example/HelloWorld/HelloWorld.pione", "-o", path.to_s]
-  #   res = TestHelper::Command.succeed do
-  #     Pione::Command::PioneClient.run args
-  #   end
-  #   Location[path + "message.txt"].should.exist
-  #   Location[path + "message.txt"].read.should.start_with "Hello, world!"
-  # end
-
-  it "should execute a PIONE document with stand alone mode" do
-    path = Temppath.create
-    args = ["example/HelloWorld/HelloWorld.pione", "-o", path.to_s, "--stand-alone"]
-    res = TestHelper::Command.succeed do
-      Pione::Command::PioneClient.run args
+TestHelper.scope do |this|
+  this::DIR = Location[File.dirname(__FILE__)] + "data" + "pione-client"
+
+  describe "Pione::Command::PioneClient" do
+    behaves_like "command"
+
+    it "should execute a PIONE document" do
+      path = Temppath.create
+      args = ["example/HelloWorld/HelloWorld.pione", "-o", path.to_s]
+      res = TestHelper::Command.succeed do
+        Pione::Command::PioneClient.run(args)
+      end
+      Location[path + "message.txt"].should.exist
+      Location[path + "message.txt"].read.should.start_with "Hello, world!"
     end
-    Location[path + "message.txt"].should.exist
-    Location[path + "message.txt"].read.should.start_with "Hello, world!"
-  end
 
-  # it "should execute a PIONE package" do
-  #   path = Temppath.create
-  #   args = ["example/HelloWorld/", "-o", path.to_s]
-  #   res = TestHelper::Command.succeed do
-  #     Pione::Command::PioneClient.run args
-  #   end
-  #   Location[path + "message.txt"].should.exist
-  #   Location[path + "message.txt"].read.should.start_with "Hello, world!"
-  # end
-
-  it "should execute a PIONE package with stand alone mode" do
-    path = Temppath.create
-    args = ["example/HelloWorld/", "-o", path.to_s, "--stand-alone"]
-    res = TestHelper::Command.succeed do
-      Pione::Command::PioneClient.run args
+    it "should execute a PIONE document with stand alone mode" do
+      path = Temppath.create
+      args = ["example/HelloWorld/HelloWorld.pione", "-o", path.to_s, "--stand-alone"]
+      TestHelper::Command.succeed do
+        Pione::Command::PioneClient.run(args)
+      end
+      Location[path + "message.txt"].should.exist
+      Location[path + "message.txt"].read.should.start_with "Hello, world!"
+    end
+
+    it "should execute a PIONE package" do
+      path = Temppath.create
+      args = ["example/HelloWorld/", "-o", path.to_s]
+      TestHelper::Command.succeed do
+        Pione::Command::PioneClient.run(args)
+      end
+      Location[path + "message.txt"].should.exist
+      Location[path + "message.txt"].read.should.start_with "Hello, world!"
     end
-    Location[path + "message.txt"].should.exist
-    Location[path + "message.txt"].read.should.start_with "Hello, world!"
-  end
 
-  it "should show parameters list of package" do
-    args = ["example/HelloWorld/HelloWorld.pione", "--list-params"]
-    res = TestHelper::Command.succeed do
-      Pione::Command::PioneClient.run args
+    it "should execute a PIONE package with stand alone mode" do
+      path = Temppath.create
+      args = ["example/HelloWorld/", "-o", path.to_s, "--stand-alone"]
+      TestHelper::Command.succeed do
+        Pione::Command::PioneClient.run(args)
+      end
+      Location[path + "message.txt"].should.exist
+      Location[path + "message.txt"].read.should.start_with "Hello, world!"
+    end
+
+    it "should fail with action error" do
+      doc = (this::DIR + "ActionError.pione").path.to_s
+      path = Temppath.create
+      args = [doc, "-o", path.to_s, "--stand-alone"]
+      TestHelper::Command.fail do
+        Pione::Command::PioneClient.run(args)
+      end
+    end
+
+    it "should show parameters list of package" do
+      args = ["example/HelloWorld/HelloWorld.pione", "--list-params"]
+      res = TestHelper::Command.succeed do
+        Pione::Command::PioneClient.run(args)
+      end
+      res.stdout.string.size.should > 0
     end
-    res.stdout.string.size.should > 0
   end
 end
-

data/test/command/spec_pione-command.rb

@@ -0,0 +1,18 @@
+require 'pione/test-helper'
+require_relative 'command-behavior'
+
+describe Pione::Command::PioneCommand do
+  behaves_like "command"
+
+  it "should call subcommand" do
+    TestHelper::Command.succeed do
+      Command::PioneCommand.run(["val", "1 + 1"])
+    end
+  end
+
+  it "should fail with unknown subcommand name" do
+    TestHelper::Command.fail do
+      Command::PioneCommand.run(["abcdefghijk"])
+    end
+  end
+end

data/test/command/spec_pione-compiler.rb

@@ -0,0 +1,13 @@
+require 'pione/test-helper'
+
+TestHelper.scope do |this|
+  this::PNML1 = Location[File.dirname(__FILE__)] + "data" + "pione-compiler" + "Sequence.pnml"
+
+  describe Pione::Command::PioneCompiler do
+    it "should compile from PNML to PIONE document" do
+      res = TestHelper::Command.succeed do
+        Command::PioneCompiler.run [this::PNML1.path.to_s]
+      end
+    end
+  end
+end

data/test/global/spec_item.rb

@@ -0,0 +1,77 @@
+require "pione/test-helper"
+
+describe do
+  it "should define an external item" do
+    item = Global.define_external_item(:test_external_item) do |item|
+      item.desc = "test external item"
+      item.init = 1
+      item.define_updater do |val|
+        "value is %s" % val
+      end
+    end
+
+    Global.test_external_item.should == "value is 1"
+    Global.test_external_item = 2
+    Global.test_external_item.should == "value is 2"
+
+    item.unregister
+
+    should.raise(NoMethodError) {Global.test_external_item}
+  end
+
+  it "should define an internal item" do
+    item = Global.define_internal_item(:test_internal_item) do |item|
+      item.desc = "test internal item"
+      item.init = 1
+      item.define_updater do |val|
+        "value is %s" % val
+      end
+    end
+
+    Global.test_internal_item.should == "value is 1"
+    Global.test_internal_item = 2
+    Global.test_internal_item.should == "value is 2"
+
+    item.unregister
+
+    should.raise(NoMethodError) {item.test_internal_item}
+  end
+
+  it "should define a computed item" do
+    item1 = Global.define_external_item(:test_external_item) do |item|
+      item.desc = "test external item"
+      item.type = :integer
+      item.init = 1
+      item.define_updater {|val| "external: %s" % val}
+    end
+
+    item2 = Global.define_internal_item(:test_internal_item) do |item|
+      item.desc = "test internal item"
+      item.type = :integer
+      item.init = 2
+      item.define_updater {|val| "internal: %s" % val}
+    end
+
+    item3 = item = Global.define_computed_item(:test_computed_item, [:test_external_item, :test_internal_item]) do |item|
+      item.desc = "test computed item"
+      item.define_updater do
+        "%s, %s" % [Global.test_external_item, Global.test_internal_item]
+      end
+    end
+
+    Global.test_computed_item.should == "external: 1, internal: 2"
+    Global.test_external_item = 2
+    Global.test_computed_item.should == "external: 2, internal: 2"
+    Global.test_internal_item = 1
+    Global.test_computed_item.should == "external: 2, internal: 1"
+    Global.test_external_item = 3
+    Global.test_internal_item = 4
+    Global.test_computed_item.should == "external: 3, internal: 4"
+
+    item1.unregister
+    item2.unregister
+    item3.unregister
+
+    should.raise(NoMethodError) {item.test_computed_item}
+  end
+end

data/test/lang/data/data-expr.yml

@@ -91,3 +91,8 @@
   - "'*.x' | '*.y' | '*.z' | '*.x' | '*.y' | '*.z' | '*.x' | '*.y' | '*.z'" :
       "('*.a' | '*.b' | '*.c').suffix('x' | 'y' | 'z')"
 
+"#join" :
+  - '"a"' : "'a'.join"
+  - '"a"' : "'a'.join(\":\")"
+  - '"a b c"' : "('a' | 'b' | 'c').join"
+  - '"a:b:c"' : "('a' | 'b' | 'c').join(\":\")"

data/test/rule-engine/data/action-handler/UsePackageScript.pione

@@ -0,0 +1,17 @@
+.@ PackageName :: "UsePackageScript"
+
+Rule R1
+  input '1.a'
+  output '1.b'
+Action
+  test.sh
+End
+
+Rule R2
+  input '1.a'
+  output '1.b'
+Action
+  not_exist.sh
+End
+
+

data/test/rule-engine/spec_action-handler.rb

@@ -1,94 +1,157 @@
 require 'pione/test-helper'
 
-location = Location[File.dirname(__FILE__)] + "spec_action-handler.pione"
-package_id = "SpecActionHandler"
-env = Lang::Environment.new.setup_new_package(package_id)
-Package::Document.load(env, location, "SpecActionHandler", nil, nil, "spec_action-handler.pione")
-
-describe 'Pione::RuleHandler::ActionHandler' do
-  before do
-    @ts = TestHelper::TupleSpace.create(self)
-
-    location = Location[Temppath.create]
-    location_a = location + "1.a"
-    location_b = location + "1.b"
-    location_a.create("1")
-    location_b.create("2")
-
-    param_set = Lang::ParameterSet.new(table: {
-        "*" => Lang::StringSequence.of("1"),
-        "INPUT" => Lang::Variable.new("I"),
-        "I" => Lang::KeyedSequence.new
-          .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.a"))
-          .put(Lang::IntegerSequence.of(2), Lang::DataExprSequence.of("1.b")),
-        "OUTPUT" => Lang::Variable.new("O"),
-        "O" => Lang::KeyedSequence.new
-          .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.c"))
-      })
-
-    tuple_a = TupleSpace::DataTuple.new(name: '1.a', location: location_a, time: Time.now)
-    tuple_b = TupleSpace::DataTuple.new(name: '1.b', location: location_b, time: Time.now)
-    inputs = [tuple_a, tuple_b]
-
-    domain_id = Util::DomainID.generate(package_id, @rule_name, inputs, param_set)
-    tuple_a.domain = domain_id
-    tuple_b.domain = domain_id
-    inputs.each {|t| write(t) }
-
-    @handler_sh1 = RuleEngine.make(@ts, env, package_id, 'Shell1', inputs, param_set, domain_id, 'root')
-    @handler_sh2 = RuleEngine.make(@ts, env, package_id, 'Shell2', inputs, param_set, domain_id, 'root')
-    @handler_ruby = RuleEngine.make(@ts, env, package_id, 'Ruby', inputs, param_set, domain_id, 'root')
-  end
+TestHelper.scope do |this|
+  this::DIR = Location[File.dirname(__FILE__)] + "data" + "action-handler"
+  this::BASIC_ACTION = this::DIR + "BasicAction.pione"
+  this::USE_PACKAGE_SCRIPT = this::DIR + "UsePackageScript.pione"
 
-  after do
-    @ts.terminate
-  end
+  describe 'Pione::RuleHandler::ActionHandler' do
+    describe "basic actions" do
+      before do
+        env = Lang::Environment.new.setup_new_package("BasicAction")
+        package_id = "BasicAction"
+        Package::Document.load(env, this::BASIC_ACTION, package_id, nil, nil, "BasicAction.pione")
 
-  it 'should be action handler' do
-    @handler_sh1.should.be.kind_of(RuleEngine::ActionHandler)
-    @handler_sh2.should.be.kind_of(RuleEngine::ActionHandler)
-    @handler_ruby.should.be.kind_of(RuleEngine::ActionHandler)
-  end
+        @ts = TestHelper::TupleSpace.create(self)
 
-  it 'should have working directory' do
-    @handler_sh1.working_directory.should.exist
-    @handler_sh2.working_directory.should.exist
-    @handler_ruby.working_directory.should.exist
-  end
+        location = Location[Temppath.create]
+        location_a = location + "1.a"
+        location_b = location + "1.b"
+        location_a.create("1")
+        location_b.create("2")
 
-  it 'should make different working directories' do
-    @handler_sh1.working_directory.should != @handler_sh2.working_directory
-    @handler_sh2.working_directory.should != @handler_ruby.working_directory
-    @handler_ruby.working_directory.should != @handler_sh1.working_directory
-  end
+        param_set = Lang::ParameterSet.new(table: {
+            "*" => Lang::StringSequence.of("1"),
+            "INPUT" => Lang::Variable.new("I"),
+            "I" => Lang::KeyedSequence.new
+              .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.a"))
+              .put(Lang::IntegerSequence.of(2), Lang::DataExprSequence.of("1.b")),
+            "OUTPUT" => Lang::Variable.new("O"),
+            "O" => Lang::KeyedSequence.new
+              .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.c"))
+          })
 
-  it 'should write a shell script' do
-    @handler_sh1.write_shell_script do |path|
-      File.should.exist(path)
-      File.should.executable(path)
-      File.read(path).should == "VAL1=`cat 1.a`;\nVAL2=`cat 1.b`;\nexpr $VAL1 + $VAL2 > 1.c\n"
-    end
-  end
+        tuple_a = TupleSpace::DataTuple.new(name: '1.a', location: location_a, time: Time.now)
+        tuple_b = TupleSpace::DataTuple.new(name: '1.b', location: location_b, time: Time.now)
+        inputs = [tuple_a, tuple_b]
+
+        domain_id = Util::DomainID.generate(package_id, @rule_name, inputs, param_set)
+        tuple_a.domain = domain_id
+        tuple_b.domain = domain_id
+        inputs.each {|t| write(t) }
+
+        @handler_sh1 = RuleEngine.make(@ts, env, package_id, 'Shell1', inputs, param_set, domain_id, 'root')
+        @handler_sh2 = RuleEngine.make(@ts, env, package_id, 'Shell2', inputs, param_set, domain_id, 'root')
+        @handler_ruby = RuleEngine.make(@ts, env, package_id, 'Ruby', inputs, param_set, domain_id, 'root')
+      end
+
+      after do
+        @ts.terminate
+      end
+
+      it 'should be action handler' do
+        @handler_sh1.should.be.kind_of(RuleEngine::ActionHandler)
+        @handler_sh2.should.be.kind_of(RuleEngine::ActionHandler)
+        @handler_ruby.should.be.kind_of(RuleEngine::ActionHandler)
+      end
+
+      it 'should have working directory' do
+        @handler_sh1.working_directory.should.exist
+        @handler_sh2.working_directory.should.exist
+        @handler_ruby.working_directory.should.exist
+      end
+
+      it 'should make different working directories' do
+        @handler_sh1.working_directory.should != @handler_sh2.working_directory
+        @handler_sh2.working_directory.should != @handler_ruby.working_directory
+        @handler_ruby.working_directory.should != @handler_sh1.working_directory
+      end
+
+      it 'should write a shell script' do
+        @handler_sh1.write_shell_script do |path|
+          File.should.exist(path)
+          File.should.executable(path)
+          File.read(path).should == "VAL1=`cat 1.a`;\nVAL2=`cat 1.b`;\nexpr $VAL1 + $VAL2 > 1.c\n"
+        end
+      end
+
+      it 'should call shell script' do
+        @handler_sh1.setup_working_directory
+        @handler_sh1.write_shell_script do |path|
+          @handler_sh1.call_shell_script(path)
+          (@handler_sh1.working_directory + "1.b").should.exist
+        end
+      end
 
-  it 'should call shell script' do
-    @handler_sh1.setup_working_directory
-    @handler_sh1.write_shell_script do |path|
-      @handler_sh1.call_shell_script(path)
-      (@handler_sh1.working_directory + "1.b").should.exist
+      [:sh1, :sh2, :ruby].each do |sym|
+        it "should execute an action: #{sym}" do
+          # execute and get result
+          handler = eval("@handler_#{sym}")
+          outputs = handler.execute
+          outputs[0][0].name.should == '1.c'
+          outputs[0][0].location.read.chomp.should == "3"
+          should.not.raise do
+            read(TupleSpace::DataTuple.new(name: '1.c', domain: handler.domain_id))
+          end
+        end
+      end
     end
-  end
 
-  [:sh1, :sh2, :ruby].each do |sym|
-    it "should execute an action: #{sym}" do
-      # execute and get result
-      handler = eval("@handler_#{sym}")
-      outputs = handler.execute
-      outputs[0][0].name.should == '1.c'
-      outputs[0][0].location.read.chomp.should == "3"
-      should.not.raise do
-        read(TupleSpace::DataTuple.new(name: '1.c', domain: handler.domain_id))
+    describe "use package script" do
+      before do
+        env = Lang::Environment.new.setup_new_package("UsePackageScript")
+        package_id = "UsePackageScript"
+        Package::Document.load(env, this::USE_PACKAGE_SCRIPT, package_id, nil, nil, "UsePackageScript.pione")
+
+        @ts = TestHelper::TupleSpace.create(self)
+
+        location = Location[Temppath.create]
+        location_a = location + "1.a"
+        location_a.create("1")
+
+        param_set = Lang::ParameterSet.new(table: {
+            "*" => Lang::StringSequence.of("1"),
+            "INPUT" => Lang::Variable.new("I"),
+            "I" => Lang::KeyedSequence.new
+              .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.a")),
+            "OUTPUT" => Lang::Variable.new("O"),
+            "O" => Lang::KeyedSequence.new
+              .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.b"))
+          })
+
+        tuple_a = TupleSpace::DataTuple.new(name: '1.a', location: location_a, time: Time.now)
+        inputs = [tuple_a]
+
+        sh = (@ts.base_location + "package" + "bin" + "test.sh")
+        sh.write("echo abc > 1.b")
+        sh.path.chmod(0700)
+
+        domain_id = Util::DomainID.generate(package_id, @rule_name, inputs, param_set)
+        tuple_a.domain = domain_id
+        inputs.each {|t| write(t) }
+
+        @handler1 = RuleEngine.make(@ts, env, package_id, 'R1', inputs, param_set, domain_id, 'root')
+        @handler2 = RuleEngine.make(@ts, env, package_id, 'R2', inputs, param_set, domain_id, 'root')
+      end
+
+      after do
+        @ts.terminate
+      end
+
+      it "should call package script" do
+        outputs = @handler1.execute
+        outputs[0][0].name.should == '1.b'
+        outputs[0][0].location.read.chomp.should == "abc"
+        should.not.raise do
+          read(TupleSpace::DataTuple.new(name: '1.b', domain: @handler1.domain_id))
+        end
+      end
+
+      it "should raise action error because the script not found" do
+        should.raise(RuleEngine::ActionError) do
+          outputs = @handler2.execute
+        end
       end
     end
   end
 end
-