puppet-lint 2.1.1 → 2.2.0

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'arrow_on_right_operand_line' do
+  {'chain' => '->', 'subscribe chain' => '~>'}.each do |name, operator|
+    context "#{name} operator" do
+      context 'both operands on same line' do
+        let(:code) { "Package['httpd'] #{operator} Service['httpd']" }
+
+        it { expect(problems).to have(0).problems }
+      end
+
+      context 'arrow on the line of left operand' do
+        let(:code) do
+          "Package['httpd']  #{operator}
+            Service['httpd']"
+        end
+
+        it { expect(problems).to have(1).problems }
+
+        context 'with fix enabled' do
+          before do
+            PuppetLint.configuration.fix = true
+          end
+
+          after do
+            PuppetLint.configuration.fix = false
+          end
+
+          let(:fixed) do
+            "Package['httpd']
+            #{operator} Service['httpd']"
+          end
+
+          it { expect(manifest).to eq (fixed) }
+        end
+      end
+
+      context 'arrow on the line of right operand' do
+        let(:code) { "Package['httpd']
+          #{operator} Service['httpd']" }
+
+        it { expect(problems).to have(0).problems }
+      end
+    end
+  end
+end

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

@@ -169,6 +169,37 @@ describe 'variable_scope' do
     end
   end
 
+  context 'nested future parser blocks' do
+    let(:code) { "
+      class foo() {
+        $foo = {1=>2, 3=>4}
+        $bar = [1, 2, 3]
+        $foo.each |$k ,$v| {
+          $k
+          $v
+          $x  # top-scope warning
+          $bar.each |$x| {
+            $k
+            $v
+            $x
+            $p  # top-scope warning
+          }
+          $x  # top-scope warning
+        }
+      }
+    " }
+
+    it 'should only detect three problems' do
+      expect(problems).to have(3).problem
+    end
+
+    it 'should create three warnings' do
+      expect(problems).to contain_warning(msg).on_line(8).in_column(11)
+      expect(problems).to contain_warning(msg).on_line(13).in_column(13)
+      expect(problems).to contain_warning(msg).on_line(15).in_column(11)
+    end
+  end
+
   %w{alias audit before loglevel noop notify require schedule stage subscribe tag}.each do |metaparam|
     context "referencing #{metaparam} metaparam value as a variable" do
       let(:code) { "
@@ -208,4 +239,46 @@ describe 'variable_scope' do
       expect(problems).to have(0).problems
     end
   end
+
+  context 'nested variable assignment' do
+    let(:code) { "
+      class test {
+        [$foo, [[$bar, $baz], $qux]] = something()
+      }
+    " }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'function calls inside string interpolation' do
+    let(:code) { "
+      class test {
+        \"${split('1,2,3', ',')}\"  # split is a function
+        \"${lookup('foo::bar')}\"  # lookup is a function
+      }
+    " }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'variables in string interpolation' do
+    let(:code) { "
+      class test {
+        \"${foo.split(',')}\"  # foo is a top-scope variable
+        \"${::bar.split(',')}\"
+      }
+    " }
+
+    it 'should only detect one problem' do
+      expect(problems).to have(1).problems
+    end
+
+    it 'should create one warning' do
+      expect(problems).to contain_warning(msg).on_line(3).in_column(11)
+    end
+  end
 end

data/spec/puppet-lint/plugins/check_nodes/unquoted_node_name_spec.rb

@@ -79,6 +79,18 @@ describe 'unquoted_node_name' do
         expect(problems).to contain_warning(msg).on_line(1).in_column(19)
       end
     end
+
+    context 'incomplete node block' do
+      let(:code) { 'node foo' }
+
+      it 'should detect a problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should create 1 error' do
+        expect(problems).to contain_error('Syntax error (try running `puppet parser validate <file>`)').on_line(1).in_column(1)
+      end
+    end
   end
 
   context 'with fix enabled' do

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

@@ -159,5 +159,45 @@ describe 'ensure_first_param' do
         expect(problems).to have(0).problems
       end
     end
+
+    context 'ensure is a selector' do
+      let(:code) { "
+        file { 'foo':
+          mode   => '0640',
+          ensure => $::operatingsystem ? {
+            'redhat' => absent,
+            default  => $::phase_of_the_moon ? {
+              'full'  => absent,
+              default => present,
+            },
+          },
+        }
+      " }
+
+      let(:fixed) { "
+        file { 'foo':
+          ensure => $::operatingsystem ? {
+            'redhat' => absent,
+            default  => $::phase_of_the_moon ? {
+              'full'  => absent,
+              default => present,
+            },
+          },
+          mode   => '0640',
+        }
+      " }
+
+      it 'should detect a problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the problem' do
+        expect(problems).to contain_fixed(msg).on_line(4).in_column(11)
+      end
+
+      it 'should move the whole ensure parameter to the top' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

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

@@ -131,6 +131,38 @@ describe 'file_mode' do
         expect(problems).to have(0).problems
       end
     end
+
+    context 'mode as a function return value' do
+      let(:code) { "file { 'foo': mode => lookup('bar'), }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'multi body file bad modes selector' do
+      let(:code) { "
+        file {
+          '/tmp/foo1':
+            ensure => $foo ? { default => absent },
+            mode => 644;
+          '/tmp/foo2':
+            mode => 644;
+          '/tmp/foo3':
+            mode => 644;
+         }"
+      }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create three warnings' do
+        expect(problems).to contain_warning(sprintf(msg)).on_line(5).in_column(21)
+        expect(problems).to contain_warning(sprintf(msg)).on_line(7).in_column(21)
+        expect(problems).to contain_warning(sprintf(msg)).on_line(9).in_column(21)
+      end
+    end
   end
 
   context 'with fix enabled' do
@@ -205,5 +237,57 @@ describe 'file_mode' do
         expect(manifest).to eq(code)
       end
     end
+
+    context 'mode as a function return value' do
+      let(:code) { "file { 'foo': mode => lookup('bar'), }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not change the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+
+    context 'multi body file bad modes selector' do
+      let(:code) { "
+        file {
+          '/tmp/foo1':
+            ensure => $foo ? { default => absent },
+            mode => 644;
+          '/tmp/foo2':
+            mode => 644;
+          '/tmp/foo3':
+            mode => 644;
+         }"
+      }
+
+      let(:fixed) { "
+        file {
+          '/tmp/foo1':
+            ensure => $foo ? { default => absent },
+            mode => '0644';
+          '/tmp/foo2':
+            mode => '0644';
+          '/tmp/foo3':
+            mode => '0644';
+         }"
+      }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix 3 problems' do
+        expect(problems).to contain_fixed(msg).on_line(5).in_column(21)
+        expect(problems).to contain_fixed(msg).on_line(7).in_column(21)
+        expect(problems).to contain_fixed(msg).on_line(9).in_column(21)
+      end
+
+      it 'should zero pad the file modes and change them to strings' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

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

@@ -27,6 +27,38 @@ describe 'unquoted_file_mode' do
         expect(problems).to contain_warning(msg).on_line(1).in_column(25)
       end
     end
+
+    context 'file mode from a function rvalue' do
+      let(:code) { "file { 'foo': mode => lookup('bar'), }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'multi body file bad modes selector' do
+      let(:code) { "
+        file {
+          '/tmp/foo1':
+            ensure => $foo ? { default => absent },
+            mode => 644;
+          '/tmp/foo2':
+            mode => 644;
+          '/tmp/foo3':
+            mode => 644;
+         }"
+      }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create three warnings' do
+        expect(problems).to contain_warning(sprintf(msg)).on_line(5).in_column(21)
+        expect(problems).to contain_warning(sprintf(msg)).on_line(7).in_column(21)
+        expect(problems).to contain_warning(sprintf(msg)).on_line(9).in_column(21)
+      end
+    end
   end
 
   context 'with fix enabled' do
@@ -69,5 +101,57 @@ describe 'unquoted_file_mode' do
         expect(manifest).to eq("concat { 'foo': mode => '0777' }")
       end
     end
+
+    context 'file mode from a function rvalue' do
+      let(:code) { "file { 'foo': mode => lookup('bar'), }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not change the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
+
+    context 'multi body file bad modes selector' do
+      let(:code) { "
+        file {
+          '/tmp/foo1':
+            ensure => $foo ? { default => absent },
+            mode => 644;
+          '/tmp/foo2':
+            mode => 644;
+          '/tmp/foo3':
+            mode => 644;
+         }"
+      }
+
+      let(:fixed) { "
+        file {
+          '/tmp/foo1':
+            ensure => $foo ? { default => absent },
+            mode => '644';
+          '/tmp/foo2':
+            mode => '644';
+          '/tmp/foo3':
+            mode => '644';
+         }"
+      }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix 3 problems' do
+        expect(problems).to contain_fixed(msg).on_line(5).in_column(21)
+        expect(problems).to contain_fixed(msg).on_line(7).in_column(21)
+        expect(problems).to contain_fixed(msg).on_line(9).in_column(21)
+      end
+
+      it 'should quote the file modes' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

data/spec/puppet-lint/plugins/check_strings/double_quoted_strings_spec.rb

@@ -99,6 +99,7 @@ describe 'double_quoted_strings' do
         $string4 = "this string contains \\"escaped \\" double quotes"
         $string5 = "this string contains \\'escaped \\' single quotes"
         $string6 = "this string contains \r line return"
+        $string7 = "this string contains \\\\ an escaped backslash"
         }}
 
       it 'should not detect any problems' do

data/spec/puppet-lint/plugins/check_whitespace/arrow_alignment_spec.rb

@@ -402,6 +402,28 @@ describe 'arrow_alignment' do
         expect(problems).to contain_warning(sprintf(msg,23,19)).on_line(6).in_column(19)
       end
     end
+
+    context 'complex data structure with different indentation levels at the same depth' do
+      let(:code) { "
+        class { 'some_class':
+          config_hash => {
+            'a_hash'   => {
+              'foo' => 'bar',
+            },
+            'an_array' => [
+              {
+                foo => 'bar',
+                bar => 'baz',
+              },
+            ],
+          },
+        }
+      " }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
   end
 
   context 'with fix enabled' do
@@ -675,5 +697,164 @@ describe 'arrow_alignment' do
         expect(manifest).to eq(fixed)
       end
     end
+
+    context 'complex data structure with different indentation levels at the same depth' do
+      let(:code) { "
+        class { 'some_class':
+          config_hash => {
+            'a_hash'   => {
+              'foo' => 'bar',
+            },
+            'an_array' => [
+              {
+                foo => 'bar',
+                bar  => 'baz',
+              },
+            ],
+          },
+        }
+      " }
+
+      let(:fixed) { "
+        class { 'some_class':
+          config_hash => {
+            'a_hash'   => {
+              'foo' => 'bar',
+            },
+            'an_array' => [
+              {
+                foo => 'bar',
+                bar => 'baz',
+              },
+            ],
+          },
+        }
+      " }
+
+      it 'should detect 1 problem' do
+        expect(problems).to have(1).problems
+      end
+
+      it 'should fix 1 problem' do
+        expect(problems).to contain_fixed(sprintf(msg, 21, 22)).on_line(10).in_column(22)
+      end
+
+      it 'should align the hash rockets' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'complex data structure with multiple token keys' do
+      let(:code) { <<-END.gsub(/^ {8}/, '')
+        class example (
+          $external_ip_base,
+        ) {
+
+          bar { 'xxxxxxxxx':
+            inputs => {
+              'ny' => {
+                "${external_ip_base}.16:443 ${a} ${b} ${c}" => 'foo',
+                'veryveryverylongstring8:443'=> 'foo',
+                'simple'=> 'foo',
+                '3'=> :foo,
+                :baz=> :qux,
+                3=> 3,
+              },
+            },
+          }
+        }
+        END
+      }
+
+      let(:fixed) { <<-END.gsub(/^ {8}/, '')
+        class example (
+          $external_ip_base,
+        ) {
+
+          bar { 'xxxxxxxxx':
+            inputs => {
+              'ny' => {
+                "${external_ip_base}.16:443 ${a} ${b} ${c}" => 'foo',
+                'veryveryverylongstring8:443'               => 'foo',
+                'simple'                                    => 'foo',
+                '3'                                         => :foo,
+                :baz                                        => :qux,
+                3                                           => 3,
+              },
+            },
+          }
+        }
+        END
+      }
+
+      it 'should detect 5 problems' do
+        expect(problems).to have(5).problems
+      end
+
+      it 'should fix 5 problems' do
+        expect(problems).to contain_fixed(sprintf(msg, 53, 38)).on_line(9).in_column(38)
+        expect(problems).to contain_fixed(sprintf(msg, 53, 17)).on_line(10).in_column(17)
+        expect(problems).to contain_fixed(sprintf(msg, 53, 12)).on_line(11).in_column(12)
+        expect(problems).to contain_fixed(sprintf(msg, 53, 13)).on_line(12).in_column(13)
+        expect(problems).to contain_fixed(sprintf(msg, 53, 10)).on_line(13).in_column(10)
+      end
+
+      it 'should realign the arrows' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'realignment of resource with an inline single line hash' do
+      let(:code) { <<-END.gsub(/^ {8}/, '')
+        class { 'puppetdb':
+          database                => 'embedded',
+          #database                => 'postgres',
+          #postgres_version        => '9.3',
+          java_args               => { '-Xmx' => '512m', '-Xms' => '256m' },
+          listen_address          => $::ipaddress_eth0,
+          listen_port             => 4998,
+          ssl_listen_address      => $::ipaddress_eth0,
+          ssl_listen_port         => 4999,
+          open_listen_port        => false,
+          open_ssl_listen_port    => false;
+        }
+        END
+      }
+
+      let(:fixed) { <<-END.gsub(/^ {8}/, '')
+        class { 'puppetdb':
+          database             => 'embedded',
+          #database                => 'postgres',
+          #postgres_version        => '9.3',
+          java_args            => { '-Xmx' => '512m', '-Xms' => '256m' },
+          listen_address       => $::ipaddress_eth0,
+          listen_port          => 4998,
+          ssl_listen_address   => $::ipaddress_eth0,
+          ssl_listen_port      => 4999,
+          open_listen_port     => false,
+          open_ssl_listen_port => false;
+        }
+        END
+      }
+
+      it 'should detect 8 problems' do
+        expect(problems).to have(8).problems
+      end
+
+      it 'should fix 8 problems' do
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(2).in_column(27)
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(5).in_column(27)
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(6).in_column(27)
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(7).in_column(27)
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(8).in_column(27)
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(9).in_column(27)
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(10).in_column(27)
+        expect(problems).to contain_fixed(sprintf(msg, 24, 27)).on_line(11).in_column(27)
+      end
+
+      it 'should realign the arrows' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end