pione 0.2.2 → 0.3.0

data/lib/pione/test-helper/extension.rb

@@ -0,0 +1,9 @@
+# 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
+end

data/lib/pione/test-helper/lang-helper.rb

@@ -0,0 +1,196 @@
+module Pione
+  module TestHelper
+    module Lang
+      class << self
+        # Read PIONE language and return the result.
+        def read(string, parser_name, opts={})
+          LangReader.new(string, parser_name, opts).read
+        end
+
+        # Read a declaration.
+        def declaration(string, opts={})
+          read(string, :declaration, opts)
+        end
+
+        def declaration!(env, string, opts={})
+          declaration(string, opts).eval(env)
+        end
+
+        # Read a conditional branch.
+        def conditional_branch(string, opts={})
+          read(string, :conditional_branch, opts)
+        end
+
+        # Read a structural context.
+        def context(string, opts={})
+          read(string, :structural_context, opts)
+        end
+
+        def context!(env, string, opts={})
+          context(string, opts).eval!(env)
+        end
+
+        # Read a package context.
+        def package_context(string, opts={})
+          read(string, :package_context, opts)
+        end
+
+        # Read and evaluate a package context.
+        def package_context!(env, string, opts={})
+          package_context(string, opts).eval!(env)
+        end
+
+        # Read a rule condition context.
+        def rule_condition_context(string, opts={})
+          read(string, :rule_condition_context, opts)
+        end
+
+        # Read and evaluate a rule condition context.
+        def rule_condition_context!(env, string, opts={})
+          rule_condition_context(string, opts).eval!(env)
+        end
+
+        # Read a conditional branch context.
+        def conditional_branch_context(string, opts={})
+          read(string, :conditional_branch_context, opts)
+        end
+
+        # Read and evaluate a rule condition context.
+        def conditional_branch_context!(env, string, opts={})
+          conditional_branch_context(string, opts).eval!(env)
+        end
+
+        # Read an expression.
+        def expr(string, opts={})
+          read(string, :expr, opts)
+        end
+
+        # Read and evaluate an expression.
+        def expr!(env, string, opts={})
+          expr(string, opts).eval!(env)
+        end
+
+        # Read a feature expression.
+        def feature_expr(string, opts={})
+          read(string, :feature_expr, opts)
+        end
+
+        # Read and evaluate a feature expression.
+        def feature_expr!(string, opts={})
+          feature_expr(string, opts).eval(env)
+        end
+
+        # Build an environment and update it with the string as structural context.
+        def env(string=nil)
+          _env = Pione::Lang::Environment.new.setup_new_package("Test")
+          context(string).eval(_env) if string
+          _env
+        end
+
+        # Test pione method.
+        def test_pione_method(name, option={})
+          TestPioneMethod.new(name, option).run
+        end
+      end
+    end
+
+    # LangReader is a language reader that converts fromt string to pione inner model.
+    class LangReader
+      @parser = {}
+
+      # cache for parser and transformer
+      class << self
+        def parser(name)
+          @parser[name] ||= Pione::Lang::DocumentParser.new.send(name)
+        end
+
+        def transformer
+          @transformer ||= Pione::Lang::DocumentTransformer.new
+        end
+      end
+
+      forward! :class, :parser, :transformer
+
+      def initialize(string, parser_name, opts={})
+        @string = string
+        @parser_name = parser_name
+        @opts = {package_name: "Test", filename: "Test.pione"}.merge(opts)
+      end
+
+      def read
+        parsed = parser(@parser_name).parse(@string)
+        opts = {package_name: @opts[:package_name], filename: @opts[:filename]}
+        transformer.apply(parsed, opts)
+      end
+    end
+
+    class TestPioneMethodItem < StructX
+      member :expectation_string
+      member :expr_string
+      member :transformer_option
+
+      def expectation
+        Pione::Lang::DocumentTransformer.new.apply(
+          Pione::Lang::DocumentParser.new.expr.parse(expectation_string),
+          transformer_option
+        )
+      end
+
+      def expr
+        Pione::Lang::DocumentTransformer.new.apply(
+          Pione::Lang::DocumentParser.new.expr.parse(expr_string),
+          transformer_option
+        )
+      end
+
+      def test
+        env = TestHelper::Lang.env
+        expr.eval(env).should == expectation.eval(env)
+      end
+    end
+
+    class TestPioneMethod
+      def initialize(path, option={})
+        dir = File.dirname(path)
+        name = File.basename(path, ".rb").sub("spec_", "")
+        @path = File.join(dir, 'data', '%s.yml' % name)
+        @transformer_option = make_transformer_option(option)
+      end
+
+      # Test pione method.
+      def run
+        YAML.load_file(@path).each do |title, testcases|
+          items = make_test_items(testcases)
+
+          describe "pione method test cases" do
+            describe title do
+              items.each do |item|
+                it '%s should be %s' % [item.expr_string, item.expectation_string] do
+                  item.test
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def make_transformer_option(option)
+        transformer_option = {}
+        transformer_option[:package_name] = option[:package_name] || "Test"
+        transformer_option[:filename] = option[:filename] || "Test.pione"
+        transformer_option
+      end
+
+      def make_test_items(testcases)
+        if testcases
+          testcases.map do |testcase|
+            head = testcase.keys.first
+            TestPioneMethodItem.new(head.to_s, testcase[head].to_s, @transformer_option)
+          end
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/pione/test-helper/location-helper.rb

@@ -0,0 +1,27 @@
+module Pione
+  module TestHelper
+    module Location
+      # Test location scheme.
+      def self.test_scheme(path)
+        dir = File.dirname(path)
+        name = File.basename(path, ".rb").sub("spec_", "")
+        yml_path = File.join(dir, 'data', '%s.yml' % name)
+
+        describe "location scheme test" do
+          YAML.load_file(yml_path).each do |testcase|
+            if uri = testcase.keys.first
+              testcase[uri].keys.each do |name|
+                # expectation
+                expectation = testcase[uri][name]
+                expectation = nil if expectation == "nil"
+
+                # test
+                URI.parse(uri).__send__(name).should == expectation
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/test-helper/package-helper.rb

@@ -0,0 +1,11 @@
+module Pione
+  module TestHelper
+    module Package
+      class << self
+        def get(name)
+          Pione::Location[File.dirname(__FILE__)] + ".." + ".." + ".." + "test" + "test-data" + "package" + name
+        end
+      end
+    end
+  end
+end

data/lib/pione/test-helper/parser-helper.rb

@@ -0,0 +1,45 @@
+module Pione
+  module TestHelper
+    module Parser
+      # Make 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
+
+      # Make specifications of parser.
+      def spec(rb, context, parser=Pione::Lang::DocumentParser)
+        basename = File.basename(rb, ".rb")
+        path = File.join(File.dirname(rb), "data", basename[5..-1] + ".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
+end

data/lib/pione/test-helper/transformer-helper.rb

@@ -0,0 +1,136 @@
+module Pione
+  module TestHelper
+    # transformer interface for bacon contexts.
+    module TransformerInterface
+      # Start transformer spec context.
+      def transformer_spec(name, parser_name, option={}, &b)
+        Transformer.spec(name, parser_name, option, self, &b)
+      end
+    end
+
+    module Transformer
+      # test case
+      class TestCase < StructX
+        member :string
+        member :expected
+      end
+
+      # succeed case
+      class SucceedCase < StructX
+        member :string
+      end
+
+      # fail case
+      class FailCase < StructX
+        member :string
+        member :exception_type
+      end
+
+      # test case list
+      class TestCases < Array
+        def test(obj, res=nil, &b)
+          if res
+            push(Naming.Eq(TestCase.new(obj, res)))
+          else
+            push(Naming.Block(TestCase.new(obj, b)))
+          end
+        end
+
+        def succeed(string)
+          push(SucceedCase.new(string))
+        end
+
+        def fail(string, exception_type)
+          push(FailCase.new(string, exception_type))
+        end
+      end
+
+      class Spec
+        forward_as_key! :@option, :parser_class, :transformer_class, :package_name, :filename
+
+        def initialize(testcases, name, parser_name, option, context)
+          @testcases = testcases
+          @name = name
+          @parser_name = parser_name
+          @option = Hash.new
+          @option[:parser_class] = option[:parser_class] || Pione::Lang::DocumentParser
+          @option[:transformer_class] = option[:transformer_class] || Pione::Lang::DocumentTransformer
+          @option[:package_name] = option[:package_name] || "Test"
+          @option[:filename] = option[:filename] || "Test"
+          @context = context
+        end
+
+        # declare specitification in the context
+        def declare
+          @testcases.each do |tc|
+            case tc
+            when Naming::Eq, Naming::Block
+              test_case(tc)
+            when SucceedCase
+              succeed_case(tc)
+            when FailCase
+              fail_case(tc)
+            end
+          end
+        end
+
+        private
+
+        def parse(string)
+          # cut indentations
+          string = Util::Indentation.cut(string)
+          parser = parser_class.new.send(@parser_name).parse(string)
+          transformer_class.new.apply(parser, package_name: package_name, filename: filename)
+        end
+
+        # declare by TestCase
+        def test_case(tc)
+          string = tc.value.string
+          expected = tc.value.expected
+          res = parse(string)
+          msg = "should get %s:%s%s"
+          msg_args = [@name, string.include?("\n") ? "\n" : " ", string.chomp]
+
+          @context.it(msg % msg_args) do
+            case tc
+            when Naming::Eq
+              res.should == expected
+            when Naming::Block
+              expected.call(res)
+            end
+          end
+        end
+
+        # declare by SucceedCase
+        def succeed_case(tc)
+          block = Proc.new {parse(tc.string)}
+          msg = "should succeed in %s transformation:%s%s"
+          msg_args = [@name, tc.string.include?("\n") ? "\n" : " ", tc.string.chomp]
+
+          @context.it(msg % msg_args) { should.not.raise(&block) }
+        end
+
+        # declare by FailCase
+        def fail_case(tc)
+          block = Proc.new {parse(tc.string)}
+          msg = "should fail in %s transformation with %s:%s%s"
+          msg_args = [@name, tc.exception_type, tc.string.include?("\n") ? "\n" : " ", tc.string.chomp]
+
+          @context.it(msg % msg_args) { should.raise(tc.exception_type, &block) }
+        end
+      end
+
+      class << self
+        # Define transformer specification.
+        def spec(name, parser_name, option={}, context, &b)
+          testcases = TestCases.new.tap {|x| x.instance_eval(&b)}
+
+          # setup bacon context
+          context.describe(name) do
+            Spec.new(testcases, name, parser_name, option, context).declare
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/test-helper/tuple-helper.rb

@@ -0,0 +1,13 @@
+module Pione
+  module TestHelper
+    module Tuple
+      def self.task(package_id, rule_name, inputs, param_set=nil, features=nil, caller_id='root')
+        param_set = Pione::Lang::ParameterSet.new unless param_set
+        features = Pione::Lang::FeatureSequence.new unless features
+        digest = Util::TaskDigest.generate(package_id, rule_name, inputs, param_set)
+        domain_id = Util::DomainID.generate(package_id, rule_name, inputs, param_set)
+        Pione::TupleSpace::TaskTuple.new(digest, package_id, rule_name, inputs, param_set, features, domain_id, caller_id)
+      end
+    end
+  end
+end

data/lib/pione/test-helper/tuple-space-helper.rb

@@ -0,0 +1,31 @@
+module Pione
+  module TestHelper
+    module TupleSpace
+      # Create a customized tuple space.
+      def self.create(context=nil)
+        # make drb server and it's connection
+        tuple_space = Pione::TupleSpace::TupleSpaceServer.new({}, false)
+
+        # base location
+        base_location = Pione::Location[Temppath.create]
+        tuple_space.write(Pione::TupleSpace::BaseLocationTuple.new(base_location))
+
+        context.set_tuple_space(tuple_space) if context
+
+        return tuple_space
+      end
+
+      # Check exceptions in tuple space.
+      def self.check_exceptions(tuple_space)
+        exceptions = tuple_space.read_all(Pione::TupleSpace::ExceptionTuple.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
+    end
+  end
+end