puppet 3.6.2 → 3.7.0

data/lib/puppet/vendor/rgen/test/model_builder/serializer_test.rb

@@ -0,0 +1,94 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'test/unit'
+require 'rgen/ecore/ecore'
+
+# The following would also influence other tests...
+#
+#module RGen::ECore
+#  class EGenericType < EObject
+#    contains_many_uni 'eTypeArguments', EGenericType
+#  end
+#  class ETypeParameter < ENamedElement
+#  end
+#  class EClassifier
+#    contains_many_uni 'eTypeParameters', ETypeParameter
+#  end
+#  class ETypedElement
+#    has_one 'eGenericType', EGenericType
+#  end
+#end
+#
+#RGen::ECore::ECoreInterface.clear_ecore_cache
+#RGen::ECore::EString.ePackage = RGen::ECore.ecore
+
+require 'rgen/environment'
+require 'rgen/model_builder/model_serializer'
+require 'rgen/instantiator/ecore_xml_instantiator'
+require 'rgen/model_builder'
+require 'model_builder/statemachine_metamodel'
+
+class ModelSerializerTest < Test::Unit::TestCase
+  def test_ecore_internal
+    File.open(File.dirname(__FILE__)+"/ecore_internal.rb","w") do |f|
+      serializer = RGen::ModelBuilder::ModelSerializer.new(f, RGen::ECore.ecore)
+      serializer.serialize(RGen::ECore.ecore)
+    end
+  end
+  
+  def test_roundtrip
+    model = %{\
+statemachine "Airconditioner" do
+  state "Off", :kind => :START
+  compositeState "On" do
+    state "Heating"
+    state "Cooling"
+    state "Dumm"
+  end
+  transition "_Transition1", :sourceState => "On.Cooling", :targetState => "On.Heating"
+  transition "_Transition2", :sourceState => "On.Heating", :targetState => "On.Cooling"
+end
+}
+    check_roundtrip(StatemachineMetamodel, model)
+  end
+  
+  module AmbiguousRoleMM
+    extend RGen::MetamodelBuilder::ModuleExtension
+    class A < RGen::MetamodelBuilder::MMBase
+    end
+    class B < RGen::MetamodelBuilder::MMBase
+    end
+    class C < B
+    end
+    A.contains_many 'role1', B, 'back1'
+    A.contains_many 'role2', B, 'back2'
+  end
+
+  def test_roundtrip_ambiguous_role
+    model = %{\
+a "_A1" do
+  b "_B1", :as => :role1
+  b "_B2", :as => :role2
+  c "_C1", :as => :role2
+end
+}
+    check_roundtrip(AmbiguousRoleMM, model)
+  end
+
+  private
+
+  def build_model(mm, model)
+    RGen::ModelBuilder.build(mm) do
+      eval(model)
+    end
+  end
+
+  def check_roundtrip(mm, model)
+    sm = build_model(mm, model)
+    f = StringIO.new
+    serializer = RGen::ModelBuilder::ModelSerializer.new(f, mm.ecore)
+    serializer.serialize(sm)
+    assert_equal model, f.string
+  end
+
+end

data/lib/puppet/vendor/rgen/test/model_builder/statemachine_metamodel.rb

@@ -0,0 +1,42 @@
+# a test metamodel used by the following tests
+module StatemachineMetamodel
+  extend RGen::MetamodelBuilder::ModuleExtension
+  
+  module Condition
+    extend RGen::MetamodelBuilder::ModuleExtension
+  
+    class Condition < RGen::MetamodelBuilder::MMBase
+    end
+  
+    module TimeCondition
+      extend RGen::MetamodelBuilder::ModuleExtension
+  
+      class TimeCondition < Condition
+        has_attr 'timeout', Integer
+      end
+    end
+  end
+  
+  class Statemachine < RGen::MetamodelBuilder::MMBase
+    has_attr 'name'
+  end
+  
+  class State < RGen::MetamodelBuilder::MMBase
+    has_attr 'name'
+    has_attr 'kind', RGen::MetamodelBuilder::DataTypes::Enum.new([:START])
+  end
+  
+  class CompositeState < State
+    has_attr 'name'
+    contains_many 'state', State, 'compositeState'
+  end
+  
+  class Transition < RGen::MetamodelBuilder::MMBase
+    many_to_one 'sourceState', State, 'outgoingTransition'
+    many_to_one 'targetState', State, 'incomingTransition'
+    has_many 'condition', Condition::Condition
+  end
+  
+  Statemachine.contains_many 'state', State, 'statemachine'
+  Statemachine.contains_many 'transition', Transition, 'statemachine'
+end

data/lib/puppet/vendor/rgen/test/model_builder/test_model/statemachine1.rb

@@ -0,0 +1,23 @@
+statemachine "Airconditioner" do
+  state "Off", :kind => :START
+  compositeState "On" do
+    state "Heating" do
+      transition :as => :outgoingTransition, :targetState => "Cooling",
+        :statemachine => "Airconditioner"
+    end
+    state "Cooling" do
+    end
+  end
+  transition :sourceState => "On.Cooling", :targetState => "On.Heating" do
+    _using Condition::TimeCondition do
+      timeCondition :as => :condition, :timeout => 100
+    end
+    Condition::TimeCondition.timeCondition :as => :condition, :timeout => 10
+  end
+end
+_using Condition do
+  statemachine "AirconExtension" do
+    s = state "StartState"
+    transition :sourceState => s, :targetState => "Airconditioner.Off"
+  end
+end

data/lib/puppet/vendor/rgen/test/model_builder_test.rb

@@ -0,0 +1,6 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'model_builder/builder_test'
+require 'model_builder/serializer_test'
+require 'model_builder/builder_context_test'
+require 'model_builder/reference_resolver_test'

data/lib/puppet/vendor/rgen/test/model_fragment_test.rb

@@ -0,0 +1,30 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/metamodel_builder'
+require 'rgen/fragment/model_fragment'
+
+class ModelFragmentTest < Test::Unit::TestCase
+
+module TestMetamodel
+  extend RGen::MetamodelBuilder::ModuleExtension
+
+  class SimpleClass < RGen::MetamodelBuilder::MMBase
+    has_attr 'name', String
+    contains_many 'subclass', SimpleClass, 'parent'
+  end
+end
+
+def test_elements
+  root = TestMetamodel::SimpleClass.new(:name => "parent",
+    :subclass => [TestMetamodel::SimpleClass.new(:name => "child")])
+  
+  frag = RGen::Fragment::ModelFragment.new("location")
+  frag.set_root_elements([root])
+
+  assert_equal 2, frag.elements.size
+end
+
+end
+
+

data/lib/puppet/vendor/rgen/test/output_handler_test.rb

@@ -0,0 +1,58 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/template_language/output_handler'
+
+class MetamodelBuilderTest < Test::Unit::TestCase
+	def test_direct_nl
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :direct
+		h << "Test"
+		h.ignoreNextNL
+		h << "\nContent"
+		assert_equal "TestContent", h.to_s
+	end
+	def test_direct_ws
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :direct
+		h << "Test"
+		h.ignoreNextWS
+		h << " \n       Content"
+		assert_equal "TestContent", h.to_s
+	end
+	def test_explicit_indent
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :explicit
+		h.indent = 1
+		h << "Start"
+		h << "   \n "
+		h << "Test"
+		h << "      \n   \n    Content"
+		assert_equal "   Start\n   Test\n   Content", h.to_s
+	end
+	def test_explicit_endswithws
+		h = RGen::TemplateLanguage::OutputHandler.new
+		h.mode = :explicit
+		h.indent = 1
+		h << "Start   \n\n"
+		assert_equal "   Start\n", h.to_s
+	end
+  def test_performance
+    h = RGen::TemplateLanguage::OutputHandler.new
+    h.mode = :explicit
+    h.indent = 1
+    line = (1..50).collect{|w| "someword"}.join(" ")+"\n"
+    # repeat more often to make performance differences visible
+    20.times do 
+      h << line
+    end
+  end
+	def test_indent_string
+		h = RGen::TemplateLanguage::OutputHandler.new(1, "\t", :explicit)
+		h << "Start"
+		h << "   \n "
+		h << "Test"
+		h << "      \n   \n    Content"
+		assert_equal "\tStart\n\tTest\n\tContent", h.to_s
+	end
+end

data/lib/puppet/vendor/rgen/test/qualified_name_provider_test.rb

@@ -0,0 +1,48 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/metamodel_builder'
+require 'rgen/serializer/qualified_name_provider'
+
+class QualifiedNameProviderTest < Test::Unit::TestCase
+
+  class AbstractTestNode < RGen::MetamodelBuilder::MMBase
+    contains_many 'children', AbstractTestNode, "parent"
+  end
+
+  class NamedNode < AbstractTestNode
+    has_attr 'n', String
+  end
+
+  class UnnamedNode < AbstractTestNode
+  end
+
+  def test_simple
+    root = NamedNode.new(:n => "root", :children => [
+      NamedNode.new(:n => "a", :children => [
+        NamedNode.new(:n => "a1")
+      ]),
+      UnnamedNode.new(:children => [
+        NamedNode.new(:n => "b1")
+      ])
+    ])
+
+    qnp = RGen::Serializer::QualifiedNameProvider.new(:attribute_name => "n")
+
+    assert_equal "/root", qnp.identifier(root)
+    assert_equal "/root/a", qnp.identifier(root.children[0])
+    assert_equal "/root/a/a1", qnp.identifier(root.children[0].children[0])
+    assert_equal "/root", qnp.identifier(root.children[1])
+    assert_equal "/root/b1", qnp.identifier(root.children[1].children[0])
+  end
+
+  def test_unnamed_root
+    root = UnnamedNode.new
+
+    qnp = RGen::Serializer::QualifiedNameProvider.new(:attribute_name => "n")
+
+    assert_equal "/", qnp.identifier(root)
+  end
+
+end
+

data/lib/puppet/vendor/rgen/test/qualified_name_resolver_test.rb

@@ -0,0 +1,102 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/metamodel_builder'
+require 'rgen/instantiator/qualified_name_resolver'
+
+class QualifiedNameResolverTest < Test::Unit::TestCase
+
+  class TestNode < RGen::MetamodelBuilder::MMBase
+    has_attr 'name', String
+    has_one 'nextSibling', TestNode
+    contains_many 'children', TestNode, "parent"
+  end
+
+  class TestNode2 < RGen::MetamodelBuilder::MMBase
+    has_attr 'cname', String
+    has_one 'nextSibling', TestNode2
+    contains_many 'children', TestNode2, "parent"
+  end
+
+  class TestNode3 < RGen::MetamodelBuilder::MMBase
+    has_attr 'name', String
+    contains_one 'child', TestNode3, "parent"
+  end
+
+  def testModel
+    [TestNode.new(:name => "Root1", :children => [
+      TestNode.new(:name => "Sub11"),
+      TestNode.new(:name => "Sub12", :children => [
+        TestNode.new(:name => "Sub121")])]),
+     TestNode.new(:name => "Root2", :children => [
+      TestNode.new(:name => "Sub21", :children => [
+        TestNode.new(:name => "Sub211")])]),
+     TestNode.new(:name => "Root3"),
+     TestNode.new(:name => "Root3")
+     ]
+  end
+
+  def testModel2
+    [TestNode2.new(:cname => "Root1", :children => [
+      TestNode2.new(:cname => "Sub11")])]
+  end
+
+  def testModel3
+    [TestNode3.new(:name => "Root1", :child =>
+      TestNode3.new(:name => "Sub11", :child =>
+        TestNode3.new(:name => "Sub111")))]
+  end
+
+  def test_customNameAttribute
+    model = testModel2
+    res = RGen::Instantiator::QualifiedNameResolver.new(model, :nameAttribute => "cname")
+    assert_equal model[0], res.resolveIdentifier("/Root1")
+    assert_equal model[0].children[0], res.resolveIdentifier("/Root1/Sub11")
+  end
+
+  def test_customSeparator
+    model = testModel
+    res = RGen::Instantiator::QualifiedNameResolver.new(model, :separator => "|")
+    assert_equal model[0], res.resolveIdentifier("|Root1")
+    assert_nil res.resolveIdentifier("/Root1")
+    assert_equal model[0].children[0], res.resolveIdentifier("|Root1|Sub11")
+  end
+
+  def test_noLeadingSeparator
+    model = testModel
+    res = RGen::Instantiator::QualifiedNameResolver.new(model, :leadingSeparator => false)
+    assert_equal model[0], res.resolveIdentifier("Root1")
+    assert_nil res.resolveIdentifier("/Root1")
+    assert_equal model[0].children[0], res.resolveIdentifier("Root1/Sub11")
+  end
+    
+	def test_resolve
+    model = testModel
+    res = RGen::Instantiator::QualifiedNameResolver.new(model)
+    assert_equal model[0], res.resolveIdentifier("/Root1")
+    # again
+    assert_equal model[0], res.resolveIdentifier("/Root1")
+    assert_equal model[0].children[0], res.resolveIdentifier("/Root1/Sub11")
+    # again
+    assert_equal model[0].children[0], res.resolveIdentifier("/Root1/Sub11")
+    assert_equal model[0].children[1], res.resolveIdentifier("/Root1/Sub12")
+    assert_equal model[0].children[1].children[0], res.resolveIdentifier("/Root1/Sub12/Sub121")
+    assert_equal model[1], res.resolveIdentifier("/Root2")
+    assert_equal model[1].children[0], res.resolveIdentifier("/Root2/Sub21")
+    assert_equal model[1].children[0].children[0], res.resolveIdentifier("/Root2/Sub21/Sub211")
+    # duplicate name yields two result elements
+    assert_equal [model[2], model[3]], res.resolveIdentifier("/Root3")
+    assert_equal nil, res.resolveIdentifier("/RootX")
+    assert_equal nil, res.resolveIdentifier("/Root1/SubX")
+  end
+
+  def test_oneChild
+    model = testModel3
+    res = RGen::Instantiator::QualifiedNameResolver.new(model)
+    assert_equal model[0], res.resolveIdentifier("/Root1")
+    assert_equal model[0].child, res.resolveIdentifier("/Root1/Sub11")
+    assert_equal model[0].child.child, res.resolveIdentifier("/Root1/Sub11/Sub111")
+  end
+
+end
+

data/lib/puppet/vendor/rgen/test/reference_resolver_test.rb

@@ -0,0 +1,117 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'test/unit'
+require 'rgen/metamodel_builder'
+require 'rgen/instantiator/reference_resolver'
+
+class ReferenceResolverTest < Test::Unit::TestCase
+
+  class TestNode < RGen::MetamodelBuilder::MMBase
+    has_attr 'name', String
+    has_one 'other', TestNode
+    has_many 'others', TestNode
+  end
+
+  class TestNode2 < RGen::MetamodelBuilder::MMBase
+    has_attr 'name', String
+  end
+
+  def test_identifier_resolver
+    nodeA, nodeB, nodeC, unresolved_refs = create_model
+    resolver = RGen::Instantiator::ReferenceResolver.new(
+      :identifier_resolver => proc do |ident|
+        {:a => nodeA, :b => nodeB, :c => nodeC}[ident]
+      end)
+    urefs = resolver.resolve(unresolved_refs)
+    check_model(nodeA, nodeB, nodeC)
+    assert urefs.empty?
+  end
+
+  def test_add_identifier
+    nodeA, nodeB, nodeC, unresolved_refs = create_model
+    resolver = RGen::Instantiator::ReferenceResolver.new
+    resolver.add_identifier(:a, nodeA)
+    resolver.add_identifier(:b, nodeB)
+    resolver.add_identifier(:c, nodeC)
+    urefs = resolver.resolve(unresolved_refs)
+    check_model(nodeA, nodeB, nodeC)
+    assert urefs.empty?
+  end
+
+  def test_problems
+    nodeA, nodeB, nodeC, unresolved_refs = create_model
+    resolver = RGen::Instantiator::ReferenceResolver.new(
+      :identifier_resolver => proc do |ident|
+        {:a => [nodeA, nodeB], :c => nodeC}[ident]
+      end)
+    problems = []
+    urefs = resolver.resolve(unresolved_refs, :problems => problems)
+    assert_equal ["identifier b not found", "identifier a not uniq"], problems
+    assert_equal 2, urefs.size
+    assert urefs.all?{|ur| !ur.target_type_error}
+  end
+
+  def test_on_resolve_proc
+    nodeA, nodeB, nodeC, unresolved_refs = create_model
+    resolver = RGen::Instantiator::ReferenceResolver.new
+    resolver.add_identifier(:a, nodeA)
+    resolver.add_identifier(:b, nodeB)
+    resolver.add_identifier(:c, nodeC)
+    data = []
+    resolver.resolve(unresolved_refs, 
+      :on_resolve => proc {|ur, e| data << [ ur, e ]})
+    assert data[0][0].is_a?(RGen::Instantiator::ReferenceResolver::UnresolvedReference)
+    assert_equal nodeA, data[0][0].element 
+    assert_equal "other", data[0][0].feature_name 
+    assert_equal :b, data[0][0].proxy.targetIdentifier 
+    assert_equal nodeB, data[0][1]
+  end
+
+  def test_target_type_error
+    nodeA, nodeB, nodeC, unresolved_refs = create_model
+    resolver = RGen::Instantiator::ReferenceResolver.new(
+      :identifier_resolver => proc do |ident|
+        {:a => TestNode2.new, :b => TestNode2.new, :c => nodeC}[ident]
+      end)
+    problems = []
+    urefs = resolver.resolve(unresolved_refs, :problems => problems)
+    assert_equal 2, problems.size
+    assert problems[0] =~ /invalid target type .*TestNode2/
+    assert problems[1] =~ /invalid target type .*TestNode2/
+    assert_equal 2, urefs.uniq.size
+    assert urefs[0].target_type_error
+    assert urefs[1].target_type_error
+    assert urefs.any?{|ur| ur.proxy.object_id == nodeA.other.object_id}
+    assert urefs.any?{|ur| ur.proxy.object_id == nodeB.others[0].object_id}
+  end
+
+  private
+
+  def create_model
+    nodeA = TestNode.new(:name => "NodeA")
+    nodeB = TestNode.new(:name => "NodeB")
+    nodeC = TestNode.new(:name => "NodeC")
+    bProxy = RGen::MetamodelBuilder::MMProxy.new(:b) 
+    nodeA.other = bProxy 
+    aProxy = RGen::MetamodelBuilder::MMProxy.new(:a) 
+    cProxy = RGen::MetamodelBuilder::MMProxy.new(:c) 
+    nodeB.others = [aProxy, cProxy] 
+    unresolved_refs = [
+      RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(nodeA, "other", bProxy),
+      RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(nodeB, "others", aProxy),
+      RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(nodeB, "others", cProxy)
+    ]
+    return nodeA, nodeB, nodeC, unresolved_refs
+  end
+
+  def check_model(nodeA, nodeB, nodeC)
+    assert_equal nodeB, nodeA.other
+    assert_equal [], nodeA.others
+    assert_equal nil, nodeB.other
+    assert_equal [nodeA, nodeC], nodeB.others
+    assert_equal nil, nodeC.other
+    assert_equal [], nodeC.others
+  end
+
+end
+