puppet 3.6.2 → 3.7.0

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

@@ -0,0 +1,254 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__),"..","test")
+
+require 'test/unit'
+require 'rgen/transformer'
+require 'rgen/environment'
+require 'rgen/util/model_comparator'
+require 'metamodels/uml13_metamodel'
+require 'testmodel/class_model_checker'
+
+class TransformerTest < Test::Unit::TestCase
+
+	class ModelIn
+		attr_accessor :name
+	end
+
+	class ModelInSub < ModelIn
+	end
+	
+	class ModelAIn
+		attr_accessor :name
+		attr_accessor :modelB
+	end
+
+	class ModelBIn
+		attr_accessor :name
+		attr_accessor :modelA
+	end
+
+	class ModelCIn
+		attr_accessor :number
+	end
+	
+	class ModelOut
+		attr_accessor :name
+	end
+	
+	class ModelAOut
+		attr_accessor :name
+		attr_accessor :modelB
+	end
+	
+	class ModelBOut
+		attr_accessor :name
+		attr_accessor :modelA
+	end
+	
+	class ModelCOut
+		attr_accessor :number
+	end
+	
+	class MyTransformer < RGen::Transformer
+		attr_reader :modelInTrans_count
+		attr_reader :modelAInTrans_count
+		attr_reader :modelBInTrans_count
+		
+		transform ModelIn, :to => ModelOut do
+			# aribitrary ruby code may be placed before the hash creating the output element
+			@modelInTrans_count ||= 0; @modelInTrans_count += 1
+			{ :name => name }
+		end
+		
+		transform ModelAIn, :to => ModelAOut do
+			@modelAInTrans_count ||= 0; @modelAInTrans_count += 1
+			{ :name => name, :modelB => trans(modelB) }
+		end
+		
+		transform ModelBIn, :to => ModelBOut do
+			@modelBInTrans_count ||= 0; @modelBInTrans_count += 1
+			{ :name => name, :modelA => trans(modelA) }
+		end
+		
+		transform ModelCIn, :to => ModelCOut, :if => :largeNumber do
+			# a method can be called anywhere in a transformer block
+			{ :number => duplicateNumber }
+		end
+
+		transform ModelCIn, :to => ModelCOut, :if => :smallNumber do
+			{ :number => number / 2 }
+		end
+		
+		method :largeNumber do
+			number > 1000
+		end
+		
+		method :smallNumber do
+			number < 500
+		end
+		
+		method :duplicateNumber do
+			number * 2;
+		end
+		
+	end
+	
+	class MyTransformer2 < RGen::Transformer
+		# check that subclasses are independent (i.e. do not share the rules)
+		transform ModelIn, :to => ModelOut do
+			{ :name => name }
+		end
+	end	
+	
+	def test_transformer
+		from = ModelIn.new
+		from.name = "TestName"
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+		assert t.trans(from).is_a?(ModelOut)
+		assert_equal "TestName", t.trans(from).name
+		assert_equal 1, env_out.elements.size
+		assert_equal env_out.elements.first, t.trans(from)
+		assert_equal 1, t.modelInTrans_count
+	end
+  
+  def test_transformer_chain
+    from = ModelIn.new
+    from.name = "Test1"
+    from2 = ModelIn.new
+    from2.name = "Test2"
+    from3 = ModelIn.new
+    from3.name = "Test3"
+    env_out = RGen::Environment.new
+    elementMap = {}
+    t1 = MyTransformer.new(:env_in, env_out, elementMap)
+		assert t1.trans(from).is_a?(ModelOut)
+		assert_equal "Test1", t1.trans(from).name
+		assert_equal 1, t1.modelInTrans_count
+    # modifying the element map means that following calls of +trans+ will be affected
+    assert_equal( {from => t1.trans(from)}, elementMap )
+    elementMap.merge!({from2 => :dummy})
+    assert_equal :dummy, t1.trans(from2)
+    # second transformer based on the element map of the first
+    t2 = MyTransformer.new(:env_in, env_out, elementMap)
+    # second transformer returns same objects
+    assert_equal t1.trans(from).object_id, t2.trans(from).object_id
+    assert_equal :dummy, t2.trans(from2)
+    # and no transformer rule is evaluated at this point
+		assert_equal nil, t2.modelInTrans_count
+    # now transform a new object in second transformer
+		assert t2.trans(from3).is_a?(ModelOut)
+		assert_equal "Test3", t2.trans(from3).name
+		assert_equal 1, t2.modelInTrans_count
+    # the first transformer returns the same object without evaluation of a transformer rule
+    assert_equal t1.trans(from3).object_id, t2.trans(from3).object_id
+		assert_equal 1, t1.modelInTrans_count
+  end
+	
+	def test_transformer_subclass
+		from = ModelInSub.new
+		from.name = "TestName"
+		t = MyTransformer.new
+		assert t.trans(from).is_a?(ModelOut)
+		assert_equal "TestName", t.trans(from).name
+		assert_equal 1, t.modelInTrans_count
+	end
+	
+	def test_transformer_array
+		froms = [ModelIn.new, ModelIn.new]
+		froms[0].name = "M1"
+		froms[1].name = "M2"
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+		assert t.trans(froms).is_a?(Array)
+		assert t.trans(froms)[0].is_a?(ModelOut)
+		assert_equal "M1", t.trans(froms)[0].name
+		assert t.trans(froms)[1].is_a?(ModelOut)
+		assert_equal "M2", t.trans(froms)[1].name
+		assert_equal 2, env_out.elements.size
+		assert (t.trans(froms)-env_out.elements).empty?
+		assert_equal 2, t.modelInTrans_count
+	end
+	
+	def test_transformer_cyclic
+		# setup a cyclic dependency between fromA and fromB
+		fromA = ModelAIn.new
+		fromB = ModelBIn.new
+		fromA.modelB = fromB
+		fromA.name = "ModelA"
+		fromB.modelA = fromA
+		fromB.name = "ModelB"
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+		# check that trans resolves the cycle correctly (no endless loop)
+		# both elements, fromA and fromB will be transformed with the transformation
+		# of the first element, either fromA or fromB
+		assert t.trans(fromA).is_a?(ModelAOut)
+		assert_equal "ModelA", t.trans(fromA).name
+		assert t.trans(fromA).modelB.is_a?(ModelBOut)
+		assert_equal "ModelB", t.trans(fromA).modelB.name
+		assert_equal t.trans(fromA), t.trans(fromA).modelB.modelA
+		assert_equal t.trans(fromB), t.trans(fromA).modelB
+		assert_equal 2, env_out.elements.size
+		assert (env_out.elements - [t.trans(fromA), t.trans(fromB)]).empty?
+		assert_equal 1, t.modelAInTrans_count
+		assert_equal 1, t.modelBInTrans_count
+	end
+	
+	def test_transformer_conditional
+		froms = [ModelCIn.new, ModelCIn.new, ModelCIn.new]
+		froms[0].number = 100
+		froms[1].number = 1000
+		froms[2].number = 2000
+
+		env_out = RGen::Environment.new
+		t = MyTransformer.new(:env_in, env_out)
+
+		assert t.trans(froms).is_a?(Array)
+		assert_equal 2, t.trans(froms).size
+		
+		# this one matched the smallNumber rule
+		assert t.trans(froms[0]).is_a?(ModelCOut)
+		assert_equal 50, t.trans(froms[0]).number
+		
+		# this one did not match any rule
+		assert t.trans(froms[1]).nil?
+
+		# this one matched the largeNumber rule
+		assert t.trans(froms[2]).is_a?(ModelCOut)
+		assert_equal 4000, t.trans(froms[2]).number
+		
+		# elements in environment are the same as the ones returned
+		assert_equal 2, env_out.elements.size
+		assert (t.trans(froms)-env_out.elements).empty?
+	end
+	
+	class CopyTransformer < RGen::Transformer
+		include UML13
+		def transform
+			trans(:class => UML13::Package)
+		end
+		UML13.ecore.eClassifiers.each do |c|
+		  copy c.instanceClass 
+    end
+	end
+
+	MODEL_DIR = File.join(File.dirname(__FILE__),"testmodel")
+
+	include Testmodel::ClassModelChecker
+    include RGen::Util::ModelComparator
+	
+	def test_copyTransformer
+		envIn = RGen::Environment.new
+		envOut = RGen::Environment.new
+
+    EASupport.instantiateUML13FromXMI11(envIn, MODEL_DIR+"/ea_testmodel.xml") 
+		
+		CopyTransformer.new(envIn, envOut).transform
+		checkClassModel(envOut)
+		assert modelEqual?(
+		  envIn.find(:class => UML13::Model).first,
+		  envOut.find(:class => UML13::Model).first)
+	end
+	
+end

data/lib/puppet/vendor/rgen/test/util/file_cache_map_test.rb

@@ -0,0 +1,99 @@
+$:.unshift(File.dirname(__FILE__)+"/../../lib")
+
+require 'test/unit'
+require 'fileutils'
+require 'rgen/util/file_cache_map'
+
+class FileCacheMapTest < Test::Unit::TestCase
+
+  TestDir = File.dirname(__FILE__)+"/file_cache_map_test/testdir"
+ 
+  def setup
+    FileUtils.rm_r(Dir[TestDir+"/*"])
+    # * doesn't include dot files
+    FileUtils.rm_r(Dir[TestDir+"/.cache"])
+    @cm = RGen::Util::FileCacheMap.new(".cache", ".test")
+  end
+   
+  def test_nocache
+    reasons = []
+    assert_equal(:invalid, @cm.load_data(TestDir+"/fileA", :invalidation_reasons => reasons))
+    assert_equal [:no_cachefile], reasons
+  end
+
+  def test_storeload
+    keyFile = TestDir+"/fileA"  
+    File.open(keyFile, "w") {|f| f.write("somedata")}
+    @cm.store_data(keyFile, "valuedata")
+    assert(File.exist?(TestDir+"/.cache/fileA.test"))
+    assert_equal("valuedata", @cm.load_data(keyFile))
+  end
+
+  def test_storeload_subdir
+    keyFile = TestDir+"/subdir/fileA"
+    FileUtils.mkdir(TestDir+"/subdir")
+    File.open(keyFile, "w") {|f| f.write("somedata")}
+    @cm.store_data(keyFile, "valuedata")
+    assert(File.exist?(TestDir+"/subdir/.cache/fileA.test"))
+    assert_equal("valuedata", @cm.load_data(keyFile))
+  end
+
+  def test_storeload_postfix
+    keyFile = TestDir+"/fileB.txt"  
+    File.open(keyFile, "w") {|f| f.write("somedata")}
+    @cm.store_data(keyFile, "valuedata")
+    assert(File.exist?(TestDir+"/.cache/fileB.txt.test"))
+    assert_equal("valuedata", @cm.load_data(keyFile))
+  end
+
+  def test_storeload_empty
+    keyFile = TestDir+"/fileA"  
+    File.open(keyFile, "w") {|f| f.write("")}
+    @cm.store_data(keyFile, "valuedata")
+    assert(File.exist?(TestDir+"/.cache/fileA.test"))
+    assert_equal("valuedata", @cm.load_data(keyFile))
+  end
+
+  def test_corruptcache
+    keyFile = TestDir+"/fileA"
+    File.open(keyFile, "w") {|f| f.write("somedata")}
+    @cm.store_data(keyFile, "valuedata")
+    File.open(TestDir+"/.cache/fileA.test","a") {|f| f.write("more data")}
+    reasons = []
+    assert_equal(:invalid, @cm.load_data(keyFile, :invalidation_reasons => reasons))
+    assert_equal [:cachefile_corrupted], reasons
+  end  
+
+  def test_changedcontent
+    keyFile = TestDir+"/fileA"
+    File.open(keyFile, "w") {|f| f.write("somedata")}
+    @cm.store_data(keyFile, "valuedata")
+    File.open(keyFile, "a") {|f| f.write("more data")}
+    reasons = []
+    assert_equal(:invalid, @cm.load_data(keyFile, :invalidation_reasons => reasons))
+    assert_equal [:keyfile_changed], reasons
+  end 
+
+  def test_versioninfo
+    keyFile = TestDir+"/fileA"  
+    File.open(keyFile, "w") {|f| f.write("somedata")}
+    @cm.version_info = "123"
+    @cm.store_data(keyFile, "valuedata")
+    assert(File.exist?(TestDir+"/.cache/fileA.test"))
+    assert_equal("valuedata", @cm.load_data(keyFile))
+  end
+
+  def test_changed_version
+    keyFile = TestDir+"/fileA"  
+    File.open(keyFile, "w") {|f| f.write("somedata")}
+    @cm.version_info = "123"
+    @cm.store_data(keyFile, "valuedata")
+    @cm.version_info = "456"
+    reasons = []
+    assert_equal(:invalid, @cm.load_data(keyFile, :invalidation_reasons => reasons))
+    assert_equal [:keyfile_changed], reasons
+  end
+
+end
+
+

data/lib/puppet/vendor/rgen/test/util/pattern_matcher_test.rb

@@ -0,0 +1,97 @@
+$:.unshift(File.dirname(__FILE__)+"/../../lib")
+
+require 'test/unit'
+require 'rgen/environment'
+require 'rgen/metamodel_builder'
+require 'rgen/model_builder'
+require 'rgen/util/pattern_matcher'
+
+class PatternMatcherTest < Test::Unit::TestCase
+
+module TestMM
+  extend RGen::MetamodelBuilder::ModuleExtension
+
+  class Node < RGen::MetamodelBuilder::MMBase
+    has_attr 'name', String
+    contains_many 'children', Node, 'parent'
+  end
+end
+
+def modelA 
+  env = RGen::Environment.new
+  RGen::ModelBuilder.build(TestMM, env) do 
+    node "A" do
+      node "AA"
+    end
+    node "B" do
+      node "B1"
+      node "B2"
+      node "B3"
+    end
+    node "C" do
+      node "C1"
+      node "C2"
+    end
+    node "D" do
+      node "DD"
+    end
+  end
+  env
+end
+
+def test_simple
+  matcher = RGen::Util::PatternMatcher.new
+  matcher.add_pattern("simple") do |env, c|
+    TestMM::Node.new(:name => "A", :children => [
+      TestMM::Node.new(:name => "AA")])
+  end
+  matcher.add_pattern("bad") do |env, c|
+    TestMM::Node.new(:name => "X")
+  end
+  env = modelA
+
+  match = matcher.find_pattern(env, "simple")
+  assert_not_nil match
+  assert_equal "A", match.root.name
+  assert_equal env.find(:class => TestMM::Node, :name => "A").first.object_id, match.root.object_id
+  assert_equal 2, match.elements.size
+  assert_equal [nil], match.bound_values
+
+  assert_nil matcher.find_pattern(env, "bad")
+end
+
+def test_value_binding
+  matcher = RGen::Util::PatternMatcher.new
+  matcher.add_pattern("single_child") do |env, name, child|
+    TestMM::Node.new(:name => name, :children => [ child ])
+  end
+  matcher.add_pattern("double_child") do |env, name, child1, child2|
+    TestMM::Node.new(:name => name, :children => [ child1, child2 ])
+  end
+  matcher.add_pattern("child_pattern") do |env, child_name|
+    TestMM::Node.new(:name => "A", :children => [
+      TestMM::Node.new(:name => child_name)])
+  end
+  env = modelA
+
+  match = matcher.find_pattern(env, "single_child")
+  assert_not_nil match
+  assert_equal "A", match.root.name
+  assert_equal "AA", match.bound_values[1].name
+
+  match = matcher.find_pattern(env, "single_child", "D")
+  assert_not_nil match
+  assert_equal "D", match.root.name
+  assert_equal "DD", match.bound_values[0].name
+
+  match = matcher.find_pattern(env, "double_child")
+  assert_not_nil match
+  assert_equal "C", match.root.name
+
+  match = matcher.find_pattern(env, "child_pattern")
+  assert_not_nil match
+  assert_equal ["AA"], match.bound_values
+end
+
+end
+