puppet-debugger 0.17.0 → 1.2.0

data/spec/puppet_debugger_spec.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-require "stringio"
-describe "PuppetDebugger" do
+require 'spec_helper'
+require 'stringio'
+describe 'PuppetDebugger' do
   let(:resource) do
     "service{'httpd': ensure => running}"
   end
 
   before(:each) do
-    debugger.handle_input("reset")
+    debugger.handle_input('reset')
   end
 
   let(:output) do
@@ -31,56 +31,54 @@ describe "PuppetDebugger" do
     debugger.parser.evaluate_string(debugger.scope, input)
   end
 
-  describe "native classes" do
-    describe "create" do
+  describe 'native classes' do
+    describe 'create' do
       let(:input) do
-        "class testfoo {}"
+        'class testfoo {}'
       end
       let(:debugger_output) do
-        "\n => Puppet::Type::Component {\n  loglevel\e[0;37m => \e[0m\e[0;36mnotice\e[0m,\n      name\e[0;37m => \e[0m\e[0;33m\"Testfoo\"\e[0m,\n     title\e[0;37m => \e[0m\e[0;33m\"Class[Testfoo]\"\e[0m\n}\n"
+        " => Puppet::Type::Component {\n  loglevel\e[0;37m => \e[0m\e[0;36mnotice\e[0m,\n      name\e[0;37m => \e[0m\e[0;33m\"Testfoo\"\e[0m,\n     title\e[0;37m => \e[0m\e[0;33m\"Class[Testfoo]\"\e[0m\n}\n"
       end
       it do
         debugger.handle_input(input)
-        expect(output.string).to eq("\n")
-        expect(debugger.known_resource_types[:hostclasses]).to include("testfoo")
+        expect(output.string).to eq('')
+        expect(debugger.known_resource_types[:hostclasses]).to include('testfoo')
       end
       it do
         debugger.handle_input(input)
-        debugger.handle_input("include testfoo")
-        expect(debugger.scope.compiler.catalog.classes).to include("testfoo")
+        debugger.handle_input('include testfoo')
+        expect(debugger.scope.compiler.catalog.classes).to include('testfoo')
       end
       it do
         debugger.handle_input(input)
-        debugger.handle_input("include testfoo")
-        expect(debugger.scope.compiler.catalog.resources.map(&:name)).to include("Testfoo")
+        debugger.handle_input('include testfoo')
+        expect(debugger.scope.compiler.catalog.resources.map(&:name)).to include('Testfoo')
       end
     end
   end
 
-  describe "native definitions" do
-    describe "create" do
+  describe 'native definitions' do
+    describe 'create' do
       let(:input) do
-        "define testfoodefine {}"
+        'define testfoodefine {}'
       end
       let(:debugger_output) do
-        "\n => Puppet::Type::Component {\n  loglevel\e[0;37m => \e[0m\e[0;36mnotice\e[0m,\n      name\e[0;37m => \e[0m\e[0;33m\"some_name\"\e[0m,\n     title\e[0;37m => \e[0m\e[0;33m\"Testfoo[some_name]\"\e[0m\n}\n"
+        " => Puppet::Type::Component {\n  loglevel\e[0;37m => \e[0m\e[0;36mnotice\e[0m,\n      name\e[0;37m => \e[0m\e[0;33m\"some_name\"\e[0m,\n     title\e[0;37m => \e[0m\e[0;33m\"Testfoo[some_name]\"\e[0m\n}\n"
       end
       it do
         debugger.handle_input(input)
-        expect(debugger.scope.environment.known_resource_types.definitions.keys).to include("testfoodefine")
-        expect(output.string).to eq("\n")
+        expect(debugger.scope.environment.known_resource_types.definitions.keys).to include('testfoodefine')
+        expect(output.string).to eq('')
       end
       it do
         debugger.handle_input(input)
         debugger.handle_input("testfoodefine{'some_name':}")
-        expect(debugger.scope.compiler.resources.collect(&:name)).to include("some_name")
-        expect(debugger.scope.compiler.resources.collect(&:type)).to include("Testfoodefine")
-        expect(output.string).to include("\n => Puppet::Type::Component")
+        expect(output.string).to include(' => Puppet::Type::Component')
       end
     end
   end
 
-  describe "key_words" do
+  describe 'key_words' do
     it do
       expect(debugger.key_words.count).to be >= 30 if supports_datatypes?
     end
@@ -90,9 +88,9 @@ describe "PuppetDebugger" do
     end
   end
 
-  describe "native functions", native_functions: true do
+  describe 'native functions', native_functions: true do
     let(:func) do
-      <<-EOF
+      <<-OUT
       function debugger::bool2http($arg) {
         case $arg {
           false, undef, /(?i:false)/ : { 'Off' }
@@ -100,165 +98,164 @@ describe "PuppetDebugger" do
           default               : { "$arg" }
         }
       }
-      EOF
+      OUT
     end
     before(:each) do
       debugger.handle_input(func)
     end
-    describe "create" do
-      it "shows function" do
-        expect(output.string).to eq("\n")
+    describe 'create' do
+      it 'shows function' do
+        expect(output.string).to eq('')
       end
     end
-    describe "run" do
+    describe 'run' do
       let(:input) do
-        <<-EOF
+        <<-OUT
         debugger::bool2http(false)
-        EOF
+        OUT
       end
       it do
         debugger.handle_input(input)
-        expect(output.string).to include("Off")
+        expect(output.string).to include('Off')
       end
     end
   end
 
-  describe "returns a array of resource_types" do
-    it "returns resource type" do
-      expect(resource_types.first.class.to_s).to eq("Puppet::Pops::Types::PResourceType")
+  describe 'returns a array of resource_types' do
+    it 'returns resource type' do
+      expect(resource_types.first.class.to_s).to eq('Puppet::Pops::Types::PResourceType')
     end
   end
 
-  describe "empty" do
+  describe 'empty' do
     let(:input) do
-      ""
+      ''
     end
-    it "can run" do
-      debugger_output = "\n"
+    it 'can run' do
+      debugger_output = ''
+      debugger.handle_input(input)
       debugger.handle_input(input)
       expect(output.string).to eq(debugger_output)
     end
-    describe "space" do
+    describe 'space' do
       let(:input) do
-        " "
+        ' '
       end
-      it "can run" do
-        debugger_output = "\n"
+      it 'can run' do
+        debugger_output = ''
         debugger.handle_input(input)
         expect(output.string).to eq(debugger_output)
       end
     end
   end
 
-  describe "variables" do
+  describe 'variables' do
     let(:input) do
       "$file_path = '/tmp/test2.txt'"
     end
-    it "can process a variable" do
+    it 'can process a variable' do
       debugger.handle_input(input)
-      expect(output.string).to match(/\/tmp\/test2.txt/)
+      expect(output.string).to match(%r{/tmp/test2.txt})
     end
   end
 
-  describe "resource" do
+  describe 'resource' do
     let(:input) do
       "file{'/tmp/test2.txt': ensure => present, mode => '0755'}"
     end
-    it "can process a resource" do
+    it 'can process a resource' do
       debugger_output = /Puppet::Type::File/
       debugger.handle_input(input)
       expect(output.string).to match(debugger_output)
     end
   end
 
-  describe "bad input" do
+  describe 'bad input' do
     let(:input) do
-      "Service{"
+      'Service{'
     end
-    it "can process" do
+    it 'can process' do
       debugger.handle_input(input)
-      expect(output.string).to match(%r(Syntax error at end of))
+      expect(output.string).to match(/Syntax error at end of/)
     end
   end
 
-  describe "map block" do
+  describe 'map block' do
     let(:input) do
       "['/tmp/test3', '/tmp/test4'].map |String $path| { file{$path: ensure => present} }"
     end
-    it "can process a each block" do
+    it 'can process a each block' do
       debugger_output = /Puppet::Type::File/
       debugger.handle_input(input)
       expect(output.string).to match(debugger_output)
     end
   end
 
-  describe "each block" do
+  describe 'each block' do
     let(:input) do
       "['/tmp/test3', '/tmp/test4'].each |String $path| { file{$path: ensure => present} }"
     end
-    it "can process a each block" do
+    it 'can process a each block' do
       debugger.handle_input(input)
-      expect(output.string).to match(/\/tmp\/test3/)
-      expect(output.string).to match(/\/tmp\/test4/)
+      expect(output.string).to match(%r{/tmp/test3})
+      expect(output.string).to match(%r{/tmp/test4})
     end
   end
 
-  describe "string" do
+  describe 'string' do
     let(:input) do
-      "String"
+      'String'
     end
-    it "shows type" do
+    it 'shows type' do
       debugger.handle_input(input)
-      expect(output.string).to eq("\n => String\n")
+      expect(output.string).to eq(" => String\n")
     end
   end
-  describe "Array", type_function: true do
+  describe 'Array', type_function: true do
     let(:input) do
-      "type([1,2,3,4])"
+      'type([1,2,3,4])'
     end
-    it "shows type" do
-      if Gem::Version.new(Puppet.version) > Gem::Version.new("4.4")
-        out = "\n => Tuple[Integer[1, 1], Integer[2, 2], Integer[3, 3], Integer[4, 4]]\n"
-        debugger.handle_input(input)
-        expect(output.string).to eq(out)
-      end
+    it 'shows type' do
+      debugger.handle_input(input)
+      out = " => Tuple[Integer[1, 1], Integer[2, 2], Integer[3, 3], Integer[4, 4]]\n"
+      expect(output.string).to eq(out)
     end
   end
 
-  describe "multi diemension array" do
+  describe 'multi diemension array' do
     let(:input) do
-      "[[1, [23,4], [22], [1,[2232]]]]"
+      '[[1, [23,4], [22], [1,[2232]]]]'
     end
 
-    it "handles multi array" do
+    it 'handles multi array' do
       debugger.handle_input(input)
-      expect(output.string.count("[")).to be >= 17
+      expect(output.string.count('[')).to be >= 17
     end
   end
 
-  describe "command_completion" do
-    it "should complete on tabs" do
+  describe 'command_completion' do
+    it 'should complete on tabs' do
       allow(Readline).to receive(:line_buffer).and_return("\n")
-      expect(debugger.command_completion.call("").count).to be >= 200
+      expect(debugger.command_completion.call('').count).to be >= 200
     end
 
-    it "#key_words" do
+    it '#key_words' do
       expect(debugger.key_words.count).to be >= 100
     end
   end
 
-  describe "error message" do
+  describe 'error message' do
     let(:input) do
       "file{'/tmp/test': ensure => present, contact => 'blah'}"
     end
-    if Gem::Version.new(Puppet.version) >= Gem::Version.new("4.0")
-      it "show error message" do
+    if Gem::Version.new(Puppet.version) >= Gem::Version.new('4.0')
+      it 'show error message' do
         debugger_output = /no\ parameter\ named\ 'contact'/
         debugger.handle_input(input)
         expect(output.string).to match(debugger_output)
       end
     else
-      it "show error message" do
+      it 'show error message' do
         debugger_output = /Invalid\ parameter\ contact/
         debugger.handle_input(input)
         expect(output.string).to match(debugger_output)

data/spec/remote_node_spec.rb

@@ -41,7 +41,7 @@ describe 'PuppetDebugger' do
 
     describe 'set' do
       it 'sends message about resetting' do
-        expect(output.string).to eq("\nResetting to use node puppetdev.localdomain\n")
+        expect(output.string).to eq(" => Resetting to use node puppetdev.localdomain\n")
       end
 
       it 'return node name' do
@@ -74,10 +74,6 @@ describe 'PuppetDebugger' do
       let(:node_name) do
         'invalid.localdomain'
       end
-      # this test stopped working in the puppet 5.x series
-      xit 'name' do
-        expect { debugger.node.name }.to raise_error(PuppetDebugger::Exception::UndefinedNode)
-      end
     end
 
     it 'set node name' do

data/spec/spec_helper.rb

@@ -1,25 +1,30 @@
 # frozen_string_literal: true
 
-require 'simplecov'
 require_relative '../lib/puppet-debugger'
 require 'yaml'
-ENV['COVERAGE'] = 'true'
+ENV['CI'] = 'true'
 
-module SimpleCov::Configuration
-  def clean_filters
-    @filters = []
+if ENV['COVERAGE']
+  require 'simplecov'
+
+  module SimpleCov::Configuration
+    def clean_filters
+      @filters = []
+    end
   end
-end
 
-SimpleCov.configure do
-  clean_filters
-  load_profile 'test_frameworks'
-end
+  SimpleCov.configure do
+    clean_filters
+    load_profile 'test_frameworks'
+  end
 
-SimpleCov.start do
-  add_filter '/.rvm/'
-  add_filter 'vendor'
-  add_filter 'bundler'
+  if ENV['COVERAGE']
+    SimpleCov.start do
+      add_filter '/.rvm/'
+      add_filter 'vendor'
+      add_filter 'bundler'
+    end
+  end
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -30,17 +35,17 @@ require 'puppet-debugger'
 ENV['REPL_FACTERDB_FILTER'] = 'operatingsystem=Fedora and operatingsystemrelease=23 and architecture=x86_64 and facterversion=/^2\\.4/'
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each { |f| require f }
 
 def stdlib_path
   File.join(Puppet[:basemodulepath].split(':').first, 'stdlib')
 end
 
 def install_stdlib
-  `bundle exec puppet module install puppetlabs/stdlib` unless File.exists?(stdlib_path)
+  `bundle exec puppet module install puppetlabs/stdlib` unless File.exist?(stdlib_path)
 end
 
-#install_stdlib
+# install_stdlib
 
 def fixtures_dir
   File.join(File.dirname(__FILE__), 'fixtures')
@@ -62,7 +67,6 @@ def supports_datatypes?
   Gem::Version.new(Puppet.version) >= Gem::Version.new('4.5')
 end
 
-
 RSpec.configure do |config|
   config.filter_run_excluding native_functions: !supports_native_functions?
   RSpec::Expectations.configuration.on_potential_false_positives = :nothing

data/spec/support_spec.rb

@@ -21,19 +21,19 @@ describe 'support' do
   end
 
   let(:manifest_file) do
-    file = File.open('/tmp/debugger_puppet_manifest.pp', 'w') do |f|
+    File.open('/tmp/debugger_puppet_manifest.pp', 'w') do |f|
       f.write(manifest_code)
     end
     '/tmp/debugger_puppet_manifest.pp'
   end
 
   let(:manifest_code) do
-    <<-EOF
+    <<-OUT
     file{'/tmp/test.txt': ensure => absent } \n
     notify{'hello_there':} \n
     service{'httpd': ensure => running}\n
 
-    EOF
+    OUT
   end
 
   after(:each) do
@@ -61,6 +61,4 @@ describe 'support' do
     expect(debugger.node.facts.values).to be_instance_of(Hash)
     expect(debugger.node.facts.values['fqdn']).to eq('foo.example.com')
   end
-
-
 end