puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

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

@@ -359,10 +359,8 @@ describe 'The Loader' do
           end
 
           it 'discover is only called once on dependent loader' do
-            times_called = 0
-            allow_any_instance_of(ModuleLoaders::FileBased).to receive(:discover).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY) { times_called += 1 }.and_return([])
+            ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
             expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
-            expect(times_called).to eq(4)
           end
 
           context 'with tasks enabled' do
@@ -435,13 +433,13 @@ describe 'The Loader' do
               let(:env) { Puppet::Node::Environment.create(:none_such, [modules_dir]) }
 
               it 'an EmptyLoader is used and module loader finds types' do
-                expect_any_instance_of(Puppet::Pops::Loader::ModuleLoaders::EmptyLoader).to receive(:find).and_return(nil)
+                Puppet::Pops::Loader::ModuleLoaders::EmptyLoader.any_instance.expects(:find).at_least_once.returns(nil)
                 expect(Loaders.find_loader('a').discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(
                   contain_exactly(tn(:type, 'a::atype')))
               end
 
               it 'an EmptyLoader is used and module loader finds tasks' do
-                expect_any_instance_of(Puppet::Pops::Loader::ModuleLoaders::EmptyLoader).to receive(:find).and_return(nil)
+                Puppet::Pops::Loader::ModuleLoaders::EmptyLoader.any_instance.expects(:find).at_least_once.returns(nil)
                 expect(Loaders.find_loader('a').discover(:task) { |t| t.name =~ /^.::.*\z/ }).to(
                   contain_exactly(tn(:task, 'a::atask')))
               end
@@ -472,10 +470,8 @@ describe 'The Loader' do
             end
 
             it 'discover is only called once on dependent loader' do
-              times_called = 0
-              allow_any_instance_of(ModuleLoaders::FileBased).to receive(:discover).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY) { times_called += 1 }.and_return([])
+              ModuleLoaders::FileBased.any_instance.expects(:discover).times(4).with(:type, nil, Pcore::RUNTIME_NAME_AUTHORITY).returns([])
               expect(loader.private_loader.discover(:type) { |t| t.name =~ /^.::.*\z/ }).to(contain_exactly())
-              expect(times_called).to eq(4)
             end
           end
         end

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

@@ -167,9 +167,9 @@ describe 'loaders' do
     end
 
     it 'loader allows loading a function more than once' do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return('')
-      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns ''
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
 
       env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
@@ -228,9 +228,9 @@ describe 'loaders' do
     end
 
     it 'all dependent modules are visible' do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson)
-      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -257,11 +257,10 @@ describe 'loaders' do
         {:from => from, :called => 'a puppet function declared in init.pp', :expects => "I'm the function usee::usee_puppet_init()"},
         {:from => from, :called => 'a ruby function', :expects => "I'm the function usee::usee_ruby()"} ].each_with_index do |desc, called_idx|
         case_number = from_idx * 3 + called_idx + 1
-
         it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
-          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
-          allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-          allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
@@ -270,20 +269,18 @@ describe 'loaders' do
         end
 
         it "can call #{desc[:called]} from #{desc[:from]} when no metadata is present" do
-          times_has_metadata_called = 0
-          allow_any_instance_of(Puppet::Module).to receive('has_metadata?') { times_has_metadata_called += 1 }.and_return(false)
+          Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
           expect(resource).not_to be_nil
           expect(resource['message']).to eq(desc[:expects])
-          expect(times_has_metadata_called).to be >= 1
         end
 
         it "can not call #{desc[:called]} from #{desc[:from]} if dependency is missing in existing metadata.json" do
-          allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => []).to_pson)
-          allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-          allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => []).to_pson
+          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           catalog = compiler.compile
           resource = catalog.resource('Notify', "case_#{case_number}")
@@ -294,9 +291,9 @@ describe 'loaders' do
     end
 
     it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
-      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(Usee::Zero, 0)
         notice(ok)
@@ -304,7 +301,7 @@ describe 'loaders' do
     end
 
     it "a type can reference an autoloaded type alias from another module when no metadata is present" do
-      expect_any_instance_of(Puppet::Module).to receive('has_metadata?').at_least(:once).and_return(false)
+      Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(Usee::Zero, 0)
         notice(ok)
@@ -312,9 +309,9 @@ describe 'loaders' do
     end
 
     it "a type can reference a type alias from another module when other module has it declared in init.pp" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
-      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(Usee::One, 1)
@@ -323,9 +320,9 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
-      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         assert_type(User::WithUseeZero, [0])
         notice(ok)
@@ -333,9 +330,9 @@ describe 'loaders' do
     end
 
     it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
-      allow(File).to receive(:read).with(user_metadata_path, {:encoding => 'utf-8'}).and_return(user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson)
-      allow(File).to receive(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
-      allow(File).to receive(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).and_raise(Errno::ENOENT)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
         include 'usee'
         assert_type(User::WithUseeOne, [1])
@@ -379,7 +376,7 @@ describe 'loaders' do
         catalog = compiler.compile
         expect(catalog.resource('Notify[first]')).to be_a(Puppet::Resource)
 
-        expect(Puppet::Pops::Loader::RubyFunctionInstantiator).not_to receive(:create)
+        Puppet::Pops::Loader::RubyFunctionInstantiator.expects(:create).never
         compiler = Puppet::Parser::Compiler.new(node)
         compiler.topscope['value_from_scope'] = 'second'
         catalog = compiler.compile
@@ -424,33 +421,9 @@ describe 'loaders' do
       expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'passed in scope'")
     end
 
-    it 'calls can be made to a non core function via the call() function' do
-      call_function = loader.load_typed(typed_name(:function, 'call')).value
-      expect(call_function.call(scope, 'user::puppetcaller4')).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
-    end
-
-  end
-
-  context 'when a 3x load takes place' do
-    let(:env) { environment_for(mix_4x_and_3x_functions) }
-    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
-    let(:scope) { compiler.topscope }
-    let(:loader) { compiler.loaders.private_loader_for_module('user') }
-
-    before(:each) do
-      Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
-    end
-    after(:each) do
-      Puppet.pop_context
-    end
-
-    it "a function with no illegal constructs can be loaded" do
-      function = loader.load_typed(typed_name(:function, 'good_func_load')).value
-      expect(function.call(scope)).to eql(Float("3.14"))
-    end
   end
 
-  context 'when a 3x load has illegal method added' do
+  context 'when causing a 3x load followed by a 4x load' do
     let(:env) { environment_for(mix_4x_and_3x_functions) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
     let(:scope) { compiler.topscope }
@@ -463,53 +436,10 @@ describe 'loaders' do
       Puppet.pop_context
     end
 
-    it "outside function body is reported as an error" do
-      expect { loader.load_typed(typed_name(:function, 'bad_func_load')) }.to raise_error(/Illegal method definition/)
+    it "a 3x function with code outside body is reported as an error" do
+      expect { loader.load_typed(typed_name(:function, 'bad_func_load')) }.to raise_error(/Illegal legacy function definition/)
     end
-
-    it "to self outside function body is reported as an error" do
-      expect { loader.load_typed(typed_name(:function, 'bad_func_load5')) }.to raise_error(/Illegal method definition.*'bad_func_load5_illegal_method'/)
-    end
-
-    it "outside body is reported as an error even if returning the right func_info" do
-      expect { loader.load_typed(typed_name(:function, 'bad_func_load2'))}.to raise_error(/Illegal method definition/)
-    end
-
-    it "inside function body is reported as an error" do
-      expect {
-        f = loader.load_typed(typed_name(:function, 'bad_func_load3')).value
-        f.call(scope)
-      }.to raise_error(/Illegal method definition.*'bad_func_load3_illegal_method'/)
-    end
-
-    it "to self inside function body is reported as an error" do
-      expect { 
-        f = loader.load_typed(typed_name(:function, 'bad_func_load4')).value
-        f.call(scope)
-      }.to raise_error(/Illegal method definition.*'bad_func_load4_illegal_method'/)
-    end
-  end
-
-context 'when a 3x load has illegal construct and --func3x_check is false' do
-  let(:env) { environment_for(mix_4x_and_3x_functions) }
-  let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
-  let(:scope) { compiler.topscope }
-  let(:loader) { compiler.loaders.private_loader_for_module('user') }
-
-  before(:each) do
-    Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
-    Puppet[:func3x_check] = false
   end
-  after(:each) do
-    Puppet.pop_context
-    Puppet[:func3x_check] = true
-  end
-
-  it "an illegal function is loaded" do
-      f = loader.load_typed(typed_name(:function, 'bad_func_load3')).value
-      expect(f.call(scope)).to eql("some return value")
-  end
-end
 
   context 'when causing a 3x load followed by a 4x load' do
     let(:env) { environment_for(mix_4x_and_3x_functions) }
@@ -530,7 +460,7 @@ end
       Puppet::Parser::Functions::newfunction(:callee, :type => :rvalue, :arity => 1) do |args|
         function_callee_ws(['passed in scope'])
       end
-      expect(Puppet).not_to receive(:warning)
+      Puppet.expects(:warning).with(any_parameters).never
       scope['passed_in_scope'] = 'value'
       function = loader.load_typed(typed_name(:function, 'callee')).value
       expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")

data/spec/unit/pops/lookup/context_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/compiler'

data/spec/unit/pops/lookup/interpolation_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 
@@ -38,11 +39,11 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
   let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {}, nil) }
 
   before(:each) do
-    allow_any_instance_of(Lookup::Invocation).to receive(:lookup_adapter).and_return(adapter)
+    Lookup::Invocation.any_instance.stubs(:lookup_adapter).returns(adapter)
   end
 
   def expect_lookup(*keys)
-    keys.each { |key| expect(adapter).to receive(:track).with(key) }
+    keys.each { |key| adapter.expects(:track).with(key) }
   end
 
   context 'when interpolating nested data' do

data/spec/unit/pops/merge_strategy_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 

data/spec/unit/pops/migration_spec.rb

@@ -34,18 +34,20 @@ describe 'Puppet::Pops::MigrationMigrationChecker' do
   describe "when there is no MigrationChecker in the PuppetContext" do
     it "a null implementation of the MigrationChecker gets created (once per impl that needs one)" do
       migration_checker = Puppet::Pops::Migration::MigrationChecker.new()
-      expect(Puppet::Pops::Migration::MigrationChecker).to receive(:new).at_least(:once).and_return(migration_checker)
+      Puppet::Pops::Migration::MigrationChecker.expects(:new).at_least_once.returns(migration_checker)
       expect(Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "1", __FILE__)).to eq(1)
+      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
     end
   end
 
   describe "when there is a MigrationChecker in the Puppet Context" do
     it "does not create any MigrationChecker instances when parsing and evaluating" do
-      migration_checker = double()
-      expect(Puppet::Pops::Migration::MigrationChecker).not_to receive(:new)
+      migration_checker = mock()
+      Puppet::Pops::Migration::MigrationChecker.expects(:new).never
       Puppet.override({:migration_checker => migration_checker}, "test-context") do
         Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "true", __FILE__)
       end
+      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
     end
   end
 end

data/spec/unit/pops/model/model_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 

data/spec/unit/pops/model/pn_transformer_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/pops/pn'
@@ -41,10 +42,6 @@ describe 'Puppet::Pops::Model::PNTransformer' do
       expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(
         call('hash', call('=>', 'a', 1), call('=>', 'b', 2)))
     end
-
-    it 'replaces empty/nil body with a Nop' do
-      expect(Puppet::Pops::Model::PNTransformer.transform(nil)).to eq(call('nop'))
-    end
   end
 
   def lit(value)

data/spec/unit/pops/parser/locator_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'puppet/pops'
 
 describe Puppet::Pops::Parser::Locator do
+
   it "multi byte characters in a comment does not interfere with AST node text extraction" do
     parser = Puppet::Pops::Parser::Parser.new()
     model = parser.parse_string("# \u{0400}comment\nabcdef#XXXXXXXXXX").model
@@ -21,66 +22,23 @@ describe Puppet::Pops::Parser::Locator do
   end
 
   it 'Locator caches last offset / line' do
+    #Puppet::Pops::Parser::Locator::AbstractLocator.expects(:ary_bsearch_i).once
     parser = Puppet::Pops::Parser::Parser.new()
     model = parser.parse_string("$a\n = 1\n + 1\n").model
-    expect(model.body.locator).to receive(:ary_bsearch_i).with(anything, 2).once.and_return(:special_value)
+    model.body.locator.expects(:ary_bsearch_i).with(anything, 2).once.returns(:special_value)
     expect(model.body.locator.line_for_offset(2)).to eq(:special_value)
     expect(model.body.locator.line_for_offset(2)).to eq(:special_value)
   end
 
   it 'Locator invalidates last offset / line cache if asked for different offset' do
+    #Puppet::Pops::Parser::Locator::AbstractLocator.expects(:ary_bsearch_i).once
     parser = Puppet::Pops::Parser::Parser.new()
     model = parser.parse_string("$a\n = 1\n + 1\n").model
-    expect(model.body.locator).to receive(:ary_bsearch_i).with(anything, 2).twice.and_return(:first_value, :third_value)
-    expect(model.body.locator).to receive(:ary_bsearch_i).with(anything, 3).once.and_return(:second_value)
+    model.body.locator.expects(:ary_bsearch_i).with(anything, 2).twice.returns(:first_value, :third_value)
+    model.body.locator.expects(:ary_bsearch_i).with(anything, 3).once.returns(:second_value)
     expect(model.body.locator.line_for_offset(2)).to eq(:first_value)
     expect(model.body.locator.line_for_offset(3)).to eq(:second_value) # invalidates cache as side effect
     expect(model.body.locator.line_for_offset(2)).to eq(:third_value)
   end
 
-  it 'A heredoc without margin and interpolated expression location has offset and length relative the source' do
-    parser = Puppet::Pops::Parser::Parser.new()
-    src = <<-CODE
-    # line one
-    # line two
-    @("END"/L)
-        Line four\\
-        Line five ${1 +
-        1}
-    END
-    CODE
-
-    model = parser.parse_string(src).model
-    interpolated_expr = model.body.text_expr.segments[1].expr
-    expect(interpolated_expr.left_expr.offset).to eq(84)
-    expect(interpolated_expr.left_expr.length).to eq(1)
-    expect(interpolated_expr.right_expr.offset).to eq(96)
-    expect(interpolated_expr.right_expr.length).to eq(1)
-    expect(interpolated_expr.offset).to eq(86) # the + sign
-    expect(interpolated_expr.length).to eq(1) # the + sign
-    expect(interpolated_expr.locator.extract_tree_text(interpolated_expr)).to eq("1 +\n        1")
-  end
-
-  it 'A heredoc with margin and interpolated expression location has offset and length relative the source' do
-    parser = Puppet::Pops::Parser::Parser.new()
-    src = <<-CODE
-    # line one
-    # line two
-    @("END"/L)
-        Line four\\
-        Line five ${1 +
-        1}
-    |- END
-    CODE
-
-    model = parser.parse_string(src).model
-    interpolated_expr = model.body.text_expr.segments[1].expr
-    expect(interpolated_expr.left_expr.offset).to eq(84)
-    expect(interpolated_expr.left_expr.length).to eq(1)
-    expect(interpolated_expr.right_expr.offset).to eq(96)
-    expect(interpolated_expr.right_expr.length).to eq(1)
-    expect(interpolated_expr.offset).to eq(86) # the + sign
-    expect(interpolated_expr.length).to eq(1) # the + sign
-    expect(interpolated_expr.locator.extract_tree_text(interpolated_expr)).to eq("1 +\n        1")
-  end
 end

data/spec/unit/pops/parser/parse_application_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require_relative 'parser_rspec_helper'

data/spec/unit/pops/parser/parse_basic_expressions_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 

data/spec/unit/pops/parser/parse_calls_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'