puppet-lint 2.3.0 → 2.3.1

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

@@ -4,7 +4,7 @@ describe 'right_to_left_relationship' do
   let(:msg) { 'right-to-left (<-) relationship' }
 
   context 'chain 2 resources left to right' do
-    let(:code) { "Class[foo] -> Class[bar]" }
+    let(:code) { 'Class[foo] -> Class[bar]' }
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -12,7 +12,7 @@ describe 'right_to_left_relationship' do
   end
 
   context 'chain 2 resources right to left' do
-    let(:code) { "Class[foo] <- Class[bar]" }
+    let(:code) { 'Class[foo] <- Class[bar]' }
 
     it 'should only detect a single problem' do
       expect(problems).to have(1).problem

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

@@ -4,27 +4,31 @@ describe 'variable_scope' do
   let(:msg) { 'top-scope variable being used without an explicit namespace' }
 
   context 'class with no variables declared accessing top scope' do
-    let(:code) { "
-      class foo {
-        $bar = $baz
-      }"
-    }
+    let(:code) do
+      <<-END
+        class foo {
+          $bar = $baz
+        }
+      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(16)
+      expect(problems).to contain_warning(msg).on_line(2).in_column(18)
     end
   end
 
   context 'class with no variables declared accessing top scope explicitly' do
-    let(:code) { "
-      class foo {
-        $bar = $::baz
-      }"
-    }
+    let(:code) do
+      <<-END
+        class foo {
+          $bar = $::baz
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -32,12 +36,14 @@ describe 'variable_scope' do
   end
 
   context 'class with no variables declared accessing local array index' do
-    let(:code) { "
-      class foo {
-        $bar = ['one', 'two', 'three']
-        $baz = $bar[1]
-      }"
-    }
+    let(:code) do
+      <<-END
+        class foo {
+          $bar = ['one', 'two', 'three']
+          $baz = $bar[1]
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -45,30 +51,33 @@ describe 'variable_scope' do
   end
 
   context 'class with no variables declared accessing local hash key' do
-    let(:code) { "
-      class foo {
-        $bar = {
-          'one'   => 1,
-          'two'   => 2,
-          'three' => 3,
+    let(:code) do
+      <<-END
+        class foo {
+          $bar = {
+            'one'   => 1,
+            'two'   => 2,
+            'three' => 3,
+          }
+          $baz = $bar['two']
         }
-        $baz = $bar['two']
-      }"
-    }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
     end
   end
 
-
   context 'class with variables declared accessing local scope' do
-    let(:code) { "
-      class foo {
-        $bar = 1
-        $baz = $bar
-      }"
-    }
+    let(:code) do
+      <<-END
+        class foo {
+          $bar = 1
+          $baz = $bar
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -76,11 +85,13 @@ describe 'variable_scope' do
   end
 
   context 'class with parameters accessing local scope' do
-    let(:code) { "
-      class foo($bar='UNSET') {
-        $baz = $bar
-      }"
-    }
+    let(:code) do
+      <<-END
+        class foo($bar='UNSET') {
+          $baz = $bar
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -88,27 +99,31 @@ describe 'variable_scope' do
   end
 
   context 'defined type with no variables declared accessing top scope' do
-    let(:code) { "
-      define foo() {
-        $bar = $fqdn
-      }"
-    }
+    let(:code) do
+      <<-END
+        define foo() {
+          $bar = $fqdn
+        }
+      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(16)
+      expect(problems).to contain_warning(msg).on_line(2).in_column(18)
     end
   end
 
   context 'defined type with no variables declared accessing top scope explicitly' do
-    let(:code) { "
-      define foo() {
-        $bar = $::fqdn
-      }"
-    }
+    let(:code) do
+      <<-END
+        define foo() {
+          $bar = $::fqdn
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -116,14 +131,16 @@ describe 'variable_scope' do
   end
 
   context '$name should be auto defined' do
-    let(:code) { "
-      define foo() {
-        $bar = $name
-        $baz = $title
-        $gronk = $module_name
-        $meep = $1
-      }"
-    }
+    let(:code) do
+      <<-END
+        define foo() {
+          $bar = $name
+          $baz = $title
+          $gronk = $module_name
+          $meep = $1
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -131,13 +148,15 @@ describe 'variable_scope' do
   end
 
   context 'define with required parameter' do
-    let(:code) { "
-      define tomcat::base (
-          $max_perm_gen,
-          $owner = hiera('app_user'),
-          $system_properties = {},
-      ) {  }"
-    }
+    let(:code) do
+      <<-END
+        define tomcat::base (
+            $max_perm_gen,
+            $owner = hiera('app_user'),
+            $system_properties = {},
+        ) {  }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -145,68 +164,74 @@ describe 'variable_scope' do
   end
 
   context 'future parser blocks' do
-    let(:code) { "
-      class foo() {
-        $foo = {1=>2, 3=>4}
-        $foo.each |$a, $b| {
-          $a    # should cause no warnings
-          $c    # top-scope variable warning
-        }
-        $b      # top-scope variable warning
-        $foo.each |$d| {
-          $d[1] # should cause no warnings
+    let(:code) do
+      <<-END
+        class foo() {
+          $foo = {1=>2, 3=>4}
+          $foo.each |$a, $b| {
+            $a    # should cause no warnings
+            $c    # top-scope variable warning
+          }
+          $b      # top-scope variable warning
+          $foo.each |$d| {
+            $d[1] # should cause no warnings
+          }
         }
-      }
-    " }
+      END
+    end
 
     it 'should only detect two problems' do
       expect(problems).to have(2).problem
     end
 
     it 'should create two warnings' do
-      expect(problems).to contain_warning(msg).on_line(8).in_column(9)
-      expect(problems).to contain_warning(msg).on_line(6).in_column(11)
+      expect(problems).to contain_warning(msg).on_line(7).in_column(11)
+      expect(problems).to contain_warning(msg).on_line(5).in_column(13)
     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| {
+    let(:code) do
+      <<-END
+        class foo() {
+          $foo = {1=>2, 3=>4}
+          $bar = [1, 2, 3]
+          $foo.each |$k ,$v| {
             $k
             $v
-            $x
-            $p  # top-scope warning
+            $x  # top-scope warning
+            $bar.each |$x| {
+              $k
+              $v
+              $x
+              $p  # top-scope warning
+            }
+            $x  # top-scope warning
           }
-          $x  # top-scope warning
         }
-      }
-    " }
+      END
+    end
 
     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)
+      expect(problems).to contain_warning(msg).on_line(7).in_column(13)
+      expect(problems).to contain_warning(msg).on_line(12).in_column(15)
+      expect(problems).to contain_warning(msg).on_line(14).in_column(13)
     end
   end
 
-  %w{alias audit before loglevel noop notify require schedule stage subscribe tag}.each do |metaparam|
+  %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) { "
-        class foo() {
-          $#{metaparam}
-        }
-      " }
+      let(:code) do
+        <<-END
+          class foo() {
+            $#{metaparam}
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -215,13 +240,15 @@ describe 'variable_scope' do
   end
 
   context 'support the use of facts and trusted facts for Puppet 3.5 onwards' do
-    let(:code) { "
-      class foo() {
-        if $facts['osfamily'] == 'redhat' or $trusted['osfamily'] == 'redhat' {
-         $redhat = true
+    let(:code) do
+      <<-END
+        class foo() {
+          if $facts['osfamily'] == 'redhat' or $trusted['osfamily'] == 'redhat' {
+           $redhat = true
+          }
         }
-      }
-    " }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -229,11 +256,13 @@ describe 'variable_scope' do
   end
 
   context 'multiple left hand variable assign' do
-    let(:code) { "
-      class test {
-        [$foo, $bar] = something()
-      }
-    " }
+    let(:code) do
+      <<-END
+        class test {
+          [$foo, $bar] = something()
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -241,11 +270,13 @@ describe 'variable_scope' do
   end
 
   context 'nested variable assignment' do
-    let(:code) { "
-      class test {
-        [$foo, [[$bar, $baz], $qux]] = something()
-      }
-    " }
+    let(:code) do
+      <<-END
+        class test {
+          [$foo, [[$bar, $baz], $qux]] = something()
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -253,12 +284,14 @@ describe 'variable_scope' do
   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
-      }
-    " }
+    let(:code) do
+      <<-END
+        class test {
+          "${split('1,2,3', ',')}"  # split is a function
+          "${lookup('foo::bar')}"  # lookup is a function
+        }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -266,19 +299,21 @@ describe 'variable_scope' do
   end
 
   context 'variables in string interpolation' do
-    let(:code) { "
-      class test {
-        \"${foo.split(',')}\"  # foo is a top-scope variable
-        \"${::bar.split(',')}\"
-      }
-    " }
+    let(:code) do
+      <<-END
+        class test {
+          "${foo.split(',')}"  # foo is a top-scope variable
+          "${::bar.split(',')}"
+        }
+      END
+    end
 
     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)
+      expect(problems).to contain_warning(msg).on_line(2).in_column(13)
     end
   end
 end