puppet-lint 2.3.0 → 2.3.1

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

@@ -4,33 +4,37 @@ describe 'duplicate_params' do
   let(:msg) { 'duplicate parameter found in resource' }
 
   context 'resource with duplicate parameters' do
-    let(:code) { "
-      file { '/tmp/foo':
-        ensure => present,
-        foo => bar,
-        baz => gronk,
-        foo => meh,
-      }"
-    }
+    let(:code) do
+      <<-END
+        file { '/tmp/foo':
+          ensure => present,
+          foo => bar,
+          baz => gronk,
+          foo => meh,
+        }
+      END
+    end
 
     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(msg).on_line(6).in_column(9)
+      expect(problems).to contain_error(msg).on_line(5).in_column(11)
     end
   end
 
   context 'bug #145: resource with a hash and no duplicate parameters' do
-    let(:code) { "
-      class {'fooname':
-        hashes => [
-          { foo => 'bar01',},
-          { foo => 'bar02', },
-        ],
-      }"
-    }
+    let(:code) do
+      <<-END
+        class {'fooname':
+          hashes => [
+            { foo => 'bar01',},
+            { foo => 'bar02', },
+          ],
+        }
+      END
+    end
 
     it 'should not detect any errors' do
       expect(problems).to have(0).problems
@@ -38,52 +42,58 @@ describe 'duplicate_params' do
   end
 
   context 'bug #145: resource with a hash and duplicate parameters in subhash' do
-    let(:code) { "
-      class {'fooname':
-        hashes => [
-          { foo => 'bar01',
-            foo => 'bar02', },
-        ],
-      }"
-    }
+    let(:code) do
+      <<-END
+        class {'fooname':
+          hashes => [
+            { foo => 'bar01',
+              foo => 'bar02', },
+          ],
+        }
+      END
+    end
 
     it 'should only detect a single error' do
       expect(problems).to have(1).problem
     end
 
     it 'should create an error' do
-      expect(problems).to contain_error(msg).on_line(5).in_column(13)
+      expect(problems).to contain_error(msg).on_line(4).in_column(15)
     end
   end
 
   context 'bug #145: resource with a hash and duplicate parameters in parent type' do
-    let(:code) { "
-      class {'fooname':
-        hashes    => [
-          { foo     => 'bar01', },
-          { foo     => 'bar02', },
-        ],
-        something => { hash => 'mini', },
-        hashes    => 'dupe',
-      }"
-    }
+    let(:code) do
+      <<-END
+        class {'fooname':
+          hashes    => [
+            { foo     => 'bar01', },
+            { foo     => 'bar02', },
+          ],
+          something => { hash => 'mini', },
+          hashes    => 'dupe',
+        }
+      END
+    end
 
     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(msg).on_line(8).in_column(9)
+      expect(problems).to contain_error(msg).on_line(7).in_column(11)
     end
   end
 
   describe 'bug #145: more hash tests and no duplicate parameters' do
-    let(:code) { "
-      class test {
-        $foo = { param => 'value', }
-        $bar = { param => 'bar', }
-      }"
-    }
+    let(:code) do
+      <<-END
+        class test {
+          $foo = { param => 'value', }
+          $bar = { param => 'bar', }
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -91,7 +101,7 @@ describe 'duplicate_params' do
   end
 
   context 'colon as last token in file' do
-    let(:code) { "}:" }
+    let(:code) { '}:' }
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems

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

@@ -13,11 +13,13 @@ describe 'ensure_first_param' do
     end
 
     context 'ensure as only attr in a multi line resource' do
-      let(:code) { "
-        file { 'foo':
-          ensure => present,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => present,
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -25,29 +27,33 @@ describe 'ensure_first_param' do
     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
+      let(:code) do
+        <<-END
+          file { 'foo':
+            mode   => '0000',
+            ensure => present,
+          }
+        END
+      end
+
+      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_warning(msg).on_line(4).in_column(11)
+        expect(problems).to contain_warning(msg).on_line(3).in_column(13)
       end
     end
 
     context 'ensure as first attr in a multi line resource' do
-      let(:code) { "
-        file { 'foo':
-          ensure => present,
-          mode   => '0000',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => present,
+            mode   => '0000',
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -55,18 +61,20 @@ describe 'ensure_first_param' do
     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',
-                    }
-                },
+      let(:code) do
+        <<-END
+          class thing {
+            class { 'thang':
+              stuff => {
+                'stuffing' => {
+                  ensure => 'present',
+                  blah   => 'bleah',
+                }
+              },
             }
-        }"
-      }
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -92,11 +100,13 @@ describe 'ensure_first_param' do
     end
 
     context 'ensure as only attr in a multi line resource' do
-      let(:code) { "
-        file { 'foo':
-          ensure => present,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => present,
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -104,37 +114,46 @@ describe 'ensure_first_param' do
     end
 
     context 'ensure as second attr in a multi line resource' do
-      let(:code) { "
-        file { 'foo':
-          mode   => '0000',
-          ensure => present,
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            mode   => '0000',
+            ensure => present,
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          file { 'foo':
+            ensure => present,
+            mode   => '0000',
+          }
+        END
+      end
 
       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)
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(13)
       end
 
       it 'should make ensure the first attr' do
-        expect(manifest).to eq("
-        file { 'foo':
-          ensure => present,
-          mode   => '0000',
-        }")
+        expect(manifest).to eq(fixed)
       end
     end
 
     context 'ensure as first attr in a multi line resource' do
-      let(:code) { "
-        file { 'foo':
-          ensure => present,
-          mode   => '0000',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => present,
+            mode   => '0000',
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -142,18 +161,20 @@ describe 'ensure_first_param' do
     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',
-                    }
-                },
+      let(:code) do
+        <<-END
+          class thing {
+            class { 'thang':
+              stuff => {
+                'stuffing' => {
+                  ensure => 'present',
+                  blah   => 'bleah',
+                }
+              },
             }
-        }"
-      }
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -161,38 +182,42 @@ describe 'ensure_first_param' do
     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(:code) do
+        <<-END
+          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,
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          file { 'foo':
+            ensure => $::operatingsystem ? {
+              'redhat' => absent,
+              default  => $::phase_of_the_moon ? {
+                'full'  => absent,
+                default => present,
+              },
             },
-          },
-          mode   => '0640',
-        }
-      " }
+            mode   => '0640',
+          }
+        END
+      end
 
       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)
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(13)
       end
 
       it 'should move the whole ensure parameter to the top' do

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

@@ -5,12 +5,14 @@ describe 'ensure_not_symlink_target' do
 
   context 'with fix disabled' do
     context 'file resource creating a symlink with seperate target attr' do
-      let(:code) { "
-        file { 'foo':
-          ensure => link,
-          target => '/foo/bar',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => link,
+            target => '/foo/bar',
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -18,18 +20,20 @@ describe 'ensure_not_symlink_target' do
     end
 
     context 'file resource creating a symlink with target specified in ensure' do
-      let(:code) { "
-        file { 'foo':
-          ensure => '/foo/bar',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => '/foo/bar',
+          }
+        END
+      end
 
       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_warning(msg).on_line(3).in_column(21)
+        expect(problems).to contain_warning(msg).on_line(2).in_column(23)
       end
     end
   end
@@ -44,12 +48,14 @@ describe 'ensure_not_symlink_target' do
     end
 
     context 'file resource creating a symlink with seperate target attr' do
-      let(:code) { "
-        file { 'foo':
-          ensure => link,
-          target => '/foo/bar',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => link,
+            target => '/foo/bar',
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -61,24 +67,29 @@ describe 'ensure_not_symlink_target' do
     end
 
     context 'file resource creating a symlink with target specified in ensure' do
-      let(:code) { "
-        file { 'foo':
-          ensure => '/foo/bar',
-        }"
-      }
-      let(:fixed) { "
-        file { 'foo':
-          ensure => symlink,
-          target => '/foo/bar',
-        }"
-      }
+      let(:code) do
+        <<-END
+          file { 'foo':
+            ensure => '/foo/bar',
+          }
+        END
+      end
+
+      let(:fixed) do
+        <<-END
+          file { 'foo':
+            ensure => symlink,
+            target => '/foo/bar',
+          }
+        END
+      end
 
       it 'should only detect a single problem' do
         expect(problems).to have(1).problem
       end
 
       it 'should fix the problem' do
-        expect(problems).to contain_fixed(msg).on_line(3).in_column(21)
+        expect(problems).to contain_fixed(msg).on_line(2).in_column(23)
       end
 
       it 'should create a new target param' do