puppet 7.28.0-universal-darwin → 7.29.1-universal-darwin

data/spec/unit/pops/factory_spec.rb

@@ -1,309 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require File.join(File.dirname(__FILE__), '/factory_rspec_helper')
-
-# This file contains testing of the pops model factory
-#
-
-describe Puppet::Pops::Model::Factory do
-  include FactoryRspecHelper
-
-  context "When factory methods are invoked they should produce expected results" do
-    it "tests #var should create a VariableExpression" do
-      expect(var('a').model.class).to eq(Puppet::Pops::Model::VariableExpression)
-    end
-
-    it "tests #fqn should create a QualifiedName" do
-      expect(fqn('a').model.class).to eq(Puppet::Pops::Model::QualifiedName)
-    end
-
-    it "tests #QNAME should create a QualifiedName" do
-      expect(QNAME('a').model.class).to eq(Puppet::Pops::Model::QualifiedName)
-    end
-
-    it "tests #QREF should create a QualifiedReference" do
-      expect(QREF('a').model.class).to eq(Puppet::Pops::Model::QualifiedReference)
-    end
-
-    it "tests #block should create a BlockExpression" do
-      expect(block().model.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
-    end
-
-    it "should create a literal undef on :undef" do
-      expect(literal(:undef).model.class).to eq(Puppet::Pops::Model::LiteralUndef)
-    end
-
-    it "should create a literal default on :default" do
-      expect(literal(:default).model.class).to eq(Puppet::Pops::Model::LiteralDefault)
-    end
-  end
-
-  context "When calling block_or_expression" do
-    it "A single expression should produce identical output" do
-      expect(block_or_expression([literal(1) + literal(2)]).model.is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
-    end
-
-    it "Multiple expressions should produce a block expression" do
-      braces = double('braces')
-      allow(braces).to receive(:offset).and_return(0)
-      allow(braces).to receive(:length).and_return(0)
-
-      model = block_or_expression([literal(1) + literal(2), literal(2) + literal(3)], braces, braces).model
-      expect(model.is_a?(Puppet::Pops::Model::BlockExpression)).to eq(true)
-      expect(model.statements.size).to eq(2)
-    end
-  end
-
-  context "When processing calls with CALL_NAMED" do
-    it "Should be possible to state that r-value is required" do
-      built = call_named('foo', true).model
-      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
-      expect(built.rval_required).to eq(true)
-    end
-
-    it "Should produce a call expression without arguments" do
-      built = call_named('foo', false).model
-      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
-      expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
-      expect(built.functor_expr.value).to eq("foo")
-      expect(built.rval_required).to eq(false)
-      expect(built.arguments.size).to eq(0)
-    end
-
-    it "Should produce a call expression with one argument" do
-      built = call_named('foo', false, literal(1) + literal(2)).model
-      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
-      expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
-      expect(built.functor_expr.value).to eq("foo")
-      expect(built.rval_required).to eq(false)
-      expect(built.arguments.size).to eq(1)
-      expect(built.arguments[0].is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
-    end
-
-    it "Should produce a call expression with two arguments" do
-      built = call_named('foo', false, literal(1) + literal(2), literal(1) + literal(2)).model
-      expect(built.is_a?(Puppet::Pops::Model::CallNamedFunctionExpression)).to eq(true)
-      expect(built.functor_expr.is_a?(Puppet::Pops::Model::QualifiedName)).to eq(true)
-      expect(built.functor_expr.value).to eq("foo")
-      expect(built.rval_required).to eq(false)
-      expect(built.arguments.size).to eq(2)
-      expect(built.arguments[0].is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
-      expect(built.arguments[1].is_a?(Puppet::Pops::Model::ArithmeticExpression)).to eq(true)
-    end
-  end
-
-  context "When creating attribute operations" do
-    it "Should produce an attribute operation for =>" do
-      built = ATTRIBUTE_OP('aname', '=>', literal('x')).model
-      built.is_a?(Puppet::Pops::Model::AttributeOperation)
-      expect(built.operator).to eq('=>')
-      expect(built.attribute_name).to eq("aname")
-      expect(built.value_expr.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
-    end
-
-    it "Should produce an attribute operation for +>" do
-      built = ATTRIBUTE_OP('aname', '+>', literal('x')).model
-      built.is_a?(Puppet::Pops::Model::AttributeOperation)
-      expect(built.operator).to eq('+>')
-      expect(built.attribute_name).to eq("aname")
-      expect(built.value_expr.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
-    end
-  end
-
-  context "When processing RESOURCE" do
-    it "Should create a Resource body" do
-      built = RESOURCE_BODY(literal('title'), [ATTRIBUTE_OP('aname', '=>', literal('x'))]).model
-      expect(built.is_a?(Puppet::Pops::Model::ResourceBody)).to eq(true)
-      expect(built.title.is_a?(Puppet::Pops::Model::LiteralString)).to eq(true)
-      expect(built.operations.size).to eq(1)
-      expect(built.operations[0].class).to eq(Puppet::Pops::Model::AttributeOperation)
-      expect(built.operations[0].attribute_name).to eq('aname')
-    end
-
-    it "Should create a RESOURCE without a resource body" do
-      bodies = []
-      built = RESOURCE(literal('rtype'), bodies).model
-      expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
-      expect(built.bodies.size).to eq(0)
-    end
-
-    it "Should create a RESOURCE with 1 resource body" do
-      bodies = [] << RESOURCE_BODY(literal('title'), [])
-      built = RESOURCE(literal('rtype'), bodies).model
-      expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
-      expect(built.bodies.size).to eq(1)
-      expect(built.bodies[0].title.value).to eq('title')
-    end
-
-    it "Should create a RESOURCE with 2 resource bodies" do
-      bodies = [] << RESOURCE_BODY(literal('title'), []) << RESOURCE_BODY(literal('title2'), [])
-      built = RESOURCE(literal('rtype'), bodies).model
-      expect(built.class).to eq(Puppet::Pops::Model::ResourceExpression)
-      expect(built.bodies.size).to eq(2)
-      expect(built.bodies[0].title.value).to eq('title')
-      expect(built.bodies[1].title.value).to eq('title2')
-    end
-  end
-
-  context "When processing simple literals" do
-    it "Should produce a literal boolean from a boolean" do
-      model = literal(true).model
-      expect(model.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(model.value).to eq(true)
-      model = literal(false).model
-      expect(model.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(model.value).to eq(false)
-    end
-  end
-
-  context "When processing COLLECT" do
-    it "should produce a virtual query" do
-      model = VIRTUAL_QUERY(fqn('a').eq(literal(1))).model
-      expect(model.class).to eq(Puppet::Pops::Model::VirtualQuery)
-      expect(model.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
-      expect(model.expr.operator).to eq('==')
-    end
-
-    it "should produce an export query" do
-      model = EXPORTED_QUERY(fqn('a').eq(literal(1))).model
-      expect(model.class).to eq(Puppet::Pops::Model::ExportedQuery)
-      expect(model.expr.class).to eq(Puppet::Pops::Model::ComparisonExpression)
-      expect(model.expr.operator).to eq('==')
-    end
-
-    it "should produce a collect expression" do
-      q = VIRTUAL_QUERY(fqn('a').eq(literal(1)))
-      built = COLLECT(literal('t'), q, [ATTRIBUTE_OP('name', '=>', literal(3))]).model
-      expect(built.class).to eq(Puppet::Pops::Model::CollectExpression)
-      expect(built.operations.size).to eq(1)
-    end
-
-    it "should produce a collect expression without attribute operations" do
-      q = VIRTUAL_QUERY(fqn('a').eq(literal(1)))
-      built = COLLECT(literal('t'), q, []).model
-      expect(built.class).to eq(Puppet::Pops::Model::CollectExpression)
-      expect(built.operations.size).to eq(0)
-    end
-  end
-
-  context "When processing concatenated string(iterpolation)" do
-    it "should handle 'just a string'" do
-      model = string('blah blah').model
-      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      expect(model.segments.size).to eq(1)
-      expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(model.segments[0].value).to eq("blah blah")
-    end
-
-    it "should handle one expression in the middle" do
-      model = string('blah blah', TEXT(literal(1)+literal(2)), 'blah blah').model
-      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      expect(model.segments.size).to eq(3)
-      expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(model.segments[0].value).to eq("blah blah")
-      expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(model.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
-      expect(model.segments[2].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(model.segments[2].value).to eq("blah blah")
-    end
-
-    it "should handle one expression at the end" do
-      model = string('blah blah', TEXT(literal(1)+literal(2))).model
-      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      expect(model.segments.size).to eq(2)
-      expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
-      expect(model.segments[0].value).to eq("blah blah")
-      expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(model.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
-    end
-
-    it "should handle only one expression" do
-      model = string(TEXT(literal(1)+literal(2))).model
-      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      expect(model.segments.size).to eq(1)
-      expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
-    end
-
-    it "should handle several expressions" do
-      model = string(TEXT(literal(1)+literal(2)), TEXT(literal(1)+literal(2))).model
-      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      expect(model.segments.size).to eq(2)
-      expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
-      expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
-      expect(model.segments[1].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
-    end
-
-    it "should handle no expression" do
-      model = string().model
-      expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 0
-    end
-  end
-
-  context "When processing UNLESS" do
-    it "should create an UNLESS expression with then part" do
-      built = UNLESS(literal(true), literal(1), literal(nil)).model
-      expect(built.class).to eq(Puppet::Pops::Model::UnlessExpression)
-      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
-      expect(built.else_expr.class).to eq(Puppet::Pops::Model::Nop)
-    end
-
-    it "should create an UNLESS expression with then and else parts" do
-      built = UNLESS(literal(true), literal(1), literal(2)).model
-      expect(built.class).to eq(Puppet::Pops::Model::UnlessExpression)
-      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
-      expect(built.else_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
-    end
-  end
-
-  context "When processing IF" do
-    it "should create an IF expression with then part" do
-      built = IF(literal(true), literal(1), literal(nil)).model
-      expect(built.class).to eq(Puppet::Pops::Model::IfExpression)
-      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
-      expect(built.else_expr.class).to eq(Puppet::Pops::Model::Nop)
-    end
-
-    it "should create an IF expression with then and else parts" do
-      built = IF(literal(true), literal(1), literal(2)).model
-      expect(built.class).to eq(Puppet::Pops::Model::IfExpression)
-      expect(built.test.class).to eq(Puppet::Pops::Model::LiteralBoolean)
-      expect(built.then_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
-      expect(built.else_expr.class).to eq(Puppet::Pops::Model::LiteralInteger)
-    end
-  end
-
-  context "When processing a Parameter" do
-    it "should create a Parameter" do
-      # PARAM(name, expr)
-      # PARAM(name)
-      #
-    end
-  end
-
-  # LIST, HASH, KEY_ENTRY
-  context "When processing Definition" do
-    # DEFINITION(classname, arguments, statements)
-    # should accept empty arguments, and no statements
-  end
-
-  context "When processing Hostclass" do
-    # HOSTCLASS(classname, arguments, parent, statements)
-    # parent may be passed as a nop /nil - check this works, should accept empty statements (nil)
-    # should accept empty arguments
-
-  end
-
-  context "When processing Node" do
-  end
-
-  # Tested in the evaluator test already, but should be here to test factory assumptions
-  #
-  # TODO: CASE / WHEN
-  # TODO: MAP
-end

data/spec/unit/pops/issues_spec.rb

@@ -1,210 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-describe "Puppet::Pops::Issues" do
-  include Puppet::Pops::Issues
-
-  it "should have an issue called NAME_WITH_HYPHEN" do
-    x = Puppet::Pops::Issues::NAME_WITH_HYPHEN
-    expect(x.class).to eq(Puppet::Pops::Issues::Issue)
-    expect(x.issue_code).to eq(:NAME_WITH_HYPHEN)
-  end
-
-  it "should should format a message that requires an argument" do
-    x = Puppet::Pops::Issues::NAME_WITH_HYPHEN
-    expect(x.format(:name => 'Boo-Hoo',
-      :label => Puppet::Pops::Model::ModelLabelProvider.new,
-      :semantic => "dummy"
-      )).to eq("A String may not have a name containing a hyphen. The name 'Boo-Hoo' is not legal")
-  end
-
-  it "should should format a message that does not require an argument" do
-    x = Puppet::Pops::Issues::NOT_TOP_LEVEL
-    expect(x.format()).to eq("Classes, definitions, and nodes may only appear at toplevel or inside other classes")
-  end
-
-end
-
-describe "Puppet::Pops::IssueReporter" do
-
-  let(:acceptor) { Puppet::Pops::Validation::Acceptor.new }
-
-  def fake_positioned(number)
-    double("positioned_#{number}", :line => number, :pos => number)
-  end
-
-  def diagnostic(severity,  number, args)
-    Puppet::Pops::Validation::Diagnostic.new(
-      severity,
-      Puppet::Pops::Issues::Issue.new(number) { "#{severity}#{number}" },
-      "#{severity}file",
-      fake_positioned(number),
-      args)
-  end
-
-  def warning(number, args = {})
-    diagnostic(:warning, number, args)
-  end
-
-  def deprecation(number, args = {})
-    diagnostic(:deprecation, number, args)
-  end
-
-  def error(number, args = {})
-    diagnostic(:error, number, args)
-  end
-
-  context "given warnings" do
-
-    before(:each) do
-      acceptor.accept( warning(1) )
-      acceptor.accept( deprecation(1) )
-    end
-
-    it "emits warnings if told to emit them" do
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
-    end
-
-    it "does not emit warnings if not told to emit them" do
-      expect(Puppet::Log).not_to receive(:create)
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, {})
-    end
-
-    it "emits no warnings if :max_warnings is 0" do
-      acceptor.accept( warning(2) )
-      Puppet[:max_warnings] = 0
-      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/deprecation1/)))
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
-    end
-
-    it "emits no more than 1 warning if :max_warnings is 1" do
-      acceptor.accept( warning(2) )
-      acceptor.accept( warning(3) )
-      Puppet[:max_warnings] = 1
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
-    end
-
-    it "does not emit more deprecations warnings than the max deprecation warnings" do
-      acceptor.accept( deprecation(2) )
-      Puppet[:max_deprecations] = 0
-      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning1/)))
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
-    end
-
-    it "does not emit deprecation warnings, but does emit regular warnings if disable_warnings includes deprecations" do
-      Puppet[:disable_warnings] = 'deprecations'
-      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning1/)))
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
-    end
-
-    it "includes diagnostic arguments in logged entry" do
-      acceptor.accept( warning(2, :n => 'a') )
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
-      expect(Puppet::Log).to receive(:create).once.with(hash_including(:level => :warning, :message => match(/warning2/), :arguments => {:n => 'a'}))
-      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
-    end
-  end
-
-  context "given errors" do
-    it "logs nothing, but raises the given :message if :emit_errors is repressing error logging" do
-      acceptor.accept( error(1) )
-      expect(Puppet::Log).not_to receive(:create)
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_errors => false, :message => 'special'})
-      end.to raise_error(Puppet::ParseError, 'special')
-    end
-
-    it "prefixes :message if a single error is raised" do
-      acceptor.accept( error(1) )
-      expect(Puppet::Log).not_to receive(:create)
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
-      end.to raise_error(Puppet::ParseError, /special error1/)
-    end
-
-    it "logs nothing and raises immediately if there is only one error" do
-      acceptor.accept( error(1) )
-      expect(Puppet::Log).not_to receive(:create)
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
-      end.to raise_error(Puppet::ParseError, /error1/)
-    end
-
-    it "logs nothing and raises immediately if there are multiple errors but max_errors is 0" do
-      acceptor.accept( error(1) )
-      acceptor.accept( error(2) )
-      Puppet[:max_errors] = 0
-      expect(Puppet::Log).not_to receive(:create)
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
-      end.to raise_error(Puppet::ParseError, /error1/)
-    end
-
-    it "logs the :message if there is more than one allowed error" do
-      acceptor.accept( error(1) )
-      acceptor.accept( error(2) )
-      expect(Puppet::Log).to receive(:create).exactly(3).times.with(hash_including(:level => :err, :message => match(/error1|error2|special/)))
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
-      end.to raise_error(Puppet::ParseError, /Giving up/)
-    end
-
-    it "emits accumulated errors before raising a 'giving up' message if there are more errors than allowed" do
-      acceptor.accept( error(1) )
-      acceptor.accept( error(2) )
-      acceptor.accept( error(3) )
-      Puppet[:max_errors] = 2
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error1|error2/)))
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
-      end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
-    end
-
-    it "emits accumulated errors before raising a 'giving up' message if there are multiple errors but fewer than limits" do
-      acceptor.accept( error(1) )
-      acceptor.accept( error(2) )
-      acceptor.accept( error(3) )
-      Puppet[:max_errors] = 4
-      expect(Puppet::Log).to receive(:create).exactly(3).times.with(hash_including(:level => :err, :message => match(/error[123]/)))
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
-      end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
-    end
-
-    it "emits errors regardless of disable_warnings setting" do
-      acceptor.accept( error(1) )
-      acceptor.accept( error(2) )
-      Puppet[:disable_warnings] = 'deprecations'
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error1|error2/)))
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
-      end.to raise_error(Puppet::ParseError, /Giving up/)
-    end
-
-    it "includes diagnostic arguments in raised error" do
-      acceptor.accept( error(1, :n => 'a') )
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
-      end.to raise_error(Puppet::ParseErrorWithIssue, /error1/) { |ex| expect(ex.arguments).to eq(:n => 'a')}
-    end
-  end
-
-  context "given both" do
-
-    it "logs warnings and errors" do
-      acceptor.accept( warning(1) )
-      acceptor.accept( error(1) )
-      acceptor.accept( error(2) )
-      acceptor.accept( error(3) )
-      acceptor.accept( deprecation(1) )
-      Puppet[:max_errors] = 2
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :warning, :message => match(/warning1|deprecation1/)))
-      expect(Puppet::Log).to receive(:create).twice.with(hash_including(:level => :err, :message => match(/error[123]/)))
-      expect do
-        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
-      end.to raise_error(Puppet::ParseError, /3 errors.*2 warnings.*Giving up/)
-    end
-  end
-end

data/spec/unit/pops/label_provider_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-describe Puppet::Pops::LabelProvider do
-  class TestLabelProvider
-    include Puppet::Pops::LabelProvider
-  end
-
-  let(:labeler) { TestLabelProvider.new }
-
-  it "prefixes words that start with a vowel with an 'an'" do
-    expect(labeler.a_an('owl')).to eq('an owl')
-  end
-
-  it "prefixes words that start with a consonant with an 'a'" do
-    expect(labeler.a_an('bear')).to eq('a bear')
-  end
-
-  it "prefixes non-word characters with an 'a'" do
-    expect(labeler.a_an('[] expression')).to eq('a [] expression')
-  end
-
-  it "ignores a single quote leading the word" do
-    expect(labeler.a_an("'owl'")).to eq("an 'owl'")
-  end
-
-  it "ignores a double quote leading the word" do
-    expect(labeler.a_an('"owl"')).to eq('an "owl"')
-  end
-
-  it "capitalizes the indefinite article for a word when requested" do
-    expect(labeler.a_an_uc('owl')).to eq('An owl')
-  end
-
-  it "raises an error when missing a character to work with" do
-    expect {
-      labeler.a_an('"')
-    }.to raise_error(Puppet::DevError, /<"> does not appear to contain a word/)
-  end
-
-  it "raises an error when given an empty string" do
-    expect {
-      labeler.a_an('')
-    }.to raise_error(Puppet::DevError, /<> does not appear to contain a word/)
-  end
-end

data/spec/unit/pops/loaders/dependency_loader_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet/pops'
-require 'puppet/loaders'
-
-describe 'dependency loader' do
-  include PuppetSpec::Files
-
-  let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
-  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
-
-  describe 'FileBased module loader' do
-    it 'prints a pretty name for itself when inspected' do
-      module_dir = dir_containing('testmodule', {
-      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
-        'foo.rb' => 'Puppet::Functions.create_function("foo") { def foo; end; }'
-      }}}}})
-
-      loader = loader_for('testmodule', module_dir)
-
-      expect(loader.inspect).to eq("(DependencyLoader 'test-dep' [(ModuleLoader::FileBased 'testmodule' 'testmodule')])")
-      expect(loader.to_s).to eq("(DependencyLoader 'test-dep' [(ModuleLoader::FileBased 'testmodule' 'testmodule')])")
-    end
-
-    it 'load something in global name space raises an error' do
-      module_dir = dir_containing('testmodule', {
-      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
-        'foo.rb' => 'Puppet::Functions.create_function("foo") { def foo; end; }'
-      }}}}})
-
-      loader = loader_for('testmodule', module_dir)
-
-      expect do
-        loader.load_typed(typed_name(:function, 'testmodule::foo')).value
-      end.to raise_error(ArgumentError, /produced mis-matched name, expected 'testmodule::foo', got foo/)
-    end
-
-    it 'can load something in a qualified name space' do
-      module_dir = dir_containing('testmodule', {
-      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
-        'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }'
-      }}}}})
-
-      loader = loader_for('testmodule', module_dir)
-
-      function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
-
-      expect(function.class.name).to eq('testmodule::foo')
-      expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
-    end
-
-    it 'can load something in a qualified name space more than once' do
-      module_dir = dir_containing('testmodule', {
-      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
-        'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }'
-      }}}}})
-
-      loader = loader_for('testmodule', module_dir)
-
-      function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
-      expect(function.class.name).to eq('testmodule::foo')
-      expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
-
-      function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
-      expect(function.class.name).to eq('testmodule::foo')
-      expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
-    end
-
-    describe "when parsing files from disk" do
-
-      # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
-      # characters chosen since they will not parse on Windows with codepage 437 or 1252
-      # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
-      let (:node) { Puppet::Node.new('node') }
-      let (:rune_utf8) { "\u16A0\u16C7\u16BB" } # ᚠᛇᚻ
-      let (:code_utf8) do <<-CODE
-Puppet::Functions.create_function('testmodule::foo') {
-  def foo
-    return \"#{rune_utf8}\"
-  end
-}
-      CODE
-      end
-
-      context 'when loading files from disk' do
-        it 'should always read files as UTF-8' do
-          module_dir = dir_containing('testmodule', {
-          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
-            'foo.rb' => code_utf8
-          }}}}})
-
-          loader = loader_for('testmodule', module_dir)
-
-          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
-          expect(function.call({})).to eq(rune_utf8)
-        end
-
-        it 'currently ignores the UTF-8 BOM (Byte Order Mark) when loading module files' do
-          bom = "\uFEFF"
-          module_dir = dir_containing('testmodule', {
-          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
-            'foo.rb' => "#{bom}#{code_utf8}"
-          }}}}})
-
-          loader = loader_for('testmodule', module_dir)
-
-          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
-          expect(function.call({})).to eq(rune_utf8)
-        end
-      end
-    end
-  end
-
-  def loader_for(name, dir)
-      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, name, dir)
-      Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader], loaders.environment)
-  end
-
-  def typed_name(type, name)
-    Puppet::Pops::Loader::TypedName.new(type, name)
-  end
-end