pione 0.1.4 → 0.2.0

data/test/system/spec_domain-info.rb

@@ -0,0 +1,25 @@
+require_relative "../test-util"
+
+describe "Pione::System::DomainInfo" do
+  before do
+    @vtable = Model::VariableTable.new
+    @vtable.set(Variable.new("A"), Model::PioneInteger.new(1).to_seq)
+    @vtable.set(Variable.new("B"), Model::PioneFloat.new(1.23).to_seq)
+    @vtable.set(Variable.new("C"), Model::PioneString.new("A").to_seq)
+    @vtable.set(Variable.new("D"), Model::PioneBoolean.new(true).to_seq)
+    @location = Location[Temppath.create].tap do |location|
+      System::DomainInfo.new(@vtable).write(location)
+    end
+  end
+
+  it "should write a domain info file" do
+    location = Location[Temppath.create]
+    System::DomainInfo.new(@vtable).write(location)
+    location.should.exist
+  end
+
+  it "should read a domain info file" do
+    System::DomainInfo.read(@location).variable_table.should == @vtable
+  end
+end
+

data/test/test-util.rb

@@ -43,9 +43,9 @@ module TestUtil
 
   def create_tuple_space_server
     # make drb server and it's connection
-    tuple_space_server = Pione::TupleSpace::TupleSpaceServer.new
+    tuple_space_server = Pione::TupleSpace::TupleSpaceServer.new({}, false)
     # base uri
-    tuple_space_server.write(Tuple[:base_location].new("local:#{Dir.mktmpdir('pione-test')}/"))
+    tuple_space_server.write(Tuple[:base_location].new(Location[Temppath.create]))
     # set default tuple space server
     set_tuple_space_server tuple_space_server
     # return the connection
@@ -115,19 +115,26 @@ end
 
 module TestUtil::Transformer
   TestCase = Struct.new(:string, :expected)
+  TestCaseEq = 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))
+          push(TestCaseEq.new(key, val))
         end
       else
-        push(TestCase.new(obj, yield))
+        push(TestCaseEq.new(obj, yield))
       end
     end
+
+    def testcases.transform(obj, &b)
+      push(TestCase.new(obj, b))
+    end
+
     testcases.instance_eval(&b)
     context.describe name do
       testcases.each do |tc|
@@ -135,7 +142,12 @@ module TestUtil::Transformer
           res = DocumentTransformer.new.apply(
             DocumentParser.new.send(parser).parse(tc.string)
           )
-          res.should == tc.expected
+          case tc
+          when TestCaseEq
+            res.should == tc.expected
+          when TestCase
+            tc.expected.call(res)
+          end
         end
       end
     end
@@ -151,12 +163,6 @@ class 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.
@@ -170,10 +176,8 @@ class Bacon::Context
 end
 
 module TestUtil
+  # Test pione method.
   def test_pione_method(name)
-    #
-    # test cases
-    #
     yamlname = 'spec_%s.yml' % name
     ymlpath = File.join(File.dirname(__FILE__), 'model', yamlname)
     testcases = YAML.load_file(ymlpath)
@@ -192,6 +196,26 @@ module TestUtil
       end
     end
   end
+
+  # Test uri scheme.
+  def test_uri_scheme(name)
+    yamlname = 'spec_%s.yml' % name
+    ymlpath = File.join(File.dirname(__FILE__), 'uri-scheme', yamlname)
+    testcases = YAML.load_file(ymlpath)
+
+    describe "uri scheme test cases" do
+      testcases.each do |testcase|
+        uri = testcase.keys.first
+        it uri do
+          testcase[uri].keys.each do |name|
+            expect = testcase[uri][name]
+            expect = nil if expect == "nil"
+            URI.parse(uri).__send__(name).should == expect
+          end
+        end
+      end
+    end
+  end
 end
 
 module Pione::TupleSpace
@@ -251,220 +275,6 @@ module Pione::Agent
   end
 end
 
-begin
-  require 'em-ftpd'
-  require 'pione/patch/em-ftpd-patch'
-
-  module EM::FTPD::Files
-    def puts(*args)
-      # ignored
-    end
-  end
-rescue
-
-end
-
-
-module TestUtil
-  class FTPServer
-    class AuthInfo
-      attr_reader :user
-      attr_reader :password
-
-      def initialize
-        @user = Pione::Util.generate_uuid
-        @password = Pione::Util.generate_uuid
-      end
-    end
-
-    class OnMemoryFS
-      attr_reader :directory
-      attr_reader :file
-      attr_reader :mtime
-
-      def initialize
-        @directory = {"/" => Set.new}
-        @file = {}
-        @mtime = {}
-      end
-
-      def clear
-        @directory.clear
-        @directory["/"] = Set.new
-        @file.clear
-        @mtime.clear
-      end
-    end
-
-    PORT = 39123
-    AUTH_INFO = AuthInfo.new
-    FS = OnMemoryFS.new
-
-    class << self
-      def enabled?
-        begin
-          require 'em-ftpd'
-          return true
-        rescue
-          return false
-        end
-      end
-
-      # Start FTP server.
-      def start
-        FS.clear
-        @thread = Thread.new do
-          EventMachine.run do
-            EventMachine.start_server("0.0.0.0", PORT, EM::FTPD::Server, self)
-          end
-        end
-      end
-
-      def stop
-        FS.clear
-        EventMachine.stop
-        @thread.kill if @thread
-      end
-
-      def make_location(path)
-        Location["ftp://%s:%s@localhost:%i%s" % [AUTH_INFO.user, AUTH_INFO.password, PORT, path]]
-      end
-    end
-
-    def initialize
-      @directory = FS.directory
-      @file = FS.file
-      @mtime = FS.mtime
-      @user = AUTH_INFO.user
-      @password = AUTH_INFO.password
-    end
-
-    def change_dir(path, &b)
-      yield @directory.keys.include?(path)
-    end
-
-    def dir_contents(path, &b)
-      if @directory.has_key?(path) and @directory[path]
-        entries = @directory[path].map do |entry|
-          entry_path = Pathname.new(File.join(path, entry)).cleanpath.to_s
-          if @directory.has_key?(entry_path)
-            dir_item(entry)
-          else
-            file_item(entry, @file[entry_path].size)
-          end
-        end
-        yield entries
-      else
-        yield Set.new
-      end
-    end
-
-    def authenticate(user, password, &b)
-      # yield @user == user && @password == password
-      yield true
-    end
-
-    def bytes(path, &b)
-      path = Pathname.new(path).cleanpath.to_s
-      if @file.has_key?(path)
-        yield @file[path].size
-      elsif @directory.has_key?(path)
-        yield -1
-      else
-        yield false
-      end
-    end
-
-    def get_file(path, &block)
-      path = Pathname.new(path).cleanpath.to_s
-      if @file.has_key?(path)
-        yield @file[path]
-      else
-        yeild false
-      end
-    end
-
-    def put_file(path, data, &b)
-      path = Pathname.new(path).cleanpath
-      dir = path.dirname.to_s
-      filename = path.basename.to_s
-      if @directory.has_key?(dir) and filename
-        @directory[dir] << filename
-        @file[path.to_s] = File.read(data)
-        @mtime[path.to_s] = Time.now
-        yield data.size
-      else
-        yield false
-      end
-    end
-
-    def delete_file(path, &b)
-      path = Pathname.new(path).cleanpath
-      dir = path.dirname.to_s
-      filename = path.basename.to_s
-      if @directory.has_key?(dir) and @directory[dir].include?(filename)
-        @directory[dir].delete(dir)
-        @file.delete(path.to_s)
-        @mtime.delete(path.to_s)
-        yield true
-      else
-        yield false
-      end
-    end
-
-    def rename_file(from, to, &b)
-      from_path = Pathname.new(from).cleanpath
-      from_dir = from_path.dirname.to_s
-      from_filename = from_path.basename.to_s
-      to_path = Pathname.new(to).cleanpath
-      to_dir = to_path.dirname.to_s
-      to_filename = to_path.basename.to_s
-      if @file.has_key?(from_path.to_s) && @directory.has_key?(to_dir)
-        data = @file[from_path.to_s]
-        @file.delete(from_path.to_s)
-        @directory[from_dir].delete(from_filename)
-        @file[to_path.to_s] = data
-        @directory[to_dir] << to_filename
-        yield true
-      else
-        yield false
-      end
-    end
-
-    def make_dir(path, &b)
-      path = Pathname.new(path).cleanpath
-      dir = path.dirname.to_s
-      basename = path.basename.to_s
-      if @directory.has_key?(path.to_s) or not(@directory.has_key?(dir))
-        yield false
-      else
-        @directory[path.to_s] = Set.new
-        @directory[dir] << basename
-        yield true
-      end
-    end
-
-    def mtime(path)
-      path = Pathname.new(path).cleanpath.to_s
-      if @file[path]
-        yield @mtime[path]
-      else
-        yield false
-      end
-    end
-
-    private
-
-    def dir_item(name)
-      EM::FTPD::DirectoryItem.new(:name => name, :directory => true, :size => 0)
-    end
-
-    def file_item(name, bytes)
-      EM::FTPD::DirectoryItem.new(:name => name, :directory => false, :size => bytes)
-    end
-  end
-end
-
 def setup_for_test
   include Pione
   Thread.abort_on_exception = true

data/test/transformer/spec_block-transformer.rb

@@ -18,7 +18,7 @@ describe 'Pione::Transformer::BlockTransformer' do
       End
     STRING
       FlowBlock.new(
-        CallRule.new(RuleExpr.new(Package.new("main"), "Test"))
+        CallRule.new(RuleExpr.new(PackageExpr.new("main"), "Test"))
       )
     end
   end

data/test/transformer/spec_expr-transformer.rb

@@ -1,9 +1,18 @@
 require_relative '../test-util'
 
+$a = PioneString.new("a")
+$b = PioneString.new("b")
+$c = PioneString.new("c")
+$abc = PioneString.new("abc")
+$var_x = Variable.new("X")
+$var_y = Variable.new("Y")
+$var_z = Variable.new("Z")
+
 describe 'Pione::Transformer::ExprTransformer' do
+
   transformer_spec("binary operator", :expr) do
     tc "1 + 2" do
-      BinaryOperator.new(
+      Message.new(
         "+",
         IntegerSequence.new([1.to_pione]),
         IntegerSequence.new([2.to_pione])
@@ -11,41 +20,25 @@ describe 'Pione::Transformer::ExprTransformer' do
     end
 
     tc '"a" + "b"' do
-      BinaryOperator.new(
-        "+",
-        StringSequence.new(["a".to_pione]),
-        StringSequence.new(["b".to_pione])
-      )
+      Message.new("+", StringSequence.new([$a]), StringSequence.new([$b]))
     end
 
     tc "false || true" do
-      BinaryOperator.new(
+      Message.new(
         "||",
         BooleanSequence.new([PioneBoolean.false]),
         BooleanSequence.new([PioneBoolean.true])
       )
     end
 
-    tc "$Var * 3" do
-      BinaryOperator.new(
-        "*",
-        Variable.new("Var"),
-        IntegerSequence.new([3.to_pione])
-      )
+    tc "$X * 3" do
+      Message.new("*", $var_x, IntegerSequence.new([3.to_pione]))
     end
 
-    tc "($Var1 == \"a\") && ($Var2 == \"b\")" do
-      left = BinaryOperator.new(
-        "==",
-        Variable.new("Var1"),
-        StringSequence.new(["a".to_pione])
-      )
-      right = BinaryOperator.new(
-        "==",
-        Variable.new("Var2"),
-        StringSequence.new([PioneString.new("b")])
-      )
-      BinaryOperator.new("&&", left, right)
+    tc "($X == \"a\") && ($Y == \"b\")" do
+      left = Message.new("==", $var_x, StringSequence.new([$a]))
+      right = Message.new("==", $var_y, StringSequence.new([$b]))
+      Message.new("&&", left, right)
     end
   end
 
@@ -71,7 +64,7 @@ describe 'Pione::Transformer::ExprTransformer' do
     tc "\"abc\".index(1,1)" do
       Message.new(
         "index",
-        StringSequence.new(["abc".to_pione]),
+        StringSequence.new([$abc]),
         IntegerSequence.new([1.to_pione]),
         IntegerSequence.new([1.to_pione])
       )
@@ -80,7 +73,7 @@ describe 'Pione::Transformer::ExprTransformer' do
     tc "(1 + 2).prev" do
       Message.new(
         "prev",
-        BinaryOperator.new(
+        Message.new(
           "+",
           IntegerSequence.new([1.to_pione]),
           IntegerSequence.new([2.to_pione])
@@ -89,7 +82,7 @@ describe 'Pione::Transformer::ExprTransformer' do
     end
 
     tc "abc.sync" do
-      rule = RuleExpr.new(Package.new("main"), "abc")
+      rule = RuleExpr.new(PackageExpr.new("main"), "abc")
       Message.new("sync", rule)
     end
 
@@ -111,24 +104,22 @@ describe 'Pione::Transformer::ExprTransformer' do
       Parameters.new({})
     end
 
-    tc "{var1: 1}" do
-      Parameters.new(
-        {Variable.new("var1") => IntegerSequence.new([PioneInteger.new(1)])}
-      )
+    tc "{X: 1}" do
+      Parameters.new({$var_x => IntegerSequence.new([PioneInteger.new(1)])})
     end
 
-    tc "{var1: 1, var2: 2}" do
+    tc "{X: 1, Y: 2}" do
       Parameters.new(
-        { Variable.new("var1") => IntegerSequence.new([PioneInteger.new(1)]),
-          Variable.new("var2") => IntegerSequence.new([PioneInteger.new(2)]) }
+        { $var_x => IntegerSequence.new([PioneInteger.new(1)]),
+          $var_y => IntegerSequence.new([PioneInteger.new(2)]) }
       )
     end
 
-    tc "{var1: \"a\", var2: \"b\", var3: \"c\"}" do
+    tc "{X: \"a\", Y: \"b\", Z: \"c\"}" do
       Parameters.new(
-        { Variable.new("var1") => StringSequence.new([PioneString.new("a")]),
-          Variable.new("var2") => StringSequence.new([PioneString.new("b")]),
-          Variable.new("var3") => StringSequence.new([PioneString.new("c")]) }
+        { $var_x => StringSequence.new([$a]),
+          $var_y => StringSequence.new([$b]),
+          $var_z => StringSequence.new([$c]) }
       )
     end
   end