pione 0.2.1 → 0.2.2

data/test/test-data/package/TestPackage1/scenario/case3/input/a.txt

@@ -0,0 +1 @@
+a b c

data/test/test-data/package/TestPackage1/scenario/case3/input/b.txt

@@ -0,0 +1 @@
+1 2 3 4 5

data/test/test-data/package/TestPackage1/scenario/case3/output/a.count

@@ -0,0 +1 @@
+2

data/test/test-data/package/TestPackage1/scenario/case3/output/b.count

@@ -0,0 +1 @@
+4

data/test/test-data/package/TestPackage1/scenario/case3/scenario.yml

@@ -0,0 +1,8 @@
+ScenarioName: Case3
+Params: '{WORD: " "}'
+Inputs:
+  - "a.txt"
+  - "b.txt"
+Outputs:
+  - "a.count"
+  - "b.count"

data/test/test-util.rb

@@ -1,10 +1,14 @@
 require 'bacon'
 require 'pione'
 
+Global.git_package_directory = Location[Temppath.mkdir]
+
 module TestUtil
   include Pione::TupleSpaceServerInterface
 
   DIR = Location[File.dirname(__FILE__)]
+  TEST_DATA_DIR = DIR + "test-data"
+  TEST_PACKAGE_DIR = TEST_DATA_DIR + "package"
 
   def write_and_wait_to_be_taken(tuple, sec=5)
     observer = notify('take', tuple)
@@ -73,152 +77,6 @@ module TestUtil
   end
 end
 
-module TestUtil
-  class CommandResult < StructX
-    member :exception
-    member :stdout
-    member :stderr
-
-    def success?
-      exception.kind_of?(SystemExit) and exception.success?
-    end
-
-    def report
-      unless success?
-        puts "ERROR: %s" % exception.message
-        exception.backtrace.each do |line|
-          puts "TRACE: %s" % line
-        end
-        puts stdout.string[0..100] if stdout.string.size > 0
-        puts stderr.string[0..100] if stderr.string.size > 0
-      end
-    end
-  end
-
-  module Command
-    class << self
-      def execute(&b)
-        res = CommandResult.new(stdout: StringIO.new("", "w"), stderr: StringIO.new("", "w"))
-        $stdout = res.stdout
-        $stderr = res.stderr
-        begin
-          b.call
-        rescue Object => e
-          res.exception = e
-        end
-        $stdout = STDOUT
-        $stderr = STDERR
-        return res
-      end
-
-      def succeed(&b)
-        res = execute(&b)
-        res.report
-        res.should.success
-        return res
-      end
-
-      def fail(&b)
-        res = execute(&b)
-        res.should.not.success
-        return res
-      end
-    end
-  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 %s:%s%s" % [name, string.include?("\n") ? "\n" : " ", string.chomp] 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 %s:%s%s" % [name, string.include?("\n") ? "\n" : "", string.chomp] 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
-  class TestCase < StructX
-    member :string
-    member :expected
-  end
-
-  class TestCaseEq < StructX
-    member :string
-    member :expected
-  end
-
-  def spec(name, parser, context, &b)
-    testcases = Array.new
-
-    def testcases.tc(obj)
-      case obj
-      when Hash
-        obj.each do |key, val|
-          push(TestCaseEq.new(key, val))
-        end
-      else
-        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|
-        it "should get %s:%s%s" % [name, tc.string.include?("\n") ? "\n" : " ", tc.string.chomp] do
-          res = DocumentTransformer.new.apply(
-            DocumentParser.new.send(parser).parse(tc.string)
-          )
-          case tc
-          when TestCaseEq
-            res.should == tc.expected
-          when TestCase
-            tc.expected.call(res)
-          end
-        end
-      end
-    end
-  end
-  module_function :spec
-end
-
 # Hash extension.
 class Hash
   # Symbolizes hash's keys recuirsively. This is convinient for YAML handling.
@@ -339,6 +197,12 @@ module Pione::Agent
   end
 end
 
+require_relative "test-util/command"
+require_relative "test-util/parser"
+require_relative "test-util/transformer"
+require_relative "test-util/package"
+require_relative "test-util/webserver"
+
 def setup_for_test
   include Pione
   Thread.abort_on_exception = true

data/test/test-util/command.rb

@@ -0,0 +1,53 @@
+module TestUtil
+  class CommandResult < StructX
+    member :exception
+    member :stdout
+    member :stderr
+
+    def success?
+      exception.kind_of?(SystemExit) and exception.success?
+    end
+
+    def report
+      unless success?
+        puts "ERROR: %s" % exception.message
+        exception.backtrace.each do |line|
+          puts "TRACE: %s" % line
+        end
+        puts stdout.string[0..100] if stdout.string.size > 0
+        puts stderr.string[0..100] if stderr.string.size > 0
+      end
+    end
+  end
+
+  module Command
+    class << self
+      def execute(&b)
+        res = CommandResult.new(stdout: StringIO.new("", "w"), stderr: StringIO.new("", "w"))
+        $stdout = res.stdout
+        $stderr = res.stderr
+        begin
+          b.call
+        rescue Object => e
+          res.exception = e
+        end
+        $stdout = STDOUT
+        $stderr = STDERR
+        return res
+      end
+
+      def succeed(&b)
+        res = execute(&b)
+        res.report
+        res.should.success
+        return res
+      end
+
+      def fail(&b)
+        res = execute(&b)
+        res.should.not.success
+        return res
+      end
+    end
+  end
+end

data/test/test-util/package.rb

@@ -0,0 +1,9 @@
+module TestUtil
+  module Package
+    class << self
+      def get(name)
+        TEST_PACKAGE_DIR + name
+      end
+    end
+  end
+end

data/test/test-util/parser.rb

@@ -0,0 +1,45 @@
+module TestUtil
+  module 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 %s:%s%s" % [name, string.include?("\n") ? "\n" : " ", string.chomp] 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 %s:%s%s" % [name, string.include?("\n") ? "\n" : "", string.chomp] do
+                should.raise(Parslet::ParseFailed) do
+                  parser.new.send(name).parse(string)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    module_function :spec
+  end
+end
+

data/test/test-util/transformer.rb

@@ -0,0 +1,50 @@
+module TestUtil
+  module Transformer
+    class TestCase < StructX
+      member :string
+      member :expected
+    end
+
+    class TestCaseEq < StructX
+      member :string
+      member :expected
+    end
+
+    def spec(name, parser, context, &b)
+      testcases = Array.new
+
+      def testcases.tc(obj)
+        case obj
+        when Hash
+          obj.each do |key, val|
+            push(TestCaseEq.new(key, val))
+          end
+        else
+          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|
+          it "should get %s:%s%s" % [name, tc.string.include?("\n") ? "\n" : " ", tc.string.chomp] do
+            res = DocumentTransformer.new.apply(
+              DocumentParser.new.send(parser).parse(tc.string)
+            )
+            case tc
+            when TestCaseEq
+              res.should == tc.expected
+            when TestCase
+              tc.expected.call(res)
+            end
+          end
+        end
+      end
+    end
+    module_function :spec
+  end
+end

data/test/test-util/webserver.rb

@@ -0,0 +1,43 @@
+require 'webrick'
+
+module TestUtil
+  class WebServer
+    class << self
+      def start(*args)
+        new(*args).tap {|x| x.start}
+      end
+    end
+
+    def initialize(document_root, option={})
+      logger = WEBrick::Log.new(StringIO.new("", "w"))
+      # modify document root
+      document_root = document_root.local.path if document_root.kind_of?(Location::DataLocation)
+
+      # setup options
+      _option = {DocumentRoot: document_root}
+      _option[:Port] = 54673 unless option[:Port]
+      _option[:Logger] = logger unless option[:Logger]
+      _option[:AccessLog] = logger unless option[:AccessLog]
+
+      # make webrick
+      @server = WEBrick::HTTPServer.new(_option)
+    end
+
+    def root
+      Location["http://localhost:%s/" % port]
+    end
+
+    def port
+      @server.config[:Port]
+    end
+
+    def start
+      @thread = Thread.new { @server.start }
+    end
+
+    def terminate
+      @server.shutdown
+      @thread.kill
+    end
+  end
+end

data/test/util/spec_error-report.rb

@@ -29,12 +29,21 @@ describe "Pione::Util::ErrorReport" do
     end
   end
 
+  it "should show debug message in debug mode" do
+    Pione.debug_mode {Util::ErrorReport.debug("test debug message", @rec, @file, @line)}
+    $stderr.string.tap do |s|
+      s.should.include "test debug message"
+      s.should.include @rec.to_s
+      s.should.include @file.to_s
+      s.should.include @line.to_s
+    end
+  end
+
   it "should not warn in normal mode" do
-    Util::ErrorReport.warn("test warning", @rec, @exc, @file, @line)
+    Util::ErrorReport.debug("test debug message", @rec, @file, @line)
     $stderr.string.tap do |s|
-      s.should.not.include "test warning"
+      s.should.not.include "test debug message"
       s.should.not.include @rec.to_s
-      s.should.not.include @exc.to_s
       s.should.not.include @file.to_s
       s.should.not.include @line.to_s
     end

data/test/util/spec_zip.rb

@@ -0,0 +1,36 @@
+require_relative '../test-util'
+
+shared "archiver" do
+  it "should compress and uncompress" do
+    Util::Zip.compress(@src, @archive)
+    @archive.should.exist
+    @archive.size.should > 0
+    Util::Zip.uncompress(@archive, @dest)
+    (@dest + "A").read.should == "A"
+    (@dest + "B").read.should == "B"
+    (@dest + "C/1").read.should == "C"
+    (@dest + "D/2").read.should == "D"
+    (@dest+ "E/1/2").read.should == "E"
+  end
+end
+
+describe "Pione::Util::Zip" do
+  def create_files(src)
+    (src + "A").create("A")
+    (src + "B").create("B")
+    (src + "C/1").create("C")
+    (src + "D/2").create("D")
+    (src + "E/1/2").create("E")
+  end
+
+  describe "local -> local -> local" do
+    before do
+      @src = Location[Temppath.mkdir]
+      create_files(@src)
+      @archive = Location[Temppath.create]
+      @dest = Location[Temppath.mkdir]
+    end
+
+    behaves_like "archiver"
+  end
+end