pione 0.1.0

data/test/patch/spec_rinda-patch.rb

@@ -0,0 +1,32 @@
+require_relative '../test-util'
+
+describe 'Rinda patch' do
+  it 'should be different tuples that have different contentes' do
+    ts = Rinda::TupleSpace.new
+    e1 = ts.write([:abc, 1])
+    e2 = ts.write([:abc, 2])
+    e1.should.not == e2
+    e2.should.not == e1
+    ts.read_all([:abc, nil]).should == [[:abc, 1], [:abc, 2]]
+    ts.read([:abc, 1]).should == [:abc, 1]
+    ts.read([:abc, 2]).should == [:abc, 2]
+  end
+
+  it 'should not unify normal tuples' do
+    ts = Rinda::TupleSpace.new
+    e1 = ts.write([:abc, 1])
+    e2 = ts.write([:abc, 1])
+    e1.should == e2
+    e2.should == e1
+    ts.read_all([:abc, nil]).should == [[:abc, 1], [:abc, 1]]
+    ts.read([:abc, 1]).should == [:abc, 1]
+  end
+
+  it 'should unify domain based tuples' do
+    ts = Rinda::TupleSpace.new
+    ts.write([:working, "test", "test"])
+    ts.write([:working, "test", "test"])
+    ts.write([:working, "test", "test"])
+    ts.read_all([:working, nil, nil]).should == [[:working, "test", "test"]]
+  end
+end

data/test/patch/spec_uri-patch.rb

@@ -0,0 +1,23 @@
+require_relative '../test-util'
+
+describe 'URI patch' do
+  it 'should be a directory' do
+    URI.parse("http://locahost/a/b/c/").should.be.directory
+  end
+
+  it 'should be not a directory' do
+    URI.parse("http://locahost/a/b/c").should.be.not.directory
+  end
+
+  it 'should be a file' do
+    URI.parse("http://locahost/a/b/c").should.be.file
+  end
+
+  it 'should be not a file' do
+    URI.parse("http://locahost/a/b/c/").should.be.not.file
+  end
+
+  it 'should convert as a directory' do
+    URI.parse("http://locahost/a/b/c").as_directory.should.be.directory
+  end
+end

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

@@ -0,0 +1,135 @@
+require_relative '../test-util'
+
+$doc = Document.parse(<<-DOCUMENT)
+Rule Test
+  input '*.a'
+  output '{$*}.b'
+Action
+  nkf -w {$INPUT[1]} > {$OUTPUT[1]}
+End
+
+Rule Shell1
+  input '*.a'
+  input '{$*}.b'
+  output '{$*}.c'
+Action
+  VAL1=`cat {$INPUT[1]}`;
+  VAL2=`cat {$INPUT[2]}`;
+  expr $VAL1 + $VAL2 > {$OUTPUT[1]}
+End
+
+Rule Shell2
+  input '*.a'
+  input '{$*}.b'
+  output '{$*}.c'.stdout
+Action
+  VAL1=`cat {$INPUT[1]}`;
+  VAL2=`cat {$INPUT[2]}`;
+  expr $VAL1 + $VAL2
+End
+
+Rule Ruby
+  input '*.a'
+  input '{$*}.b'
+  output '{$*}.c'.stdout
+Action
+#!/usr/bin/env ruby
+  val1 = File.read('{$INPUT[1]}').to_i
+  val2 = File.read('{$INPUT[2]}').to_i
+  puts val1 + val2
+End
+DOCUMENT
+
+describe 'ActionHandler' do
+  before do
+    create_remote_tuple_space_server
+    @rule_test = $doc['&main:Test']
+    @rule_sh1 = $doc['&main:Shell1']
+    @rule_sh2 = $doc['&main:Shell2']
+    @rule_ruby = $doc['&main:Ruby']
+
+    @tmpdir = Dir.mktmpdir
+    uri_a = "local:#{@tmpdir}/1.a"
+    uri_b = "local:#{@tmpdir}/1.b"
+    Resource[uri_a].create("1")
+    Resource[uri_b].create("2")
+
+    @tuple_a = Tuple[:data].new(name: '1.a', uri: uri_a, domain: "test")
+    @tuple_b = Tuple[:data].new(name: '1.b', uri: uri_b, domain: "test")
+    @tuples = [@tuple_a, @tuple_b]
+    @tuples.each {|t| write(t) }
+
+    @handler_sh1 = @rule_sh1.make_handler(
+      tuple_space_server, @tuples, Parameters.empty, []
+    )
+    @handler_sh2 = @rule_sh1.make_handler(
+      tuple_space_server, @tuples, Parameters.empty, []
+    )
+    @handler_ruby = @rule_sh1.make_handler(
+      tuple_space_server, @tuples, Parameters.empty, []
+    )
+  end
+
+  after do
+    tuple_space_server.terminate
+  end
+
+  it 'should be made from action rule' do
+    params = Parameters.empty
+    handler = @rule_test.make_handler(
+      tuple_space_server, [@tuple_a], params, []
+    )
+    handler.should.be.kind_of(RuleHandler::ActionHandler)
+  end
+
+  it 'should make working directory' do
+    Dir.should.exist(@handler_sh1.working_directory)
+    Dir.should.exist(@handler_sh2.working_directory)
+    Dir.should.exist(@handler_ruby.working_directory)
+  end
+
+  it 'should write a shell script' do
+    quiet_mode do
+      process_name = "test-process-123"
+      process_id = "xyz"
+      opts = {:process_name => process_name, :process_id => process_id}
+      handler = @rule_test.make_handler(
+        tuple_space_server, [@tuple_a], Parameters.empty, []
+      )
+      handler.send("write_shell_script") do |path|
+        File.should.exist(path)
+        File.should.executable(path)
+        File.read(path).should == "  nkf -w 1.a > 1.b\n"
+      end
+    end
+  end
+
+  it 'should call shell script' do
+    quiet_mode do
+      handler = @rule_test.make_handler(
+        tuple_space_server, [@tuple_a], Parameters.empty, []
+      )
+      handler.send("write_shell_script") do |path|
+        handler.send("call_shell_script", path)
+        File.should.exist(File.join(handler.working_directory, "1.b"))
+      end
+    end
+  end
+
+  [:sh1, :sh2, :ruby].each do |sym|
+    it "should execute an action: #{sym}" do
+      quiet_mode do
+        # execute and get result
+        handler = eval("@handler_#{sym}")
+        outputs = handler.execute
+        res = outputs.first
+        res.name.should == '1.c'
+        Resource[res.uri].read.chomp.should == "3"
+        should.not.raise do
+          read(Tuple[:data].new(name: '1.c', domain: handler.domain))
+        end
+      end
+    end
+  end
+end
+

data/test/rule-handler/spec_flow-handler.rb

@@ -0,0 +1,127 @@
+require_relative '../test-util'
+
+$document = Document.parse(<<DOCUMENT)
+Rule Test
+  input '*.a'
+  input '{$INPUT[1].MATCH[1]}.b'
+  output '{$INPUT[1].MATCH[1]}.c'
+Flow
+  rule TestAction
+End
+DOCUMENT
+
+describe 'FlowRule' do
+  before do
+    create_remote_tuple_space_server
+    @rule = $document["&main:Test"]
+  end
+
+  after do
+    tuple_space_server.terminate
+  end
+
+  it 'should not be an action' do
+    @rule.should.not.action
+  end
+
+  it 'should be a flow' do
+    @rule.should.flow
+  end
+
+  it 'should make action handler' do
+    dir = Dir.mktmpdir
+    uri_a = "local:#{dir}/1.a"
+    uri_b = "local:#{dir}/1.b"
+    Resource[uri_a].create("1")
+    Resource[uri_b].create("2")
+
+    inputs = [
+      Tuple[:data].new(name: '1.a', uri: uri_a),
+      Tuple[:data].new(name: '1.b', uri: uri_b)
+    ]
+
+    params = Parameters.empty
+    handler = @rule.make_handler(tuple_space_server, inputs, params, [])
+    handler.should.be.kind_of(RuleHandler::FlowHandler)
+  end
+end
+
+doc = Document.parse(<<-DOCUMENT)
+Rule Test
+  input '*.a'
+  input '{$*}.b'
+  output '{$*}.c'
+Flow
+  rule Shell
+End
+
+Rule Shell
+  input '*.a'
+  input '{$*}.b'
+  output '{$*}.c'
+Action
+VAL1=`cat {$INPUT[1]}`;
+VAL2=`cat {$INPUT[2]}`;
+expr $VAL1 + $VAL2 > {$OUTPUT[1]}
+End
+
+Rule VariableBindingErrorTest
+  input '*.a'
+  output '*.b'
+Flow
+  rule Test
+End
+DOCUMENT
+
+describe 'FlowHandler' do
+  before do
+    create_remote_tuple_space_server
+    @rule = doc['&main:Test']
+    write(Tuple[:rule].new('&main:Shell', doc['&main:Shell'], :known))
+
+    dir = Dir.mktmpdir
+    uri_a = "local:#{dir}/1.a"
+    uri_b = "local:#{dir}/1.b"
+    Resource[uri_a].create("1")
+    Resource[uri_b].create("2")
+
+    @tuples = [
+      Tuple[:data].new('test', '1.a', uri_a, Time.now),
+      Tuple[:data].new('test', '1.b', uri_b, Time.now)
+    ]
+    @tuples.each {|t| write(t) }
+
+    @handler = @rule.make_handler(
+      tuple_space_server,
+      @tuples,
+      Parameters.empty,
+      [],
+      {:domain => 'test'}
+    )
+  end
+
+  after do
+    tuple_space_server.terminate
+  end
+
+  it "should execute a flow" do
+    # execute and get result
+    quiet_mode do
+      thread = Thread.new { @handler.execute }
+      task = read(Tuple[:task].new)
+      task.rule_path.should == '&main:Shell'
+      task.inputs.map{|d|d.name}.sort.should == ['1.a', '1.b']
+      task.params.should.empty
+      task.features.should.empty
+      Agent[:task_worker].start(tuple_space_server)
+      thread.join
+      res = @handler.outputs.first
+      res.name.should == '1.c'
+      Resource[res.uri].read.chomp.should == "3"
+      should.not.raise do
+        read(Tuple[:data].new(name: '1.c', domain: @handler.domain))
+      end
+    end
+
+  end
+end

data/test/spec_common.rb

@@ -0,0 +1,14 @@
+require_relative 'test-util'
+
+describe 'Common' do
+  it 'should ignore exception' do
+    should.not.raise(Exception) do
+      ignore_exception { raise Exception }
+    end
+  end
+
+  it 'should get hostname' do
+    get_hostname.should == `hostname`.chomp
+  end
+end
+

data/test/spec_data-finder.rb

@@ -0,0 +1,88 @@
+require_relative 'test-util'
+
+#
+# test cases
+#
+yamlname = 'spec_data-finder.yml'
+ymlpath = File.join(File.dirname(__FILE__), yamlname)
+testcases = YAML.load_file(ymlpath)
+
+describe 'DataFinder' do
+  before do
+    create_remote_tuple_space_server
+  end
+
+  after do
+    tuple_space_server.terminate
+  end
+
+  it 'should find a data tuple by complete name' do
+    tuples = [
+      Tuple[:data].new('test', '1.a', nil, Time.now),
+      Tuple[:data].new('test', '2.a', nil, Time.now),
+      Tuple[:data].new('test', '3.a', nil, Time.now)
+    ]
+    tuples.each {|t| tuple_space_server.write(t) }
+    finder = DataFinder.new(tuple_space_server, 'test')
+    finder.send(:find_by_expr, '1.a').should == [tuples.first]
+  end
+
+  it 'should find data tuples by incomplete name' do
+    tuples = [
+      Tuple[:data].new('test', '1.a', nil, Time.now),
+      Tuple[:data].new('test', '2.a', nil, Time.now),
+      Tuple[:data].new('test', '3.a', nil, Time.now)
+    ]
+    tuples.each {|t| tuple_space_server.write(t) }
+    finder = DataFinder.new(tuple_space_server, 'test')
+    res = finder.send(:find_by_expr, DataExpr.new('*.a'))
+    tuples.each {|t| res.should.include t }
+  end
+
+  it 'should find no data' do
+    tuple = Tuple[:data].new('test', '2.a', nil, Time.now)
+    tuple_space_server.write(tuple)
+    finder = DataFinder.new(tuple_space_server, 'test')
+    finder.send(:find_by_expr, '1.a').should.empty
+  end
+
+  it 'should find in the domain' do
+    tuple = Tuple[:data].new('other', '1.a', nil, Time.now)
+    tuple_space_server.write(tuple)
+    finder = DataFinder.new(tuple_space_server, 'test')
+    finder.send(:find_by_expr, '1.a').should.empty
+  end
+
+  testcases.each do |testname, testcase|
+    it "should find input combination: #{testname}" do
+      finder = DataFinder.new(tuple_space_server, 'test')
+
+      # tuples
+      testcase['tuples'].map {|name|
+        Tuple[:data].new(name: name, domain: 'test')
+      }.each do |tuple|
+        tuple_space_server.write(tuple)
+      end
+
+      # query
+      query = testcase['query'].map {|d|
+        modifier = d["modifier"] == "all" ? :all : :each
+        DataExpr.new(d["name"], modifier)
+      }
+
+      # results
+      results = testcase['results'].map {|res|
+        res.map {|name|
+          if name.kind_of?(Array)
+            name.map {|n| Tuple[:data].new(name: n, domain: 'test') }
+          else
+            Tuple[:data].new(name: name, domain: 'test')
+          end
+        }
+      }
+
+      # test
+      finder.find(:input,  query, VariableTable.new).map{|r| r.combination }.should == results
+    end
+  end
+end

data/test/spec_data-finder.yml

@@ -0,0 +1,115 @@
+case1:
+  tuples:
+    - 1.a
+    - 2.a
+    - 3.a
+  query:
+    - { name: 1.a }
+  results:
+    - [ 1.a ]
+
+case2:
+  tuples:
+    - 1.a
+    - 2.a
+    - 3.a
+  query:
+    - { name: "*.a" }
+  results:
+    - [ 1.a ]
+    - [ 2.a ]
+    - [ 3.a ]
+
+case3:
+  tuples:
+    - 1.a
+    - 2.a
+    - 3.a
+  query:
+    - { name: "*.a", modifier: all}
+  results:
+    - [ [1.a, 2.a, 3.a] ]
+
+case4:
+  tuples:
+    - 1.a
+    - 1.b
+    - 2.a
+    - 2.b
+    - 3.a
+    - 3.b
+  query:
+    - { name: "*.a" }
+    - { name: "{$*}.b" }
+  results:
+    - [ 1.a, 1.b ]
+    - [ 2.a, 2.b ]
+    - [ 3.a, 3.b ]
+
+case5:
+  tuples:
+    - 1.a
+    - 1.b
+    - 2.a
+    - 2.b
+    - 3.a
+    - 3.b
+  query:
+    - { name: "*.a", modifier: all }
+    - { name: "*.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 ]
+
+case6:
+  tuples:
+    - 1.a
+    - 1.b
+    - 2.a
+    - 2.b
+    - 3.a
+    - 3.b
+  query:
+    - { name: "*.a" }
+    - { name: "*.b", modifier: 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] ]
+
+case7:
+  tuples:
+    - 1.a
+    - 1.b
+    - 2.a
+    - 2.b
+    - 3.a
+    - 3.b
+  query:
+    - { name: "*.a", modifier: all }
+    - { name: "*.b", modifier: all }
+  results:
+    - [ [1.a, 2.a, 3.a], [1.b, 2.b, 3.b] ]
+
+case8:
+  tuples:
+    - 1.a
+    - 1.b
+    - 2.a
+    - 2.b
+    - 3.a
+    - 3.b
+  query:
+    - { name: "*.a" }
+    - { name: "*.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 ]