puppet-debugger 0.19.0 → 1.0.0

data/spec/input_responders/exit_spec.rb

@@ -1,13 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 
 describe :exit do
   let(:args) { [] }
 
-  xit 'exits' do
-    expect{plugin.run(args)}.to eq('')
-  end
-
   let(:plugin) do
     instance = PuppetDebugger::InputResponders::Commands.plugin_from_command(subject.to_s).instance
     instance.debugger = debugger
@@ -26,21 +24,21 @@ describe :exit do
     {}
   end
 
-  it "commands contant is an array" do
+  it 'commands contant is an array' do
     expect(plugin.class::COMMAND_WORDS).to be_a(Array)
   end
 
-  it "commands must contain at least one word" do
-    expect(plugin.class::COMMAND_WORDS.count).to  be > 0
+  it 'commands must contain at least one word' do
+    expect(plugin.class::COMMAND_WORDS.count).to be > 0
   end
 
-  it "summary must be a string" do
+  it 'summary must be a string' do
     expect(plugin.class::SUMMARY).to be_a(String)
   end
 
-  it 'implements run' do
-    expect{plugin.run([])}.not_to raise_error(NotImplementedError)
-  end
+  # it 'implements run' do
+  #   expect { plugin.run([]) }.not_to raise(SystemExit)
+  # end
 
   it 'be looked up via any command words' do
     plugin.class::COMMAND_WORDS.each do |word|

data/spec/input_responders/facterdb_filter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'

data/spec/input_responders/facts_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'

data/spec/input_responders/functions_spec.rb

@@ -1,73 +1,75 @@
-require "spec_helper"
-require "puppet-debugger"
-require "puppet-debugger/plugin_test_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'puppet-debugger'
+require 'puppet-debugger/plugin_test_helper'
 
 describe :functions do
-  include_examples "plugin_tests"
+  include_examples 'plugin_tests'
 
   let(:input) do
     "md5('hello')"
   end
 
   let(:mod_dir) do
-    File.join(fixtures_dir, "modules", "extlib")
+    File.join(fixtures_dir, 'modules', 'extlib')
   end
 
-  it "runs" do
+  it 'runs' do
     expect(plugin.run).to be_a String
   end
 
-  it "returns functions" do
+  it 'returns functions' do
     expect(plugin.function_map).to be_a Hash
   end
 
-  it "sorted_list" do
+  it 'sorted_list' do
     expect(plugin.sorted_list).to be_a Array
     expect(plugin.sorted_list.first).to be_a Hash
   end
 
-  it "returns function names" do
+  it 'returns function names' do
     expect(plugin.func_list).to be_a Array
-    expect(plugin.func_list.find { |m| m =~ /md5/ }).to eq("md5()")
+    expect(plugin.func_list.find { |m| m =~ /md5/ }).to eq('md5()')
   end
 
-  it "execute md5" do
+  it 'execute md5' do
     debugger_output = /5d41402abc4b2a76b9719d911017c592/
     debugger.handle_input("md5('hello')")
     expect(output.string).to match(debugger_output)
   end
 
-  it "execute swapcase" do
+  it 'execute swapcase' do
     debugger_output = /HELLO/
     debugger.handle_input("swapcase('hello')")
     expect(output.string).to match(debugger_output)
   end
 
-  it "#function_obj with native function" do
-    expect(plugin.function_obj(File.join(mod_dir, "functions", "dir_split.pp"))).to eq(
-      { :file => File.join(mod_dir, "functions", "dir_split.pp"), :mod_name => "extlib",
-        :full_name => "extlib::dir_split", :name => "extlib::dir_split", :namespace => "extlib",
-        :summary => "Splits the given directory or directories into individual paths." }
+  it '#function_obj with native function' do
+    expect(plugin.function_obj(File.join(mod_dir, 'functions', 'dir_split.pp'))).to eq(
+      file: File.join(mod_dir, 'functions', 'dir_split.pp'), mod_name: 'extlib',
+      full_name: 'extlib::dir_split', name: 'extlib::dir_split', namespace: 'extlib',
+      summary: 'Splits the given directory or directories into individual paths.'
     )
   end
 
-  it "#function_obj ruby v4 without namespace" do
-    expect(plugin.function_obj(File.join(mod_dir, "lib", "puppet", "functions", "echo.rb"))).to eq({ :file => File.join(mod_dir, "lib", "puppet", "functions", "echo.rb"), :mod_name => "extlib",
-                                                                                                     :full_name => "echo", :name => "echo", :namespace => "", :summary => "DEPRECATED.  Use the namespaced function [`extlib::echo`](#extlibecho) instead." })
+  it '#function_obj ruby v4 without namespace' do
+    expect(plugin.function_obj(File.join(mod_dir, 'lib', 'puppet', 'functions', 'echo.rb'))).to eq(file: File.join(mod_dir, 'lib', 'puppet', 'functions', 'echo.rb'), mod_name: 'extlib',
+                                                                                                   full_name: 'echo', name: 'echo', namespace: '', summary: 'DEPRECATED.  Use the namespaced function [`extlib::echo`](#extlibecho) instead.')
   end
 
-  it "#function_obj ruby v4 and namespace" do
-    expect(plugin.function_obj(File.join(mod_dir, "lib", "puppet", "functions", "extlib", "echo.rb"))).to eq({ :file => File.join(mod_dir, "lib", "puppet", "functions", "extlib", "echo.rb"), :mod_name => "extlib",
-                                                                                                               :full_name => "extlib::echo", :name => "extlib::echo", :namespace => "extlib", :summary => nil })
+  it '#function_obj ruby v4 and namespace' do
+    expect(plugin.function_obj(File.join(mod_dir, 'lib', 'puppet', 'functions', 'extlib', 'echo.rb'))).to eq(file: File.join(mod_dir, 'lib', 'puppet', 'functions', 'extlib', 'echo.rb'), mod_name: 'extlib',
+                                                                                                             full_name: 'extlib::echo', name: 'extlib::echo', namespace: 'extlib', summary: nil)
   end
 
-  it "#function_obj has puppet namespace" do
-    file, _ = Puppet::Functions.method(:create_function).source_location
+  it '#function_obj has puppet namespace' do
+    file, = Puppet::Functions.method(:create_function).source_location
     dir = File.dirname(file)
-    f_obj = plugin.function_obj(File.join(dir, "functions", "include.rb"))
+    f_obj = plugin.function_obj(File.join(dir, 'functions', 'include.rb'))
     expect(f_obj[:mod_name]).to match(/puppet-.*/)
-    expect(f_obj[:name]).to eq("include")
-    expect(f_obj[:full_name]).to eq("include")
+    expect(f_obj[:name]).to eq('include')
+    expect(f_obj[:full_name]).to eq('include')
     expect(f_obj[:summary]).to be_nil
   end
 end

data/spec/input_responders/help_spec.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger/plugin_test_helper'
 
 describe :help do
-  include_examples "plugin_tests"
+  include_examples 'plugin_tests'
   let(:args) { [] }
 
   let(:help_output) do
@@ -29,4 +31,4 @@ describe :help do
   it 'show created by' do
     expect(help_output).to match(/Created by: NWOps <corey@nwops.io>\n/)
   end
-end
+end

data/spec/input_responders/krt_spec.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger/plugin_test_helper'
 
 describe :krt do
-  include_examples "plugin_tests"
+  include_examples 'plugin_tests'
   let(:args) { [] }
 
   it 'works' do

data/spec/input_responders/play_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger/plugin_test_helper'
 describe :play do
-  include_examples "plugin_tests"
+  include_examples 'plugin_tests'
 
   describe 'convert  url' do
     describe 'unsupported' do
@@ -96,7 +98,6 @@ describe :play do
 
   describe 'multiple lines of input' do
     before(:each) do
-
     end
     describe '3 lines' do
       let(:input) do
@@ -133,16 +134,12 @@ describe :play do
     end
     describe 'multiple lines puppet code' do
       let(:input) do
-        <<-EOF
-if $osfamily {
-  $var = '3'
-}
-$var
-        EOF
-      end
-      xit do
-        plugin.play_back_string(input)
-        expect(output.string).to include('"3"')
+        <<~OUT
+          if $osfamily {
+            $var = '3'
+          }
+          $var
+        OUT
       end
     end
   end
@@ -158,17 +155,10 @@ $var
     let(:input) do
       "play #{file_url}"
     end
-    # requires internet and stops testing
-    xit 'url' do
-      allow(debugger).to receive(:fetch_url_data).with(file_url + '.txt').and_return(File.read(fixtures_file))
-      debugger.handle_input(input)
-      expect(output.string).to match(/test/)
-      expect(output.string).to match(/Puppet::Type::File/)
-    end
 
     it 'file' do
       debugger.handle_input("play #{fixtures_file}")
       expect(output.string).to match(/Puppet::Type::File/)
     end
   end
-end
+end

data/spec/input_responders/reset_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'

data/spec/input_responders/resources_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'
 
 describe :resources do
   include_examples 'plugin_tests'
-  let(:args) { }
+  let(:args) {}
 
   it 'should be able to print resources' do
     debugger_output = /main/

data/spec/input_responders/set_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'
@@ -7,7 +9,7 @@ describe 'set' do
   let(:input) do
     ':set loglevel debug'
   end
-  
+
   it 'should set the loglevel' do
     debugger_output = /loglevel debug is set/
     debugger.handle_input(input)

data/spec/input_responders/stacktrace_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'puppet-debugger'
+require 'puppet-debugger/plugin_test_helper'
+
+describe :stacktrace do
+  include_examples 'plugin_tests'
+  let(:args) {}
+
+  it 'should be able to print stacktrace' do
+    debugger_output = /stacktrace\snot\savailable/
+    expect(plugin.run(args)).to match(debugger_output)
+  end
+end

data/spec/input_responders/types_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'

data/spec/input_responders/vars_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'
@@ -38,10 +40,10 @@ describe :vars do
 
   describe 'list variables' do
     let(:input) do
-      <<-EOF
+      <<-OUT
       class test( $param1 = "files", $param2 = $param1 ) {}
       include test
-      EOF
+      OUT
     end
     it 'ls test' do
       debugger.handle_input(input)
@@ -49,7 +51,5 @@ describe :vars do
       expect(out).to include('"param1"')
       expect(out).to include('"param2"')
     end
-   
-
   end
 end

data/spec/input_responders/whereami_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'puppet-debugger'
 require 'puppet-debugger/plugin_test_helper'

data/spec/pdb_spec.rb

@@ -28,11 +28,6 @@ describe 'pdb' do
     expect(`bundle exec bin/pdb --play #{fixtures_file} --run-once`)
       .to match(/Puppet::Type::File/)
   end
-  # xit do
-  #   # this test does not work without internet, and I am at 30K feet right now
-  #   expect(`bundle exec bin/pdb --play #{file_url} --run-once`)
-  #     .to match(/Puppet::Type::File/)
-  # end
 
   describe 'remote_node' do
     let(:node_obj) do
@@ -44,9 +39,5 @@ describe 'pdb' do
     before :each do
       allow(PuppetDebugger).to receive(:get_remote_node).with(node_name).and_return(node_obj)
     end
-    # xit do
-    #   expect(`echo 'vars'| bundle exec bin/pdb -n #{node_name}`)
-    #     .to match(/server_facts/)
-    # end
   end
 end

data/spec/puppet/application/debugger_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::Application::Debugger do
   end
 
   # ideally, we should only be providing args in stead of mocking the options
-  # however during a text, the options in the puppet application are not merged from 
+  # however during a text, the options in the puppet application are not merged from
   # the command line opts so the args never get passed through to options
   let(:args) do
     []
@@ -72,13 +72,13 @@ describe Puppet::Application::Debugger do
 
     describe 'can reset correctly' do
       let(:input) do
-        <<-EOF
-$var1 = 'dsfasd'
-$var1
-reset
-$var1 = '111111'
-$var1
-        EOF
+        <<~OUT
+          $var1 = 'dsfasd'
+          $var1
+          reset
+          $var1 = '111111'
+          $var1
+        OUT
       end
 
       it 'assign variable' do
@@ -89,7 +89,6 @@ $var1
   end
 
   describe 'without facterdb' do
-    
     it 'run md5 function' do
       allow(debugger).to receive(:options).and_return(code: "md5('sdafsd')", quiet: true, run_once: true, use_facterdb: false)
       expect { debugger.run_command }.to output(/569ebc3d91672e7d3dce25de1684d0c9/).to_stdout
@@ -108,22 +107,22 @@ $var1
         ]
       end
       it 'list resources in catalog' do
-        allow(debugger).to receive(:options).and_return(code: "resources",
-          quiet: true, run_once: true, use_facterdb: true, 
-          catalog: File.expand_path(File.join(fixtures_dir, 'pe-xl-core-0.puppet.vm.json')))
+        allow(debugger).to receive(:options).and_return(code: 'resources',
+                                                        quiet: true, run_once: true, use_facterdb: true,
+                                                        catalog: File.expand_path(File.join(fixtures_dir, 'pe-xl-core-0.puppet.vm.json')))
         expect { debugger.run_command }.to output(/Puppet_enterprise/).to_stdout
       end
     end
 
     describe 'can reset correctly' do
       let(:input) do
-        <<-EOF
-$var1 = 'dsfasd'
-$var1
-reset
-$var1 = '111111'
-$var1
-        EOF
+        <<~OUT
+          $var1 = 'dsfasd'
+          $var1
+          reset
+          $var1 = '111111'
+          $var1
+        OUT
       end
 
       it 'assign variable' do

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)