pione 0.1.0

data/test/spec_document.rb

@@ -0,0 +1,76 @@
+require_relative 'test-util'
+
+src = <<DOCUMENT
+$X := 1
+
+Rule Main
+  input '*.txt'
+  output '*.result'
+Flow
+rule RuleA
+rule RuleB
+rule RuleC
+End
+
+Rule RuleA
+  input '*.txt'
+  output '{$I[1,1]}.a'
+Action
+command_a {$I[1]} > {$O[1]}
+End
+
+Rule RuleB
+  input '*.a'
+  output '{$I[1,1]}.b'
+Action
+command_b {$I[1]} > {$O[1]}
+End
+
+Rule RuleC
+  input '*.b'
+  output '{$I[1,1]}.result'
+Action
+command_c {$I[1]} > {$O[1]}
+End
+DOCUMENT
+
+describe 'Document' do
+  it 'should read a document from a string' do
+    doc = Document.parse(src)
+    doc.rules.size.should == 4
+  end
+
+  it 'should read a document from a file' do
+    temp = Tempfile.new("spec_document")
+    temp.write(src)
+    path = temp.path
+    temp.close(false)
+    doc = Document.load(path)
+    doc.rules.size.should == 4
+  end
+
+  it 'should get rules by rule path' do
+    doc = Document.parse(src)
+    doc["&main:Main"].should.kind_of(Model::Rule)
+    doc["&main:RuleA"].should.kind_of(Model::Rule)
+    doc["&main:RuleB"].should.kind_of(Model::Rule)
+    doc["&main:RuleC"].should.kind_of(Model::Rule)
+  end
+
+  it 'should have global variable' do
+    doc = Document.parse(src)
+    doc["&main:Main"].params["X"].should == 1.to_pione
+    doc["&main:RuleA"].params["X"].should == 1.to_pione
+    doc["&main:RuleB"].params["X"].should == 1.to_pione
+    doc["&main:RuleC"].params["X"].should == 1.to_pione
+  end
+
+  it 'should raise variable binding error' do
+    should.raise(VariableBindingError) do
+      Document.parse <<-PIONE
+        $X := 1
+        $X := 2
+      PIONE
+    end
+  end
+end

data/test/spec_identifier.rb

@@ -0,0 +1,29 @@
+require_relative 'test-util'
+
+describe 'ID' do
+  it 'should get task id' do
+    ID.task_id([], Parameters.empty).size.should == 32
+  end
+
+  it 'should get same id from same task' do
+    id = ID.task_id([DataExpr["1.a"]], Parameters.empty)
+    id.should == ID.task_id([DataExpr["1.a"]], Parameters.empty)
+  end
+
+  it 'should get different id from different task' do
+    id = [
+      ID.task_id([], Parameters.empty),
+      ID.task_id([DataExpr["1.a"]], Parameters.empty),
+      ID.task_id([DataExpr["2.a"]], Parameters.empty),
+      ID.task_id([], {"var" => "1.a"}.to_params),
+      ID.task_id([], {"var" => "2.a"}.to_params),
+      ID.task_id([DataExpr["1.a"]], {"var" => "1.a"}.to_params),
+      ID.task_id([DataExpr["2.a"]], {"var" => "2.a"}.to_params)
+    ]
+    7.times do |i|
+      7.times do |ii|
+        id[i+1].should.not == id[ii+1] unless i == ii
+      end
+    end
+  end
+end

data/test/spec_log.rb

@@ -0,0 +1,52 @@
+require_relative 'test-util.rb'
+
+include Pione
+
+describe 'Log' do
+  it 'should create without block' do
+    should.not.raise { Log.new }
+  end
+
+  it 'should create with block' do
+    should.not.raise { Log.new{} }
+  end
+
+  it 'should add a record' do
+    log = Log.new do |l|
+      l.add_record("spec_log", "action", "test")
+    end
+    log.records.size.should == 1
+  end
+
+  it 'should add records' do
+    log = Log.new do |l|
+      l.add_record("spec_log", "test1", "a")
+      l.add_record("spec_log", "test2", "b")
+    end
+    log.records.size.should == 2
+  end
+
+  it 'should format as string' do
+    log = Log.new do |l|
+      l.add_record("spec_log", "action", "test")
+    end
+    md = /(.+)\s+[A-Z0-9]{4}\s+\.spec_log\.action:\s+\"test\"/.match(log.format)
+    md.should.not.be.nil
+    should.not.raise { Time.iso8601(md[1]) }
+  end
+
+  it 'should format as string' do
+    log = Log.new do |l|
+      l.add_record("spec_log", "test1", "a")
+      l.add_record("spec_log", "test2", "b")
+    end
+    lines = log.format.split("\n")
+    lines.size.should == 2
+    md1 = /^(.+)\s+[A-Z0-9]{4}\s+\.spec_log\.test1:\s+\"a\"$/.match(lines[0])
+    md1.should.not.be.nil
+    should.not.raise { Time.iso8601(md1[1]) }
+    md2 = /^(.+)\s+[A-Z0-9]{4}\s+\.spec_log\.test2:\s+\"b\"$/.match(lines[1])
+    md2.should.not.be.nil
+    should.not.raise { Time.iso8601(md2[1]) }
+  end
+end

data/test/spec_object.rb

@@ -0,0 +1,20 @@
+require_relative 'test-util'
+
+describe 'PioneObject' do
+  it "should get UUID as string" do
+    PioneObject.new.uuid.size.should == 36
+  end
+
+  it "should get same UUID from same object" do
+    obj1 = PioneObject.new
+    obj1.uuid.should == obj1.uuid
+  end
+
+  it "should get different uuids from different objects" do
+    obj1 = PioneObject.new
+    obj2 = PioneObject.new
+    obj1.uuid.should == obj1.uuid
+    obj1.uuid.should.not == obj2.uuid
+  end
+end
+

data/test/spec_resource.rb

@@ -0,0 +1,73 @@
+require 'tempfile'
+require_relative 'test-util'
+
+describe 'Resource' do
+  describe 'Local' do
+    before do
+      path = Tempfile.new("spec_resource_").path
+      @uri = ::URI.parse("local:#{path}")
+      @local = Resource[@uri]
+    end
+
+    it 'should create a file' do
+      @local.create("abc")
+      File.read(@uri.path).should == "abc"
+    end
+
+    it 'should read a file' do
+      @local.create("abc")
+      @local.read.should == "abc"
+      @local.read.should == "abc"
+      @local.read.should.not == "def"
+      File.delete(@uri.path)
+      should.raise(Resource::NotFound) { @local.read }
+    end
+
+    it 'should update a file' do
+      @local.create("abc")
+      @local.read.should == "abc"
+      @local.update("defg")
+      @local.read.should == "defg"
+      @local.update("hi")
+      @local.read.should == "hi"
+    end
+
+    it 'should delete a file' do
+      should.not.raise { @local.delete }
+      @local.create("abc")
+      @local.delete
+    end
+  end
+
+  begin
+    @uri = URI("ftp://anonymous:test@localhost/pione/test-a.txt")
+    @ftp = Resource[@uri]
+    @ftp.create("abc")
+    @ftp.delete
+
+    describe 'FTP' do
+      before do
+        path = Tempfile.new("spec_resource_").path
+        # @uri = URI("ftp://anonymous:test@localhost/pione/test-a.txt")
+        # @ftp = Resource[@uri]
+      end
+
+      it 'should create a file and read it' do
+        @ftp.create("abc")
+        @ftp.read.should == "abc"
+        @ftp.delete
+      end
+
+      it 'should update a file' do
+        @ftp.create("abc")
+        @ftp.read.should == "abc"
+        @ftp.update("defg")
+        @ftp.read.should == "defg"
+        @ftp.update("hi")
+        @ftp.read.should == "hi"
+        @ftp.delete
+      end
+    end
+  rescue Errno::ECONNREFUSED
+  end
+end

data/test/spec_update-criteria.rb

@@ -0,0 +1,83 @@
+require_relative 'test-util'
+
+data = DataExpr.new('*')
+
+document = Document.parse(<<DOCUMENT)
+Rule NoOutputsRule
+  input '*'
+Action---
+
+--End
+
+Rule OutputsRule
+  input '*.a'
+  output '*.b'
+Action
+cat {$INPUT[1]} > {$OUTPUT[1]}
+End
+DOCUMENT
+$no_outputs_rule = document["&main:NoOutputsRule"]
+$outputs_rule = document["&main:OutputsRule"]
+
+
+time1 = Time.now
+time2 = Time.now
+time3 = Time.now
+tuple1 = Tuple[:data].new('test', '1.a', nil, time1)
+tuple2 = Tuple[:data].new('test', '2.a', nil, time2)
+tuple3 = Tuple[:data].new('test', '3.b', nil, time2)
+
+UC = UpdateCriteria
+
+describe 'UpdateCriteria' do
+
+  # no output rules
+  describe 'criteria: no output rules' do
+    it 'should be updatable' do
+      inputs = [tuple1, tuple2]
+      outputs = [tuple3]
+
+      UC.no_output_rules?(
+        $no_outputs_rule,
+        inputs,
+        outputs,
+        VariableTable.new
+      ).should.true
+    end
+
+    it 'should not be updatable' do
+      inputs = [tuple1, tuple2]
+      outputs = [tuple3]
+      UC.no_output_rules?(
+        $outputs_rule,
+        inputs,
+        outputs,
+        VariableTable.new
+      ).should.false
+    end
+  end
+
+  describe 'criteria: not_exist_output' do
+    it 'should be updatable' do
+      inputs = [tuple1, tuple2]
+      outputs = []
+      UC.not_exist_output?(
+        $outputs_rule,
+        inputs,
+        outputs,
+        VariableTable.new
+      ).should.true
+    end
+
+    it 'should be not updatable' do
+      inputs = [tuple1]
+      outputs = [tuple3]
+      UC.not_exist_output?(
+        $outputs_rule,
+        inputs,
+        outputs,
+        VariableTable.new
+      ).should.false
+    end
+  end
+end

data/test/test-util.rb

@@ -0,0 +1,223 @@
+require 'bacon'
+require 'pione'
+
+module TestUtil
+  include Pione::TupleSpaceServerInterface
+
+  def write_and_wait_to_be_taken(tuple, sec=5)
+    observer = notify('take', tuple)
+    write(tuple)
+    timeout(sec) do
+      observer.pop
+    end
+  end
+
+  def clear_exceptions
+    server = get_tuple_space_server
+    server.read_all(Tuple[:exception].any).each do |tuple|
+      ts_server.take(tuple)
+    end
+  end
+
+  def check_exceptions
+    exceptions = tuple_space_server.read_all(Tuple[:exception].any)
+    exceptions.each do |tuple|
+      e = tuple.value
+      Bacon::ErrorLog << "#{e.class}: #{e.message}\n"
+      e.backtrace.each_with_index { |line, i| Bacon::ErrorLog << "\t#{line}\n" }
+      Bacon::ErrorLog << "\n"
+    end
+    exceptions.should.be.empty
+  end
+
+  def observe_exceptions(sec=5, &b)
+    @thread = Thread.new { b.call }
+    begin
+      timeout(sec) do
+        while @thread.alive? do; sleep 0.1; end
+      end
+    ensure
+      check_exceptions
+    end
+  end
+
+  def create_remote_tuple_space_server
+    # make drb server and it's connection
+    tuple_space_server = Pione::TupleSpace::TupleSpaceServer.new
+    # base uri
+    tuple_space_server.write(Tuple[:base_uri].new("local:#{Dir.mktmpdir('pione-test')}/"))
+    @__remote_drb_server__ = DRb::DRbServer.new(nil, tuple_space_server)
+    server = DRbObject.new_with_uri(@__remote_drb_server__.uri)
+    # set default tuple space server
+    set_tuple_space_server server
+    # return the connection
+    return server
+  end
+
+  def remote_drb_server
+    @__remote_drb_server__
+  end
+end
+
+module TestUtil::Parser
+  # Makes a test parser class by the sub-parser module.
+  def make_test_parser(parser_module)
+    klass = Class.new(Parslet::Parser)
+    klass.instance_eval do
+      include parser_module
+    end
+    return klass
+  end
+  module_function :make_test_parser
+
+  def spec(mod, rb, context)
+    #parser = make_test_parser(mod)
+    parser = Pione::Parser::DocumentParser
+    basename = File.basename(rb, ".rb")
+    path = File.join(File.dirname(rb), basename + ".yml")
+    YAML.load(File.read(path)).each do |name, testcase|
+      context.describe name do
+        if strings = testcase["valid"]
+          strings.each do |string|
+            it "should parse as #{name}: #{string}" do
+              should.not.raise(Parslet::ParseFailed) do
+                parser.new.send(name).parse(string)
+              end
+            end
+          end
+        end
+
+        if strings = testcase["invalid"]
+          strings.each do |string|
+            it "should fail when parsing as #{name}: #{string}" do
+              should.raise(Parslet::ParseFailed) do
+                parser.new.send(name).parse(string)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  module_function :spec
+end
+
+module TestUtil::Transformer
+  TestCase = Struct.new(:string, :expected)
+
+  def spec(name, parser, context, &b)
+    testcases = Array.new
+    def testcases.tc(obj)
+      case obj
+      when Hash
+        obj.each do |key, val|
+          push(TestCase.new(key, val))
+        end
+      else
+        push(TestCase.new(obj, yield))
+      end
+    end
+    testcases.instance_eval(&b)
+    context.describe name do
+      testcases.each do |tc|
+        it "should get #{name}: #{tc.string}" do
+          res = DocumentTransformer.new.apply(
+            DocumentParser.new.send(parser).parse(tc.string)
+          )
+          res.should == tc.expected
+        end
+      end
+    end
+  end
+  module_function :spec
+end
+
+# Hash extension.
+class Hash
+  # Symbolizes hash's keys recuirsively. This is convinient for YAML handling.
+  def symbolize_keys
+    each_with_object({}) do |(key, val), hash|
+      hash[key.to_sym] = (val.kind_of?(Hash) ? val.symbolize_keys : val)
+    end
+  end
+
+  def to_params
+    Parameters.new(
+      Hash[map{|key, val| [Pione::Model::Variable.new(key), val.to_pione]}]
+    )
+  end
+end
+
+# Bacon::Context extension.
+class Bacon::Context
+  # Install utilities.
+  include TestUtil
+
+  def transformer_spec(name, parser_name, &b)
+    TestUtil::Transformer.spec(name, parser_name, self, &b)
+  end
+end
+
+module Pione::TupleSpace
+  class TupleSpaceServer
+    # Return all tuples of the tuple space.
+    def all_tuples
+      tuples = []
+      bag = @__ts__.instance_variable_get("@bag")
+      bag.instance_variable_get("@hash").values.each do |bin|
+        tuples += bin.instance_variable_get("@bin")
+      end
+      _tuples = tuples.map{|t| t.value}
+      return _tuples
+    end
+
+    # Return take waiting tuples.
+    def take_waiter
+      tuples = []
+      bag = @__ts__.instance_variable_get("@take_waiter")
+      bag.instance_variable_get("@hash").values.each do |bin|
+        tuples += bin.instance_variable_get("@bin")
+      end
+      _tuples = tuples.map{|t| t.value}
+      return _tuples
+    end
+  end
+end
+
+module Pione::Agent
+  class BasicAgent
+    include TestUtil
+
+    # Fake set_current_state for counting state changes.
+    alias :set_current_state_orig :set_current_state
+    def set_current_state(state)
+      @__counter__ ||= nil
+      set_current_state_orig(state)
+      if @__counter__
+        @__counter__.has_key?(state) ? @__counter__[state] += 1 : @__counter__[state] = 1
+      end
+    end
+
+    # Wait until state counter is reached at the number.
+    def wait_until_count(number, state, sec=5, &b)
+      timeout(sec) do
+        @__counter__ = {}
+        first_time = true
+        while @__counter__[state].nil? or @__counter__[state] < number do
+          b.call if first_time
+          first_time = false
+          check_exceptions
+          sleep 0.2
+        end
+        @__counter__ = nil
+      end
+    end
+  end
+end
+
+def setup_for_test
+  include Pione
+  Thread.abort_on_exception = true
+end
+
+setup_for_test