class ReferenceResolverTest

createJob(hash) click to toggle source

# File lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb, line 46
def createJob(hash)
  raise "Invalid arguments" unless \
    hash.is_a?(Hash) && (hash.keys & [:receiver, :reference, :namespace, :string]).size == 4
  RGen::ModelBuilder::ReferenceResolver::ResolverJob.new(
    hash[:receiver], hash[:reference], hash[:namespace], hash[:string])
end

setElementNames(resolver, elements) click to toggle source

# File lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb, line 40
def setElementNames(resolver, elements)
  elements.each do |e|
    resolver.setElementName(e, e.name)
  end
end

testModel() click to toggle source

# File lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb, line 29
def testModel
  a1 = ClassA.new(:name => "a1")
  a2 = ClassA.new(:name => "a2")
  b1 = ClassB.new(:name => "b1", :parentA => a1)
  b2 = ClassB.new(:name => "b2", :parentA => a1)
  c1 = ClassC.new(:name => "c1", :parentB => b1)
  c2 = ClassC.new(:name => "c2", :parentB => b1)
  c3 = ClassC.new(:name => "c3", :parentB => b1)
  [a1, a2, b1, b2, c1, c2, c3]
end

test_add_identifier() click to toggle source

# File lib/puppet/vendor/rgen/test/reference_resolver_test.rb, line 30
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

test_ambiguous_prefix() click to toggle source

# File lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb, line 130
def test_ambiguous_prefix
  a = ClassA.new(:name => "name1")
  b1 = ClassB.new(:name => "name1", :parentA => a)
  b2 = ClassB.new(:name => "target", :parentA => a)
  c1 = ClassC.new(:name => "name21", :parentB => b1)
  c2 = ClassC.new(:name => "name22", :parentB => b1)
  
  toplevelNamespace = [a]
  resolver = RGen::ModelBuilder::ReferenceResolver.new
  setElementNames(resolver, [a, b1, b2, c1, c2])
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
    :namespace => b1,
    :string => "name1.name1.name21"))
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refB"},
    :namespace => b1,
    :string => "name1.target"))
  resolver.resolve(toplevelNamespace)
  
  assert_equal [c1], c2.refCs
  assert_equal b2, c2.refB
end

test_identifier_resolver() click to toggle source

# File lib/puppet/vendor/rgen/test/reference_resolver_test.rb, line 19
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

test_on_resolve_proc() click to toggle source

# File lib/puppet/vendor/rgen/test/reference_resolver_test.rb, line 54
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

test_problems() click to toggle source

# File lib/puppet/vendor/rgen/test/reference_resolver_test.rb, line 41
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

test_resolve_faulty() click to toggle source

# File lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb, line 114
def test_resolve_faulty
  a1, a2, b1, b2, c1, c2, c3 = testModel    
  
  toplevelNamespace = [a1, a2]
  resolver = RGen::ModelBuilder::ReferenceResolver.new
  setElementNames(resolver, [a1, a2, b1, b2, c1, c2, c3])
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
    :namespace => b1,
    :string => "b1.c5"))
  assert_raise RGen::ModelBuilder::ReferenceResolver::ResolverException do
    resolver.resolve(toplevelNamespace)
  end
end

test_resolve_parent_namespace() click to toggle source

# File lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb, line 81
def test_resolve_parent_namespace
  a1, a2, b1, b2, c1, c2, c3 = testModel    
  
  toplevelNamespace = [a1, a2]
  resolver = RGen::ModelBuilder::ReferenceResolver.new
  setElementNames(resolver, [a1, a2, b1, b2, c1, c2, c3])
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refA"},
    :namespace => b1,
    :string => "a1"))
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refB"},
    :namespace => b1,
    :string => "b1"))
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
    :namespace => b1,
    :string => "b1.c1"))
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
    :namespace => b1,
    :string => "a1.b1.c3"))
  resolver.resolve(toplevelNamespace)
  
  assert_equal a1, c2.refA
  assert_equal b1, c2.refB
  assert_equal [c1, c3], c2.refCs
end

test_resolve_same_namespace() click to toggle source

# File lib/puppet/vendor/rgen/test/model_builder/reference_resolver_test.rb, line 53
def test_resolve_same_namespace
  a1, a2, b1, b2, c1, c2, c3 = testModel    
  
  toplevelNamespace = [a1, a2]
  resolver = RGen::ModelBuilder::ReferenceResolver.new
  setElementNames(resolver, [a1, a2, b1, b2, c1, c2, c3])
  resolver.addJob(createJob(
    :receiver => c2,
    :reference => ClassC.ecore.eReferences.find{|r| r.name == "refCs"},
    :namespace => b1,
    :string => "c1"))
  resolver.addJob(createJob(
    :receiver => b2,
    :reference => ClassB.ecore.eReferences.find{|r| r.name == "refC"},
    :namespace => a1,
    :string => "b1.c1"))
  resolver.addJob(createJob(
    :receiver => a2,
    :reference => ClassA.ecore.eReferences.find{|r| r.name == "refC"},
    :namespace => nil,
    :string => "a1.b1.c1"))
  resolver.resolve(toplevelNamespace)
  
  assert_equal [c1], c2.refCs
  assert_equal c1, b2.refC
  assert_equal c1, a2.refC
end

test_target_type_error() click to toggle source

# File lib/puppet/vendor/rgen/test/reference_resolver_test.rb, line 70
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

Public Instance Methods