pione 0.2.2 → 0.3.0

data/test/package/spec_scenario-scanner.rb

@@ -0,0 +1,92 @@
+require 'pione/test-helper'
+
+TestHelper.scope do |this|
+  # simple scenario
+  this::S1 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS1"
+
+  # scenario without inputs
+  this::S2 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS2"
+
+  # scenario with parameter set
+  this::S3 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS3"
+
+  # invalid scenario because of no scenario names
+  this::S4 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS4"
+
+  # invalid scenario because of multiple scenario names
+  this::S5 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS5"
+
+  # invalid scenario because of multiple parameter sets
+  this::S6 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS6"
+
+  # broken scenario that doesn't have scenario document
+  this::S7 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS7"
+
+  # broken scenario that raises parser error
+  this::S8 = Location[File.dirname(__FILE__)] + "data" + "ScenarioScannerS8"
+
+  describe Pione::Package::ScenarioScanner do
+    it "should scan scenario direcotry: S1" do
+      s1 = Package::ScenarioScanner.new(this::S1).scan
+      s1.name.should == "S1"
+      s1.param_set.should.nil
+      s1.inputs.size.should == 3
+      s1.inputs.should.include "input/i1"
+      s1.inputs.should.include "input/i2"
+      s1.inputs.should.include "input/i3"
+      s1.outputs.size.should == 3
+      s1.outputs.should.include "output/o1"
+      s1.outputs.should.include "output/o2"
+      s1.outputs.should.include "output/o3"
+    end
+
+    it "should scan scenario direcotry: S2" do
+      s2 = Package::ScenarioScanner.new(this::S2).scan
+      s2.name.should == "S2"
+      s2.param_set.should.nil
+      s2.inputs.size.should == 0
+      s2.outputs.size.should == 1
+      s2.outputs.should.include "output/o1"
+    end
+
+    it "should scan scenario direcotry: S3" do
+      s3 = Package::ScenarioScanner.new(this::S3).scan
+      s3.name.should == "S3"
+      s3.param_set.should == "{PARAM: 1}"
+    end
+
+    it "should raise exception because of no scenario names" do
+      should.raise(Package::InvalidScenario) do
+        Package::ScenarioScanner.new(this::S4).scan
+      end
+    end
+
+    it "should raise exception because of multiple scenario names" do
+      should.raise(Package::InvalidScenario) do
+        Package::ScenarioScanner.new(this::S5).scan
+      end
+    end
+
+    it "should raise exception because of multiple parameter set" do
+      should.raise(Package::InvalidScenario) do
+        p Package::ScenarioScanner.new(this::S6).scan
+      end
+    end
+
+    it "should be faluse because of no scenario documents" do
+      Package::ScenarioScanner.new(this::S7).scan.should.false
+    end
+
+    it "should raise exception because of parser error" do
+      should.raise(Package::InvalidScenario) do
+        Package::ScenarioScanner.new(this::S8).scan
+      end
+    end
+
+    it "should raise exception when scanned location is not local" do
+      should.raise(Location::NotLocal) do
+        Package::ScenarioScanner.new(Location["http://example.com/P/scenario"])
+      end
+    end
+  end
+end

data/test/patch/spec_rinda-patch.rb

@@ -1,4 +1,4 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 
 describe 'Rinda patch' do
   it 'should be different tuples that have different contentes' do

data/test/patch/spec_uri-patch.rb

@@ -1,4 +1,4 @@
-require_relative '../test-util'
+require 'pione/test-helper'
 
 describe 'URI patch' do
   it 'should be a directory' do

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

@@ -0,0 +1,94 @@
+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
+
+  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
+
+  [: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
+

data/test/rule-engine/spec_data-finder.rb

@@ -0,0 +1,94 @@
+require 'pione/test-helper'
+
+#
+# test cases
+#
+yamlname = 'spec_data-finder.yml'
+ymlpath = File.join(File.dirname(__FILE__), yamlname)
+testcases = YAML.load_file(ymlpath)
+
+describe 'Pione::RuleEngine::DataFinder' do
+  before do
+    @space = TestHelper::TupleSpace.create(self)
+    @env = TestHelper::Lang.env
+  end
+
+  after do
+    @space.terminate
+  end
+
+  it 'should find a data tuple by complete name' do
+    tuples = [
+      TupleSpace::DataTuple.new('test', '1.a', nil, Time.now),
+      TupleSpace::DataTuple.new('test', '2.a', nil, Time.now),
+      TupleSpace::DataTuple.new('test', '3.a', nil, Time.now)
+    ]
+    tuples.each {|t| write(t) }
+    finder = RuleEngine::DataFinder.new(tuple_space_server, 'test')
+    finder.send(:find_tuples_by_condition, '1.a').should == [tuples.first]
+  end
+
+  it 'should find data tuples by incomplete name' do
+    tuples = [
+      TupleSpace::DataTuple.new('test', '1.a', nil, Time.now),
+      TupleSpace::DataTuple.new('test', '2.a', nil, Time.now),
+      TupleSpace::DataTuple.new('test', '3.a', nil, Time.now)
+    ]
+    tuples.each {|t| write(t) }
+    finder = RuleEngine::DataFinder.new(tuple_space_server, 'test')
+    res = finder.send(:find_tuples_by_condition, Lang::DataExprSequence.of('*.a'))
+    tuples.each {|t| res.should.include t }
+  end
+
+  it 'should find no data' do
+    tuple = TupleSpace::DataTuple.new('test', '2.a', nil, Time.now)
+    tuple_space_server.write(tuple)
+    finder = RuleEngine::DataFinder.new(tuple_space_server, 'test')
+    finder.send(:find_tuples_by_condition, '1.a').should.empty
+  end
+
+  it 'should find in the domain' do
+    tuple = TupleSpace::DataTuple.new('other', '1.a', nil, Time.now)
+    tuple_space_server.write(tuple)
+    finder = RuleEngine::DataFinder.new(tuple_space_server, 'test')
+    finder.send(:find_tuples_by_condition, '1.a').should.empty
+  end
+
+  testcases.each do |testname, testcase|
+    it "should find input combination: #{testname}" do
+      finder = RuleEngine::DataFinder.new(tuple_space_server, 'test')
+
+      # tuples
+      testcase['tuples'].map {|name|
+        TupleSpace::DataTuple.new(name: name, domain: 'test', location: Location[name])
+      }.each do |tuple|
+        write(tuple)
+      end
+
+      # query
+      query = testcase['query'].map {|d|
+        if d.kind_of?(Hash)
+          modifier = d["modifier"] == "all" ? :all : :each
+          DataExpr.new(d["name"], modifier)
+        else
+          TestHelper::Lang.expr!(@env, d)
+        end
+      }
+
+      # results
+      results = testcase['results'].map {|res|
+        res.map {|name|
+          if name.kind_of?(Array)
+            name.map {|n| TupleSpace::DataTuple.new(name: n, domain: 'test', location: Location[n]) }
+          else
+            TupleSpace::DataTuple.new(name: name, domain: 'test', location: Location[name])
+          end
+        }
+      }
+
+      # test
+      enum = Enumerator.new(finder, :find, :input, query, @env)
+      enum.to_a.map{|env, combination| combination }.should == results
+    end
+  end
+end

data/test/{tuple-space → rule-engine}/spec_data-finder.yml

@@ -6,7 +6,18 @@ case1:
   query:
     - "'1.a'"
   results:
-    - [ 1.a ]
+    - [[1.a]]
+
+case1-2:
+  tuples:
+    - 1.a
+    - 2.a
+    - 3.a
+  query:
+    - "'1.a'"
+    - "'2.a'"
+  results:
+    - [[1.a], [2.a]]
 
 case2:
   tuples:
@@ -16,9 +27,9 @@ case2:
   query:
     - "'*.a'"
   results:
-    - [ 1.a ]
-    - [ 2.a ]
-    - [ 3.a ]
+    - [[1.a]]
+    - [[2.a]]
+    - [[3.a]]
 
 case3:
   tuples:
@@ -42,9 +53,9 @@ case4:
     - "'*.a'"
     - "'{$*}.b'"
   results:
-    - [ 1.a, 1.b ]
-    - [ 2.a, 2.b ]
-    - [ 3.a, 3.b ]
+    - [[1.a], [1.b]]
+    - [[2.a], [2.b]]
+    - [[3.a], [3.b]]
 
 case5:
   tuples:
@@ -58,9 +69,9 @@ case5:
     - "'*.a'.all"
     - "'*.b'"
   results:
-    - [ [1.a, 2.a, 3.a], 1.b ]
-    - [ [1.a, 2.a, 3.a], 2.b ]
-    - [ [1.a, 2.a, 3.a], 3.b ]
+    - [[1.a, 2.a, 3.a], [1.b]]
+    - [[1.a, 2.a, 3.a], [2.b]]
+    - [[1.a, 2.a, 3.a], [3.b]]
 
 case6:
   tuples:
@@ -74,9 +85,9 @@ case6:
     - "'*.a'"
     - "'*.b'.all"
   results:
-    - [ 1.a, [1.b, 2.b, 3.b] ]
-    - [ 2.a, [1.b, 2.b, 3.b] ]
-    - [ 3.a, [1.b, 2.b, 3.b] ]
+    - [[1.a], [1.b, 2.b, 3.b]]
+    - [[2.a], [1.b, 2.b, 3.b]]
+    - [[3.a], [1.b, 2.b, 3.b]]
 
 case7:
   tuples:
@@ -104,15 +115,15 @@ case8:
     - "'*.a'"
     - "'*.b'"
   results:
-    - [ 1.a, 1.b ]
-    - [ 1.a, 2.b ]
-    - [ 1.a, 3.b ]
-    - [ 2.a, 1.b ]
-    - [ 2.a, 2.b ]
-    - [ 2.a, 3.b ]
-    - [ 3.a, 1.b ]
-    - [ 3.a, 2.b ]
-    - [ 3.a, 3.b ]
+    - [[1.a], [1.b]]
+    - [[1.a], [2.b]]
+    - [[1.a], [3.b]]
+    - [[2.a], [1.b]]
+    - [[2.a], [2.b]]
+    - [[2.a], [3.b]]
+    - [[3.a], [1.b]]
+    - [[3.a], [2.b]]
+    - [[3.a], [3.b]]
 
 case9:
   tuples:
@@ -123,9 +134,9 @@ case9:
     - "'*.a'"
     - "'*.b' or null"
   results:
-    - [ 1.a, [] ]
-    - [ 2.a, [] ]
-    - [ 3.a, [] ]
+    - [[1.a], []]
+    - [[2.a], []]
+    - [[3.a], []]
 
 case10:
   tuples:
@@ -139,6 +150,6 @@ case10:
     - "'*.a'"
     - "'*.b'.all or null"
   results:
-    - [ 1.a, [1.b, 2.b, 3.b] ]
-    - [ 2.a, [1.b, 2.b, 3.b] ]
-    - [ 3.a, [1.b, 2.b, 3.b] ]
+    - [ [1.a], [1.b, 2.b, 3.b] ]
+    - [ [2.a], [1.b, 2.b, 3.b] ]
+    - [ [3.a], [1.b, 2.b, 3.b] ]

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

@@ -0,0 +1,170 @@
+require 'pione/test-helper'
+
+package_id = "SpecEmptyHandler"
+env = Lang::Environment.new.setup_new_package(package_id)
+TestHelper::Lang.package_context!(env, <<-PIONE)
+Rule TestTouch
+  input '*.a'
+  output '{$*}.b'.touch
+End
+
+Rule TestRemove
+  input '*.a'
+  output '{$*}.b'.remove
+End
+PIONE
+
+describe 'Pione::RuleHandler::EmptyHandler' do
+  describe 'touch with nonexistance' do
+    before do
+      @space = TestHelper::TupleSpace.create(self)
+
+      # setup data
+      location = Location[Temppath.create]
+      location_a = location + "1.a"
+      location_b = location + "1.b"
+      location_a.create("1")
+      location_b.create("2")
+
+      # setup param set
+      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"))
+        })
+
+      domain_id = Util::DomainID.generate(package_id, 'TestTouch', [['1.a']], param_set)
+      @tuple_a = TupleSpace::DataTuple.new(name: '1.a', location: location_a, domain: domain_id, time: Time.now)
+      @inputs = [@tuple_a]
+
+      write(@tuple_a)
+
+      @handler = RuleEngine.make(@space, env, package_id, 'TestTouch', @inputs, param_set, domain_id, 'root')
+    end
+
+    after do
+      @space.terminate
+    end
+
+    it 'should be action handler' do
+      @handler.should.be.kind_of(RuleEngine::EmptyHandler)
+    end
+
+    it 'should create a new data by touch operation' do
+      outputs = @handler.execute
+      outputs.size.should == 1
+      outputs[0][0].name.should == '1.b'
+      # data should be empty
+      outputs[0][0].location.read.should == ""
+      # check existance of data tuple
+      should.not.raise do
+        read(TupleSpace::DataTuple.new(name: '1.b', domain: @handler.domain_id))
+      end
+    end
+  end
+
+  describe 'touch with existance' do
+    before do
+      @space = TestHelper::TupleSpace.create(self)
+
+      # setup data
+      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")),
+          "OUTPUT" => Lang::Variable.new("O"),
+          "O" => Lang::KeyedSequence.new
+            .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.b"))
+        })
+
+      domain_id = Util::DomainID.generate(package_id, 'TestTouch', [['1.a']], param_set)
+      @tuple_a = TupleSpace::DataTuple.new(name: '1.a', location: location_a, domain: domain_id, time: Time.now)
+      @tuple_b = TupleSpace::DataTuple.new(name: '1.b', location: location_b, domain: domain_id, time: Time.now)
+      @inputs = [@tuple_a]
+
+      write(@tuple_a)
+      write(@tuple_b)
+
+      @handler = RuleEngine.make(@space, env, package_id, 'TestTouch', @inputs, param_set, domain_id, 'root')
+    end
+
+    after do
+      @space.terminate
+    end
+
+    it 'should be empty handler' do
+      @handler.should.be.kind_of(RuleEngine::EmptyHandler)
+    end
+
+    it 'should update time of data tuple by touch operation' do
+      outputs = @handler.execute
+      outputs.size.should == 1
+      outputs[0][0].name.should == '1.b'
+      outputs[0][0].location.read.should == "2"
+      outputs[0][0].time.should > @tuple_b.time
+      should.not.raise do
+        read(TupleSpace::DataTuple.new(name: '1.b', domain: @handler.domain_id))
+      end
+    end
+  end
+
+  describe 'remove' do
+    before do
+      @space = TestHelper::TupleSpace.create(self)
+
+      # setup data
+      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")),
+          "OUTPUT" => Lang::Variable.new("O"),
+          "O" => Lang::KeyedSequence.new
+            .put(Lang::IntegerSequence.of(1), Lang::DataExprSequence.of("1.b"))
+        })
+
+      domain_id = Util::DomainID.generate(package_id, 'TestRemove', [['1.a']], param_set)
+      @tuple_a = TupleSpace::DataTuple.new(name: '1.a', location: location_a, domain: domain_id, time: Time.now)
+      @tuple_b = TupleSpace::DataTuple.new(name: '1.b', location: location_b, domain: domain_id, time: Time.now)
+      @inputs = [@tuple_a]
+
+      write(@tuple_a)
+      write(@tuple_b)
+
+      @handler = RuleEngine.make(@space, env, package_id, 'TestRemove', @inputs, param_set, domain_id, 'root')
+    end
+
+    after do
+      @space.terminate
+    end
+
+    it 'should be action handler' do
+      @handler.should.be.kind_of(RuleEngine::EmptyHandler)
+    end
+
+    it 'should remove tuple' do
+      read!(TupleSpace::DataTuple.new(name: '1.b', domain: @handler.domain_id)).should.not.nil
+      should.not.raise { @handler.handle }
+      # FIXME: remove operation dones't remove data tuple now, but it should remove
+      #read!(TupleSpace::DataTuple.new(name: '1.b', domain: @handler.domain_id)).should.nil
+    end
+  end
+end
+