puppet-lint 2.0.2 → 2.1.0

data/lib/puppet-lint/version.rb

@@ -1,3 +1,3 @@
 class PuppetLint
-  VERSION = '2.0.2'
+  VERSION = '2.1.0'
 end

data/puppet-lint.gemspec

@@ -14,8 +14,6 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'github_changelog_generator'
-
   s.authors = ['Tim Sharpe']
   s.email = 'tim@sharpe.id.au'
 end

data/spec/fixtures/test/manifests/ignore_reason.pp

@@ -1 +1,4 @@
-"test" # lint:ignore:double_quoted_strings for a good reason
+# test::ignore_reason
+class test::ignore_reason {
+  $foo = "test" # lint:ignore:double_quoted_strings for a good reason
+}

data/spec/fixtures/test/manifests/mismatched_control_comment.pp

@@ -0,0 +1 @@
+# lint:endignore

data/spec/puppet-lint/bin_spec.rb

@@ -213,17 +213,6 @@ describe PuppetLint::Bin do
       }
     end
 
-    context 'to print %{linenumber}' do
-      let(:args) { [
-        '--log-format', '%{linenumber}',
-        'spec/fixtures/test/manifests/fail.pp'
-      ] }
-
-      its(:exitstatus) { is_expected.to eq(1) }
-      its(:stdout) { is_expected.to eq('2') }
-      its(:stderr) { is_expected.to eq('DEPRECATION: Please use %{line} instead of %{linenumber}') }
-    end
-
     context 'to print %{line}' do
       let(:args) { [
         '--log-format', '%{line}',
@@ -275,6 +264,21 @@ describe PuppetLint::Bin do
     end
   end
 
+  context 'when displaying results as json' do
+    let(:args) { [
+      '--json',
+      'spec/fixtures/test/manifests/warning.pp',
+    ] }
+    its(:exitstatus) { is_expected.to eq(0) }
+    its(:stdout) do
+      if respond_to?(:include_json)
+        is_expected.to include_json([{'KIND' => 'WARNING'}])
+      else
+        is_expected.to match(/\[\n  \{/)
+      end
+    end
+  end
+
   context 'when hiding ignored problems' do
     let(:args) { [
       'spec/fixtures/test/manifests/ignore.pp'
@@ -302,7 +306,7 @@ describe PuppetLint::Bin do
 
     its(:exitstatus) { is_expected.to eq(0) }
     its(:stdout) { is_expected.to eq([
-      "IGNORED: double quoted string containing no variables on line 1",
+      "IGNORED: double quoted string containing no variables on line 3",
       "  for a good reason",
     ].join("\n")) }
   end
@@ -323,4 +327,13 @@ describe PuppetLint::Bin do
     its(:exitstatus) { is_expected.to eq(0) }
     its(:stdout) { is_expected.to match(/^.*line 6$/) }
   end
+
+  context 'when an lint:endignore control comment exists with no opening lint:ignore comment' do
+    let(:args) { [
+      'spec/fixtures/test/manifests/mismatched_control_comment.pp',
+    ] }
+
+    its(:exitstatus) { is_expected.to eq(0) }
+    its(:stdout) { is_expected.to match(/WARNING: lint:endignore comment with no opening lint:ignore:<check> comment found on line 1/) }
+  end
 end

data/spec/puppet-lint/configuration_spec.rb

@@ -51,6 +51,7 @@ describe PuppetLint::Configuration do
       'with_context' => false,
       'fix' => false,
       'show_ignored' => false,
+      'json' => false,
     })
   end
 end

data/spec/puppet-lint/lexer_spec.rb

@@ -17,8 +17,26 @@ describe PuppetLint::Lexer do
       expect(token.line).to eq(1)
     end
 
+    it 'should get correct line number after double quoted multi line string' do
+      token = @lexer.new_token(:STRING, "test\ntest", 9)
+      token = @lexer.new_token(:TEST, 'test', 4)
+      expect(token.line).to eq(2)
+    end
+
+    it 'should get correct line number after a multi line comment' do
+      token = @lexer.new_token(:MLCOMMENT, "test\ntest", 9)
+      token = @lexer.new_token(:TEST, 'test', 4)
+      expect(token.line).to eq(2)
+    end
+
     it 'should calculate the line number for a multi line string' do
-      @lexer.instance_variable_set('@line_no', 2)
+      token = @lexer.new_token(:SSTRING, "test\ntest", 9)
+      token = @lexer.new_token(:TEST, 'test', 4)
+      expect(token.line).to eq(2)
+    end
+
+    it 'should calculate line number for string that ends with newline' do
+      token = @lexer.new_token(:SSTRING, "test\n", 5)
       token = @lexer.new_token(:TEST, 'test', 4)
       expect(token.line).to eq(2)
     end
@@ -37,8 +55,9 @@ describe PuppetLint::Lexer do
     it 'should calculate the column number for a multi line string' do
       @lexer.instance_variable_set('@line_no', 4)
       @lexer.instance_variable_set('@column', "gronk".size)
+      token = @lexer.new_token(:SSTRING, "test\ntest", 9)
       token = @lexer.new_token(:TEST, 'test', 4)
-      expect(token.column).to eq(5)
+      expect(token.column).to eq(4)
     end
   end
 
@@ -629,6 +648,12 @@ describe PuppetLint::Lexer do
       expect(token.type).to eq(:CLASSREF)
       expect(token.value).to eq('::One')
     end
+
+    it 'should match terms that start with Types' do
+      token = @lexer.tokenise('Regexp_foo').first
+      expect(token.type).to eq(:CLASSREF)
+      expect(token.value).to eq('Regexp_foo')
+    end
   end
 
   context ':NAME' do
@@ -655,6 +680,12 @@ describe PuppetLint::Lexer do
       expect(token.type).to eq(:NAME)
       expect(token.value).to eq('::1one::2two::3three')
     end
+
+    it 'should match barewords beginning with an underscore' do
+      token = @lexer.tokenise('_bareword').first
+      expect(token.type).to eq(:NAME)
+      expect(token.value).to eq('_bareword')
+    end
   end
 
   context ':NUMBER' do
@@ -773,6 +804,12 @@ describe PuppetLint::Lexer do
       expect(token.type).to eq(:SSTRING)
       expect(token.value).to eq(%{foo\\\\})
     end
+
+    it "should match single quoted string containing a line break" do
+      token = @lexer.tokenise("'\n'").first
+      expect(token.type).to eq(:SSTRING)
+      expect(token.value).to eq("\n")
+    end
   end
 
   context ':REGEX' do
@@ -809,6 +846,17 @@ describe PuppetLint::Lexer do
       tokens = @lexer.tokenise('$x = $a/$b/$c')
       expect(tokens.select { |r| r.type == :REGEX }).to be_empty
     end
+
+    it 'should properly parse when regex follows an if' do
+      tokens = @lexer.tokenise('if /^icinga_service_icon_.*/ in $location_info { }')
+      expect(tokens[2].type).to eq(:REGEX)
+    end
+
+    it 'should properly parse when a regex follows an elsif' do
+      tokens = @lexer.tokenise('if /a/ in $location_info { } elsif /b/ in $location_info { }')
+      expect(tokens[2].type).to eq(:REGEX)
+      expect(tokens[14].type).to eq(:REGEX)
+    end
   end
 
   context ':STRING' do
@@ -817,5 +865,11 @@ describe PuppetLint::Lexer do
         @lexer.tokenise("exec { \"/bin/echo \\\\\\\"${environment}\\\\\\\"\": }")
       }.to_not raise_error
     end
+
+    it "should match double quoted string containing a line break" do
+      token = @lexer.tokenise(%Q{"\n"}).first
+      expect(token.type).to eq(:STRING)
+      expect(token.value).to eq("\n")
+    end
   end
 end

data/spec/puppet-lint/plugins/check_classes/code_on_top_scope_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe 'code_on_top_scope' do
+  describe 'comments outside class block' do
+    let(:code) { "
+      # Baz
+      class foo:bar {
+      }"
+    }
+
+    its(:problems) { should be_empty }
+  end
+
+  describe 'new lines outside of class-define block' do
+    let(:code) { "
+
+      class foo:bar {
+      }
+
+      "
+    }
+
+    its(:problems) { should be_empty }
+  end
+
+  describe 'code outside class block' do
+    let(:code) { "
+      include('something')
+
+      # Baz
+      class foo:bar {
+      }
+
+      define whatever {
+      }"
+    }
+
+    its(:problems) {
+      should contain_warning("code outside of class or define block - include")
+      should have(4).problems
+    }
+  end
+end

data/spec/puppet-lint/plugins/check_classes/name_contains_uppercase_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe 'names_containing_uppercase' do
+  
+  context 'defined type named FooBar' do
+    let(:code) { 'define FooBar { }' }
+    let(:path) { 'foobar/manifests/init.pp' }
+    let(:class_msg) { "defined type 'FooBar' contains illegal uppercase" }
+
+    it 'should only detect a single problem' do
+      expect(problems).to have(1).problem
+    end
+
+    it 'should create an error' do
+      expect(problems).to contain_error(class_msg).on_line(1).in_column(8)
+    end
+  end
+
+  context 'class named FooBar' do
+    let(:code) { 'class FooBar { }' }
+    let(:path) { 'foobar/manifests/init.pp' }
+    let(:class_msg) { "class 'FooBar' contains illegal uppercase" }
+
+    it 'should only detect a single problem' do
+      expect(problems).to have(1).problem
+    end
+
+    it 'should create an error' do
+      expect(problems).to contain_error(class_msg).on_line(1).in_column(7)
+    end
+  end
+
+  context 'class named Foo::BarFoo' do
+    let(:code) { 'class Foo::BarFoo { }' }
+    let(:path) { 'foo/manifests/barfoo.pp' }
+    let(:class_msg) { "class 'Foo::BarFoo' contains illegal uppercase" }
+
+    it 'should only detect a single problem' do
+      expect(problems).to have(1).problem
+    end
+
+    it 'should create an error' do
+      expect(problems).to contain_error(class_msg).on_line(1).in_column(7)
+    end
+
+    context 'check fix -' do
+      before do
+        PuppetLint.configuration.fix = true
+      end
+      
+      after do
+        PuppetLint.configuration.fix = false
+      end
+      
+      let(:fixed) { code.downcase }
+      
+      it 'should create an error' do
+        expect(problems).to contain_fixed(class_msg).on_line(1).in_column(7)
+      end
+      
+      it 'should downcase the class name' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+  end
+end

data/spec/puppet-lint/plugins/check_classes/parameter_order_spec.rb

@@ -73,5 +73,54 @@ describe 'parameter_order' do
         expect(problems).to have(0).problems
       end
     end
+
+    context "#{type} parameter w/a hash containing a variable and no optional parameters" do
+      let(:code) { "
+        $var1 = 'test'
+        
+        #{type} test (
+          $entries = {
+            '200 xxx' => {
+              param1 => $var1,
+              param2 => 'value2',
+              param3 => 'value3',
+            }
+          },
+          $mandatory => undef,
+        ) { }
+      "}
+
+      it { expect(problems).to have(0).problem }
+    end
+
+    context "#{type} parameter w/a hash containing a variable followed by an optional parameter" do
+      let(:code) { "
+        $var1 = 'test'
+        
+        #{type} test (
+          $entries = {
+            '200 xxx' => {
+              param1 => $var1,
+              param2 => 'value2',
+              param3 => 'value3',
+            }
+          },
+          $optional,
+          $mandatory => undef,
+        ) { }
+      "}
+
+      it { expect(problems).to contain_warning(msg).on_line(12).in_column(11) }
+    end
+
+    context "#{type} parameter w/array containing a variable" do
+      let(:code) {"
+        #{type} test (
+          $var1 = [$::hostname, 'host'],
+        ) { }
+      "}
+
+      it { expect(problems).to have(0).problem }
+    end
   end
 end

data/spec/puppet-lint/plugins/check_resources/ensure_first_param_spec.rb

@@ -3,72 +3,161 @@ require 'spec_helper'
 describe 'ensure_first_param' do
   let(:msg) { "ensure found on line but it's not the first attribute" }
 
-  context 'ensure as only attr in a single line resource' do
-    let(:code) { "file { 'foo': ensure => present }" }
+  context 'with fix disabled' do
+    context 'ensure as only attr in a single line resource' do
+      let(:code) { "file { 'foo': ensure => present }" }
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  context 'ensure as only attr in a multi line resource' do
-    let(:code) { "
-      file { 'foo':
-        ensure => present,
-      }"
-    }
+    context 'ensure as only attr in a multi line resource' do
+      let(:code) { "
+        file { 'foo':
+          ensure => present,
+        }"
+      }
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  context 'ensure as second attr in a multi line resource' do
-    let(:code) { "
-      file { 'foo':
-        mode   => '0000',
-        ensure => present,
-      }"
-    }
+    context 'ensure as second attr in a multi line resource' do
+      let(:code) { "
+        file { 'foo':
+          mode   => '0000',
+          ensure => present,
+        }"
+      }
+
+     it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    it 'should only detect a single problem' do
-      expect(problems).to have(1).problem
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(4).in_column(11)
+      end
     end
 
-    it 'should create a warning' do
-      expect(problems).to contain_warning(msg).on_line(4).in_column(9)
+    context 'ensure as first attr in a multi line resource' do
+      let(:code) { "
+        file { 'foo':
+          ensure => present,
+          mode   => '0000',
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  context 'ensure as first attr in a multi line resource' do
-    let(:code) { "
-      file { 'foo':
-        ensure => present,
-        mode   => '0000',
-      }"
-    }
+    context 'ensure as a hash key in classes does not need to be first' do
+      let(:code) { "
+        class thing {
+            class {'thang':
+                stuff => {
+                    'stuffing' => {
+                        ensure => 'present',
+                        blah   => 'bleah',
+                    }
+                },
+            }
+        }"
+      }
 
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
   end
 
-  context 'ensure as a hash key in classes does not need to be first' do
-    let(:code) { "
-      class thing {
-          class {'thang':
-              stuff => {
-                  'stuffing' => {
-                      ensure => 'present',
-                      blah   => 'bleah',
-                  }
-              },
-          }
-      }"
-    }
-
-    it 'should not detect any problems' do
-      expect(problems).to have(0).problems
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'ensure as only attr in a single line resource' do
+      let(:code) { "file { 'foo': ensure => present }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'ensure as only attr in a multi line resource' do
+      let(:code) { "
+        file { 'foo':
+          ensure => present,
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'ensure as second attr in a multi line resource' do
+      let(:code) { "
+        file { 'foo':
+          mode   => '0000',
+          ensure => present,
+        }"
+      }
+
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should create a warning' do
+        expect(problems).to contain_fixed(msg).on_line(4).in_column(11)
+      end
+
+      it 'should make ensure the first attr' do
+        expect(manifest).to eq("
+        file { 'foo':
+          ensure => present,
+          mode   => '0000',
+        }")
+      end
+    end
+
+    context 'ensure as first attr in a multi line resource' do
+      let(:code) { "
+        file { 'foo':
+          ensure => present,
+          mode   => '0000',
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'ensure as a hash key in classes does not need to be first' do
+      let(:code) { "
+        class thing {
+            class {'thang':
+                stuff => {
+                    'stuffing' => {
+                        ensure => 'present',
+                        blah   => 'bleah',
+                    }
+                },
+            }
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
   end
 end