puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/pops/issues_spec.rb

@@ -7,21 +7,21 @@ describe "Puppet::Pops::Issues" do
 
   it "should have an issue called NAME_WITH_HYPHEN" do
     x = Puppet::Pops::Issues::NAME_WITH_HYPHEN
-    x.class.should == Puppet::Pops::Issues::Issue
-    x.issue_code.should == :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
-    x.format(:name => 'Boo-Hoo',
+    expect(x.format(:name => 'Boo-Hoo',
       :label => Puppet::Pops::Model::ModelLabelProvider.new,
       :semantic => "dummy"
-      ).should == "A String may not have a name containing a hyphen. The name 'Boo-Hoo' is not legal"
+      )).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
-    x.format().should == "Classes, definitions, and nodes may only appear at toplevel or inside other classes"
+    expect(x.format()).to eq("Classes, definitions, and nodes may only appear at toplevel or inside other classes")
   end
 
 end
@@ -62,19 +62,19 @@ describe "Puppet::Pops::IssueReporter" do
     end
 
     it "emits warnings if told to emit them" do
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      Puppet.expects(:warning).twice.with(regexp_matches(/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
-      Puppet::Log.expects(:create).never
+      Puppet.expects(:warning).never
       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
-      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/deprecation1/)))
+      Puppet.expects(:warning).once.with(regexp_matches(/deprecation1/))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
@@ -82,20 +82,20 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( warning(2) )
       acceptor.accept( warning(3) )
       Puppet[:max_warnings] = 1
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      Puppet.expects(:warning).twice.with(regexp_matches(/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
-      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
+      Puppet.expects(:warning).once.with(regexp_matches(/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'
-      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
+      Puppet.expects(:warning).once.with(regexp_matches(/warning1/))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
   end
@@ -103,7 +103,7 @@ describe "Puppet::Pops::IssueReporter" do
   context "given errors" do
     it "logs nothing, but raises the given :message if :emit_errors is repressing error logging" do
       acceptor.accept( error(1) )
-      Puppet::Log.expects(:create).never
+      Puppet.expects(:err).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_errors => false, :message => 'special'})
       end.to raise_error(Puppet::ParseError, 'special')
@@ -111,7 +111,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "prefixes :message if a single error is raised" do
       acceptor.accept( error(1) )
-      Puppet::Log.expects(:create).never
+      Puppet.expects(:err).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /special error1/)
@@ -119,7 +119,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "logs nothing and raises immediately if there is only one error" do
       acceptor.accept( error(1) )
-      Puppet::Log.expects(:create).never
+      Puppet.expects(:err).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -129,7 +129,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:max_errors] = 0
-      Puppet::Log.expects(:create).never
+      Puppet.expects(:err).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -138,7 +138,7 @@ describe "Puppet::Pops::IssueReporter" do
     it "logs the :message if there is more than one allowed error" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
-      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2|special/)))
+      Puppet.expects(:err).times(3).with(regexp_matches(/error1|error2|special/))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -149,7 +149,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 2
-      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
+      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -160,7 +160,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 4
-      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
+      Puppet.expects(:err).times(3).with(regexp_matches(/error[123]/))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -170,7 +170,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:disable_warnings] = 'deprecations'
-      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
+      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -186,8 +186,8 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(3) )
       acceptor.accept( deprecation(1) )
       Puppet[:max_errors] = 2
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
-      Puppet::Log.expects(:create).twice.with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
+      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet.expects(:err).times(2).with(regexp_matches(/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/)

data/spec/unit/pops/label_provider_spec.rb

@@ -5,27 +5,27 @@ describe Puppet::Pops::LabelProvider do
   let(:labeler) { Puppet::Pops::LabelProvider.new }
 
   it "prefixes words that start with a vowel with an 'an'" do
-    labeler.a_an('owl').should == 'an owl'
+    expect(labeler.a_an('owl')).to eq('an owl')
   end
 
   it "prefixes words that start with a consonant with an 'a'" do
-    labeler.a_an('bear').should == 'a bear'
+    expect(labeler.a_an('bear')).to eq('a bear')
   end
 
   it "prefixes non-word characters with an 'a'" do
-    labeler.a_an('[] expression').should == 'a [] expression'
+    expect(labeler.a_an('[] expression')).to eq('a [] expression')
   end
 
   it "ignores a single quote leading the word" do
-    labeler.a_an("'owl'").should == "an 'owl'"
+    expect(labeler.a_an("'owl'")).to eq("an 'owl'")
   end
 
   it "ignores a double quote leading the word" do
-    labeler.a_an('"owl"').should == 'an "owl"'
+    expect(labeler.a_an('"owl"')).to eq('an "owl"')
   end
 
   it "capitalizes the indefinite article for a word when requested" do
-    labeler.a_an_uc('owl').should == 'An owl'
+    expect(labeler.a_an_uc('owl')).to eq('An owl')
   end
 
   it "raises an error when missing a character to work with" do

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

@@ -7,7 +7,7 @@ require 'puppet/loaders'
 describe 'loader helper classes' do
   it 'NamedEntry holds values and is frozen' do
     ne = Puppet::Pops::Loader::Loader::NamedEntry.new('name', 'value', 'origin')
-    expect(ne.frozen?).to be_true
+    expect(ne.frozen?).to be_truthy
     expect(ne.typed_name).to eql('name')
     expect(ne.origin).to eq('origin')
     expect(ne.value).to eq('value')
@@ -15,11 +15,11 @@ describe 'loader helper classes' do
 
   it 'TypedName holds values and is frozen' do
     tn = Puppet::Pops::Loader::Loader::TypedName.new(:function, '::foo::bar')
-    expect(tn.frozen?).to be_true
+    expect(tn.frozen?).to be_truthy
     expect(tn.type).to eq(:function)
     expect(tn.name_parts).to eq(['foo', 'bar'])
     expect(tn.name).to eq('foo::bar')
-    expect(tn.qualified).to be_true
+    expect(tn.qualified?).to be_truthy
   end
 end
 

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

@@ -5,7 +5,7 @@ require 'puppet/pops'
 describe Puppet::Pops::Model do
   it "should be possible to create an instance of a model object" do
     nop = Puppet::Pops::Model::Nop.new
-    nop.class.should == Puppet::Pops::Model::Nop
+    expect(nop.class).to eq(Puppet::Pops::Model::Nop)
   end
 end
 
@@ -15,23 +15,23 @@ describe Puppet::Pops::Model::Factory do
 
   it "construct an arithmetic expression" do
     x = Factory.literal(10) + Factory.literal(20)
-    x.is_a?(Factory).should == true
+    expect(x.is_a?(Factory)).to eq(true)
     current = x.current
-    current.is_a?(Model::ArithmeticExpression).should == true
-    current.operator.should == :'+'
-    current.left_expr.class.should == Model::LiteralInteger
-    current.right_expr.class.should == Model::LiteralInteger
-    current.left_expr.value.should == 10
-    current.right_expr.value.should == 20
+    expect(current.is_a?(Model::ArithmeticExpression)).to eq(true)
+    expect(current.operator).to eq(:'+')
+    expect(current.left_expr.class).to eq(Model::LiteralInteger)
+    expect(current.right_expr.class).to eq(Model::LiteralInteger)
+    expect(current.left_expr.value).to eq(10)
+    expect(current.right_expr.value).to eq(20)
   end
 
   it "should be easy to compare using a model tree dumper" do
     x = Factory.literal(10) + Factory.literal(20)
-    Puppet::Pops::Model::ModelTreeDumper.new.dump(x.current).should == "(+ 10 20)"
+    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.current)).to eq("(+ 10 20)")
   end
 
   it "builder should apply precedence" do
     x = Factory.literal(2) * Factory.literal(10) + Factory.literal(20)
-    Puppet::Pops::Model::ModelTreeDumper.new.dump(x.current).should == "(+ (* 2 10) 20)"
+    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.current)).to eq("(+ (* 2 10) 20)")
   end
 end

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

@@ -16,15 +16,15 @@ describe "epp parser" do
 
   it "should instantiate an epp parser" do
     parser = Puppet::Pops::Parser::EppParser.new()
-    parser.class.should == Puppet::Pops::Parser::EppParser
+    expect(parser.class).to eq(Puppet::Pops::Parser::EppParser)
   end
 
   it "should parse a code string and return a program with epp" do
     parser = Puppet::Pops::Parser::EppParser.new()
     model = parser.parse_string("Nothing to see here, move along...").current
-    model.class.should == Puppet::Pops::Model::Program
-    model.body.class.should == Puppet::Pops::Model::LambdaExpression
-    model.body.body.class.should == Puppet::Pops::Model::EppExpression
+    expect(model.class).to eq(Puppet::Pops::Model::Program)
+    expect(model.body.class).to eq(Puppet::Pops::Model::LambdaExpression)
+    expect(model.body.body.class).to eq(Puppet::Pops::Model::EppExpression)
   end
 
   context "when facing bad input it reports" do
@@ -51,65 +51,65 @@ describe "epp parser" do
 
   context "handles parsing of" do
     it "text (and nothing else)" do
-      dump(parse("Hello World")).should == [
+      expect(dump(parse("Hello World"))).to eq([
         "(lambda (epp (block",
         "  (render-s 'Hello World')",
-        ")))"].join("\n")
+        ")))"].join("\n"))
     end
 
     it "template parameters" do
-      dump(parse("<%|$x|%>Hello World")).should == [
+      expect(dump(parse("<%|$x|%>Hello World"))).to eq([
         "(lambda (parameters x) (epp (block",
         "  (render-s 'Hello World')",
-        ")))"].join("\n")
+        ")))"].join("\n"))
     end
 
     it "template parameters with default" do
-      dump(parse("<%|$x='cigar'|%>Hello World")).should == [
+      expect(dump(parse("<%|$x='cigar'|%>Hello World"))).to eq([
         "(lambda (parameters (= x 'cigar')) (epp (block",
         "  (render-s 'Hello World')",
-        ")))"].join("\n")
+        ")))"].join("\n"))
     end
 
     it "template parameters with and without default" do
-      dump(parse("<%|$x='cigar', $y|%>Hello World")).should == [
+      expect(dump(parse("<%|$x='cigar', $y|%>Hello World"))).to eq([
         "(lambda (parameters (= x 'cigar') y) (epp (block",
         "  (render-s 'Hello World')",
-        ")))"].join("\n")
+        ")))"].join("\n"))
     end
 
     it "template parameters + additional setup" do
-      dump(parse("<%|$x| $y = 10 %>Hello World")).should == [ 
+      expect(dump(parse("<%|$x| $y = 10 %>Hello World"))).to eq([ 
         "(lambda (parameters x) (epp (block",
         "  (= $y 10)",
         "  (render-s 'Hello World')",
-        ")))"].join("\n")
+        ")))"].join("\n"))
     end
 
     it "comments" do
-      dump(parse("<%#($x='cigar', $y)%>Hello World")).should == [
+      expect(dump(parse("<%#($x='cigar', $y)%>Hello World"))).to eq([
         "(lambda (epp (block",
         "  (render-s 'Hello World')",
         ")))"
-        ].join("\n")
+        ].join("\n"))
     end
 
     it "verbatim epp tags" do
-      dump(parse("<%% contemplating %%>Hello World")).should == [
+      expect(dump(parse("<%% contemplating %%>Hello World"))).to eq([
         "(lambda (epp (block",
         "  (render-s '<% contemplating %>Hello World')",
         ")))"
-        ].join("\n")
+        ].join("\n"))
     end
 
     it "expressions" do
-      dump(parse("We all live in <%= 3.14 - 2.14 %> world")).should == [
+      expect(dump(parse("We all live in <%= 3.14 - 2.14 %> world"))).to eq([
         "(lambda (epp (block",
         "  (render-s 'We all live in ')",
         "  (render (- 3.14 2.14))",
         "  (render-s ' world')",
         ")))"
-      ].join("\n")
+      ].join("\n"))
     end
   end
 end

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

@@ -25,12 +25,12 @@ describe 'The Evaluating Parser' do
   end
 
   def test(x)
-    evaluator.evaluate_string(scope, quote(x)).should == x
+    expect(evaluator.evaluate_string(scope, quote(x))).to eq(x)
   end
 
   def test_interpolate(x, y)
     scope['a'] = 'expansion'
-    evaluator.evaluate_string(scope, quote(x)).should == y
+    expect(evaluator.evaluate_string(scope, quote(x))).to eq(y)
   end
 
   context 'when evaluating' do

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

@@ -65,12 +65,12 @@ describe 'Lexer2' do
     :PIPE => '|',
   }.each do |name, string|
     it "should lex a token named #{name.to_s}" do
-      tokens_scanned_from(string).should match_tokens2(name)
+      expect(tokens_scanned_from(string)).to match_tokens2(name)
     end
   end
 
   it "should lex [ in position after non whitespace as LBRACK" do
-    tokens_scanned_from("a[").should match_tokens2(:NAME, :LBRACK)
+    expect(tokens_scanned_from("a[")).to match_tokens2(:NAME, :LBRACK)
   end
 
   {
@@ -91,48 +91,37 @@ describe 'Lexer2' do
     "true"     => :BOOLEAN,
     "in"       => :IN,
     "unless"   => :UNLESS,
-    "private"  => :PRIVATE,
-    "type"     => :TYPE,
-    "attr"     => :ATTR,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2(name)
-    end
-  end
-
-  {
-    "application"  => :APPLICATION_R,
-    "consumes"     => :CONSUMES_R,
-    "produces"     => :PRODUCES_R,
-  }.each do |string, name|
-    it "should lex a (future reserved) keyword from '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2(name)
+      expect(tokens_scanned_from(string)).to match_tokens2(name)
     end
   end
 
   # TODO: Complete with all edge cases
   [ 'A', 'A::B', '::A', '::A::B',].each do |string|
     it "should lex a CLASSREF on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:CLASSREF, string])
+      expect(tokens_scanned_from(string)).to match_tokens2([:CLASSREF, string])
     end
   end
 
   # TODO: Complete with all edge cases
   [ 'a', 'a::b', '::a', '::a::b',].each do |string|
     it "should lex a NAME on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:NAME, string])
+      expect(tokens_scanned_from(string)).to match_tokens2([:NAME, string])
     end
   end
 
   [ 'a-b', 'a--b', 'a-b-c', '_x'].each do |string|
     it "should lex a BARE WORD STRING on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:WORD, string])
+      expect(tokens_scanned_from(string)).to match_tokens2([:WORD, string])
     end
   end
 
   [ '_x::y', 'x::_y'].each do |string|
-    it "should consider the bare word '#{string}' to be a WORD" do
-      tokens_scanned_from(string).should match_tokens2(:WORD)
+    it "should consider the bare word '#{string}' to be a bad NAME" do
+      expect {
+        tokens_scanned_from(string)
+      }.to raise_error(/Illegal fully qualified name/)
     end
   end
 
@@ -144,43 +133,43 @@ describe 'Lexer2' do
     'a-$3' =>      [:NAME, :MINUS, :VARIABLE],
   }.each do |source, expected|
     it "should lex leading and trailing hyphens from #{source}" do
-      tokens_scanned_from(source).should match_tokens2(*expected)
+      expect(tokens_scanned_from(source)).to match_tokens2(*expected)
     end
   end
 
   { 'false'=>false, 'true'=>true}.each do |string, value|
     it "should lex a BOOLEAN on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:BOOLEAN, value])
+      expect(tokens_scanned_from(string)).to match_tokens2([:BOOLEAN, value])
     end
   end
 
   [ '0', '1', '2982383139'].each do |string|
     it "should lex a decimal integer NUMBER on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+      expect(tokens_scanned_from(string)).to match_tokens2([:NUMBER, string])
     end
   end
 
   { ' 1' => '1', '1 ' => '1', ' 1 ' => '1'}.each do |string, value|
     it "should lex a NUMBER with surrounding space '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:NUMBER, value])
+      expect(tokens_scanned_from(string)).to match_tokens2([:NUMBER, value])
     end
   end
 
   [ '0.0', '0.1', '0.2982383139', '29823.235', '10e23', '10e-23', '1.234e23'].each do |string|
     it "should lex a decimal floating point NUMBER on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+      expect(tokens_scanned_from(string)).to match_tokens2([:NUMBER, string])
     end
   end
 
   [ '00', '01', '0123', '0777'].each do |string|
     it "should lex an octal integer NUMBER on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+      expect(tokens_scanned_from(string)).to match_tokens2([:NUMBER, string])
     end
   end
 
   [ '0x0', '0x1', '0xa', '0xA', '0xabcdef', '0xABCDEF'].each do |string|
     it "should lex an hex integer NUMBER on the form '#{string}'" do
-      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+      expect(tokens_scanned_from(string)).to match_tokens2([:NUMBER, string])
     end
   end
 
@@ -197,7 +186,7 @@ describe 'Lexer2' do
     "'a\\\\'" =>"a\\",
   }.each do |source, expected|
     it "should lex a single quoted STRING on the form #{source}" do
-      tokens_scanned_from(source).should match_tokens2([:STRING, expected])
+      expect(tokens_scanned_from(source)).to match_tokens2([:STRING, expected])
     end
   end
 
@@ -207,7 +196,7 @@ describe 'Lexer2' do
     }.each do |source, expected|
       it "should lex a single quoted STRING on the form #{source} as having length #{expected[0]}" do
        length, value = expected
-       tokens_scanned_from(source).should match_tokens2([:STRING, value, {:line => 1, :pos=>1, :length=> length}])
+       expect(tokens_scanned_from(source)).to match_tokens2([:STRING, value, {:line => 1, :pos=>1, :length=> length}])
       end
     end
 
@@ -216,53 +205,28 @@ describe 'Lexer2' do
     '"a\'b"'  => "a'b",
   }.each do |source, expected|
     it "should lex a double quoted STRING on the form #{source}" do
-      tokens_scanned_from(source).should match_tokens2([:STRING, expected])
+      expect(tokens_scanned_from(source)).to match_tokens2([:STRING, expected])
     end
   end
 
-  { '"a$x b"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                      [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
-
-    '"a$x.b"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                      [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
+  { '"a$x b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                   [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
 
-    '"$x.b"'      => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
-                      [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
-                      [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
+    '"a$x.b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                   [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
 
-    '"a$x"'       => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
-                      [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
-                      [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
+    '"$x.b"'   => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
+                   [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
 
-    '"a${x}"'     => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
-                      [:VARIABLE, 'x',   {:line => 1, :pos=>5, :length=>1 }],
-                      [:DQPOST,   '',    {:line => 1, :pos=>7, :length=>1 }]],
-
-    '"a${_x}"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
-                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
-                      [:DQPOST,   '',    {:line => 1, :pos=>8, :length=>1 }]],
-
-    '"a${y::_x}"' => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
-                      [:VARIABLE, 'y::_x',  {:line => 1, :pos=>5, :length=>5 }],
-                      [:DQPOST,   '',    {:line => 1, :pos=>11, :length=>1 }]],
-
-    '"a${_x[1]}"' => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
-                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
-                      [:LBRACK,   '[',   {:line => 1, :pos=>7, :length=>1 }],
-                      [:NUMBER,   '1',   {:line => 1, :pos=>8, :length=>1 }],
-                      [:RBRACK,   ']',   {:line => 1, :pos=>9, :length=>1 }],
-                      [:DQPOST,   '',    {:line => 1, :pos=>11, :length=>1 }]],
-
-    '"a${_x.foo}"'=> [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
-                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
-                      [:DOT,      '.',   {:line => 1, :pos=>7, :length=>1 }],
-                      [:NAME,     'foo', {:line => 1, :pos=>8, :length=>3 }],
-                      [:DQPOST,   '',    {:line => 1, :pos=>12, :length=>1 }]],
+    '"a$x"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                   [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
   }.each do |source, expected|
     it "should lex an interpolated variable 'x' from #{source}" do
-      tokens_scanned_from(source).should match_tokens2(*expected)
+      expect(tokens_scanned_from(source)).to match_tokens2(*expected)
     end
   end
 
@@ -273,25 +237,25 @@ describe 'Lexer2' do
     '"a$$%"'  => "a$$%",
   }.each do |source, expected|
     it "should lex interpolation including false starts #{source}" do
-      tokens_scanned_from(source).should match_tokens2([:STRING, expected])
+      expect(tokens_scanned_from(source)).to match_tokens2([:STRING, expected])
     end
   end
 
   it "differentiates between foo[x] and foo [x] (whitespace)" do
-    tokens_scanned_from("$a[1]").should match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
-    tokens_scanned_from("$a [1]").should match_tokens2(:VARIABLE, :LISTSTART, :NUMBER, :RBRACK)
-    tokens_scanned_from("a[1]").should match_tokens2(:NAME, :LBRACK, :NUMBER, :RBRACK)
-    tokens_scanned_from("a [1]").should match_tokens2(:NAME, :LISTSTART, :NUMBER, :RBRACK)
-    tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
+    expect(tokens_scanned_from("$a[1]")).to match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
+    expect(tokens_scanned_from("$a [1]")).to match_tokens2(:VARIABLE, :LISTSTART, :NUMBER, :RBRACK)
+    expect(tokens_scanned_from("a[1]")).to match_tokens2(:NAME, :LBRACK, :NUMBER, :RBRACK)
+    expect(tokens_scanned_from("a [1]")).to match_tokens2(:NAME, :LISTSTART, :NUMBER, :RBRACK)
+    expect(tokens_scanned_from(" if \n\r\t\nif if ")).to match_tokens2(:IF, :IF, :IF)
   end
 
   it "skips whitepsace" do
-    tokens_scanned_from(" if if if ").should match_tokens2(:IF, :IF, :IF)
-    tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
+    expect(tokens_scanned_from(" if if if ")).to match_tokens2(:IF, :IF, :IF)
+    expect(tokens_scanned_from(" if \n\r\t\nif if ")).to match_tokens2(:IF, :IF, :IF)
   end
 
   it "skips single line comments" do
-    tokens_scanned_from("if # comment\nif").should match_tokens2(:IF, :IF)
+    expect(tokens_scanned_from("if # comment\nif")).to match_tokens2(:IF, :IF)
   end
 
   ["if /* comment */\nif",
@@ -299,7 +263,7 @@ describe 'Lexer2' do
     "if /*\n comment\n */\nif",
     ].each do |source|
     it "skips multi line comments" do
-      tokens_scanned_from(source).should match_tokens2(:IF, :IF)
+      expect(tokens_scanned_from(source)).to match_tokens2(:IF, :IF)
     end
   end
 
@@ -318,12 +282,12 @@ describe 'Lexer2' do
   }.each do |token, entry|
     it "should lex regexp after '#{token}'" do
       expected = [entry[0], :REGEX].flatten
-      tokens_scanned_from(entry[1]).should match_tokens2(*expected)
+      expect(tokens_scanned_from(entry[1])).to match_tokens2(*expected)
     end
   end
 
   it "should lex a simple expression" do
-    tokens_scanned_from('1 + 1').should match_tokens2([:NUMBER, '1'], :PLUS, [:NUMBER, '1'])
+    expect(tokens_scanned_from('1 + 1')).to match_tokens2([:NUMBER, '1'], :PLUS, [:NUMBER, '1'])
   end
 
   { "1"     => ["1 /./",       [:NUMBER, :DIV, :DOT, :DIV]],
@@ -342,12 +306,12 @@ describe 'Lexer2' do
     '"a$a"'  => ['"a$a" /./',  [:DQPRE, :VARIABLE, :DQPOST, :DIV, :DOT, :DIV]],
   }.each do |token, entry|
     it "should not lex regexp after '#{token}'" do
-      tokens_scanned_from(entry[ 0 ]).should match_tokens2(*entry[ 1 ])
+      expect(tokens_scanned_from(entry[ 0 ])).to match_tokens2(*entry[ 1 ])
     end
   end
 
   it 'should lex assignment' do
-    tokens_scanned_from("$a = 10").should match_tokens2([:VARIABLE, "a"], :EQUALS, [:NUMBER, '10'])
+    expect(tokens_scanned_from("$a = 10")).to match_tokens2([:VARIABLE, "a"], :EQUALS, [:NUMBER, '10'])
   end
 
 # TODO: Tricky, and heredoc not supported yet
@@ -356,11 +320,11 @@ describe 'Lexer2' do
 #  end
 
   it "should lex regexp at beginning of input" do
-    tokens_scanned_from(" /./").should match_tokens2(:REGEX)
+    expect(tokens_scanned_from(" /./")).to match_tokens2(:REGEX)
   end
 
   it "should lex regexp right of div" do
-    tokens_scanned_from("1 / /./").should match_tokens2(:NUMBER, :DIV, :REGEX)
+    expect(tokens_scanned_from("1 / /./")).to match_tokens2(:NUMBER, :DIV, :REGEX)
   end
 
   context 'when lexer lexes heredoc' do
@@ -370,7 +334,7 @@ describe 'Lexer2' do
       Tex\\tt\\n
       |- END
       CODE
-      tokens_scanned_from(code).should match_tokens2([:HEREDOC, 'syntax'], :SUBLOCATE, [:STRING, "Tex\tt\\n"])
+      expect(tokens_scanned_from(code)).to match_tokens2([:HEREDOC, 'syntax'], :SUBLOCATE, [:STRING, "Tex\tt\\n"])
     end
 
     it 'lexes "tag", syntax and escapes, margin, right trim and interpolation' do
@@ -379,7 +343,7 @@ describe 'Lexer2' do
       Tex\\tt\\n$var After
       |- END
       CODE
-      tokens_scanned_from(code).should match_tokens2(
+      expect(tokens_scanned_from(code)).to match_tokens2(
         [:HEREDOC, 'syntax'],
         :SUBLOCATE,
         [:DQPRE, "Tex\tt\\n"],
@@ -387,63 +351,6 @@ describe 'Lexer2' do
         [:DQPOST, " After"]
         )
     end
-
-    context 'with bad syntax' do
-      def expect_issue(code, issue)
-        expect { tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
-          expect(e.issue_code).to be(issue.issue_code)
-        }
-      end
-
-      it 'detects and reports HEREDOC_UNCLOSED_PARENTHESIS' do
-        code = <<-CODE
-        @(END:syntax/t
-        Text
-        |- END
-        CODE
-        expect_issue(code, Puppet::Pops::Issues::HEREDOC_UNCLOSED_PARENTHESIS)
-      end
-
-      it 'detects and reports HEREDOC_WITHOUT_END_TAGGED_LINE' do
-        code = <<-CODE
-        @(END:syntax/t)
-        Text
-        CODE
-        expect_issue(code, Puppet::Pops::Issues::HEREDOC_WITHOUT_END_TAGGED_LINE)
-      end
-
-      it 'detects and reports HEREDOC_INVALID_ESCAPE' do
-        code = <<-CODE
-        @(END:syntax/x)
-        Text
-        |- END
-        CODE
-        expect_issue(code, Puppet::Pops::Issues::HEREDOC_INVALID_ESCAPE)
-      end
-
-      it 'detects and reports HEREDOC_INVALID_SYNTAX' do
-        code = <<-CODE
-        @(END:syntax/t/p)
-        Text
-        |- END
-        CODE
-        expect_issue(code, Puppet::Pops::Issues::HEREDOC_INVALID_SYNTAX)
-      end
-
-      it 'detects and reports HEREDOC_WITHOUT_TEXT' do
-        code = '@(END:syntax/t)'
-        expect_issue(code, Puppet::Pops::Issues::HEREDOC_WITHOUT_TEXT)
-      end
-
-      it 'detects and reports HEREDOC_MULTIPLE_AT_ESCAPES' do
-        code = <<-CODE
-        @(END:syntax/tst)
-        Tex\\tt\\n
-        |- END
-        CODE
-        expect_issue(code, Puppet::Pops::Issues::HEREDOC_MULTIPLE_AT_ESCAPES)
-      end
-    end
   end
 
   context 'when dealing with multi byte characters' do
@@ -451,25 +358,8 @@ describe 'Lexer2' do
       code = <<-CODE
       "x\\u2713y"
       CODE
-      if Puppet::Pops::Parser::Locator::RUBYVER < Puppet::Pops::Parser::Locator::RUBY_1_9_3
-        # Ruby 1.8.7 reports the multibyte char as several octal characters
-        tokens_scanned_from(code).should match_tokens2([:STRING, "x\342\234\223y"])
-      else
-        # >= Ruby 1.9.3 reports \u
-        tokens_scanned_from(code).should match_tokens2([:STRING, "x\u2713y"])
-      end
-    end
-    it 'should support unicode characters in long form' do
-      code = <<-CODE
-      "x\\u{1f452}y"
-      CODE
-      if Puppet::Pops::Parser::Locator::RUBYVER < Puppet::Pops::Parser::Locator::RUBY_1_9_3
-        # Ruby 1.8.7 reports the multibyte char as several octal characters
-        tokens_scanned_from(code).should match_tokens2([:STRING, "x\360\237\221\222y"])
-      else
-        # >= Ruby 1.9.3 reports \u
-        tokens_scanned_from(code).should match_tokens2([:STRING, "x\u{1f452}y"])
-      end
+      # >= Ruby 1.9.3 reports \u
+       expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713y"])
     end
 
     it 'should not select LISTSTART token when preceded by multibyte chars' do
@@ -478,10 +368,10 @@ describe 'Lexer2' do
       # instead of the char offset.
       #
       code = "$a = '\u00f6\u00fc\u00fc\u00fc\u00fc\u00e4\u00e4\u00f6\u00e4'\nnotify {'x': message => B['dkda'] }\n"
-      tokens_scanned_from(code).should match_tokens2(
+      expect(tokens_scanned_from(code)).to match_tokens2(
         :VARIABLE, :EQUALS, :STRING,
         [:NAME, 'notify'], :LBRACE,
-        [:STRING, 'x'], :COLON, 
+        [:STRING, 'x'], :COLON,
         :NAME, :FARROW, :CLASSREF, :LBRACK, :STRING, :RBRACK,
         :RBRACE)
     end
@@ -492,14 +382,14 @@ describe 'Lexer2' do
       code = <<-CODE
       This is just text
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2(:EPP_START, [:RENDER_STRING, "      This is just text\n"])
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(:EPP_START, [:RENDER_STRING, "      This is just text\n"])
     end
 
     it 'epp can contain text with interpolated rendered expressions' do
       code = <<-CODE
       This is <%= $x %> just text
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2(
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
       :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:RENDER_EXPR, nil],
@@ -513,7 +403,7 @@ describe 'Lexer2' do
       code = <<-CODE
       This is <%= $x -%> just text
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2(
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
       :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:RENDER_EXPR, nil],
@@ -527,7 +417,7 @@ describe 'Lexer2' do
       code = <<-CODE
       This is <% $x=10 %> just text
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2(
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
       :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
@@ -542,13 +432,13 @@ describe 'Lexer2' do
       This is <% $x=10 -%>
       just text
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2(
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
       :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "      just text\n"]
+      [:RENDER_STRING, "just text\n"]
       )
     end
 
@@ -558,45 +448,13 @@ describe 'Lexer2' do
       <%# This is an epp comment -%>
       just text
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2(
-      :EPP_START,
-      [:RENDER_STRING, "      This is "],
-      [:VARIABLE, "x"],
-      :EQUALS,
-      [:NUMBER, "10"],
-      [:RENDER_STRING, "      just text\n"]
-      )
-    end
-
-    it 'epp comments strips left whitespace when preceding is right trim' do
-      code = <<-CODE
-      This is <% $x=10 -%>
-      space-before-me-but-not-after   <%# This is an epp comment %>
-      just text
-      CODE
-      expect(epp_tokens_scanned_from(code)).to match_tokens2(
-      :EPP_START,
-      [:RENDER_STRING, "      This is "],
-      [:VARIABLE, "x"],
-      :EQUALS,
-      [:NUMBER, "10"],
-      [:RENDER_STRING, "      space-before-me-but-not-after\n      just text\n"]
-      )
-    end
-
-    it 'epp comments strips left whitespace on same line when preceding is not right trim' do
-      code = <<-CODE
-      This is <% $x=10 %>
-      <%# This is an epp comment -%>
-      just text
-      CODE
       expect(epp_tokens_scanned_from(code)).to match_tokens2(
       :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "\n      just text\n"]
+      [:RENDER_STRING, "just text\n"]
       )
     end
 
@@ -605,84 +463,15 @@ describe 'Lexer2' do
       This is <% $x=10 -%>
       <%% this is escaped epp %%>
       CODE
-      epp_tokens_scanned_from(code).should match_tokens2(
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
       :EPP_START,
       [:RENDER_STRING, "      This is "],
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "      <% this is escaped epp %>\n"]
+      [:RENDER_STRING, "<% this is escaped epp %>\n"]
       )
     end
-
-    context 'with bad epp syntax' do
-      def expect_issue(code, issue)
-        expect { epp_tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
-          expect(e.issue_code).to be(issue.issue_code)
-        }
-      end
-
-      it 'detects and reports EPP_UNBALANCED_TAG' do
-        expect_issue('<% asf', Puppet::Pops::Issues::EPP_UNBALANCED_TAG)
-      end
-
-      it 'detects and reports EPP_UNBALANCED_COMMENT' do
-        expect_issue('<%# asf', Puppet::Pops::Issues::EPP_UNBALANCED_COMMENT)
-      end
-
-      it 'detects and reports EPP_UNBALANCED_EXPRESSION' do
-        expect_issue('asf <%', Puppet::Pops::Issues::EPP_UNBALANCED_EXPRESSION)
-      end
-    end
-  end
-
-  context 'when parsing bad code' do
-    def expect_issue(code, issue)
-      expect { tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) do |e|
-        expect(e.issue_code).to be(issue.issue_code)
-      end
-    end
-
-    it 'detects and reports issue ILLEGAL_CLASS_REFERENCE' do
-      expect_issue('A::3', Puppet::Pops::Issues::ILLEGAL_CLASS_REFERENCE)
-    end
-
-    it 'detects and reports issue ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE' do
-      expect_issue('::A::3', Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE)
-    end
-
-    it 'detects and reports issue ILLEGAL_FULLY_QUALIFIED_NAME' do
-      expect_issue('::a::3', Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_NAME)
-    end
-
-    it 'detects and reports issue ILLEGAL_NAME_OR_BARE_WORD' do
-      expect_issue('a::3', Puppet::Pops::Issues::ILLEGAL_NAME_OR_BARE_WORD)
-    end
-
-    it 'detects and reports issue ILLEGAL_NUMBER' do
-     expect_issue('3g', Puppet::Pops::Issues::ILLEGAL_NUMBER)
-    end
-
-    it 'detects and reports issue INVALID_HEX_NUMBER' do
-      expect_issue('0x3g', Puppet::Pops::Issues::INVALID_HEX_NUMBER)
-    end
-
-    it 'detects and reports issue INVALID_OCTAL_NUMBER' do
-      expect_issue('038', Puppet::Pops::Issues::INVALID_OCTAL_NUMBER)
-    end
-
-    it 'detects and reports issue INVALID_DECIMAL_NUMBER' do
-      expect_issue('4.3g', Puppet::Pops::Issues::INVALID_DECIMAL_NUMBER)
-    end
-
-    it 'detects and reports issue NO_INPUT_TO_LEXER' do
-      expect { Puppet::Pops::Parser::Lexer2.new.fullscan }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
-        expect(e.issue_code).to be(Puppet::Pops::Issues::NO_INPUT_TO_LEXER.issue_code)
-      }
-    end
-
-    it 'detects and reports issue UNCLOSED_QUOTE' do
-      expect_issue('"asd', Puppet::Pops::Issues::UNCLOSED_QUOTE)
-    end
   end
 end
+