puppet-lint 2.3.0 → 2.3.1

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe 'arrow_on_right_operand_line' do
-  {'chain' => '->', 'subscribe chain' => '~>'}.each do |name, operator|
+  { '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']" }
@@ -11,7 +11,8 @@ describe 'arrow_on_right_operand_line' do
 
       context 'arrow on the line of left operand' do
         let(:code) do
-          "Package['httpd']  #{operator}
+          "
+            Package['httpd']  #{operator}
             Service['httpd']"
         end
 
@@ -27,17 +28,22 @@ describe 'arrow_on_right_operand_line' do
           end
 
           let(:fixed) do
-            "Package['httpd']
+            "
+            Package['httpd']
             #{operator} Service['httpd']"
           end
 
-          it { expect(manifest).to eq (fixed) }
+          it { expect(manifest).to eq(fixed) }
         end
       end
 
       context 'arrow on the line of right operand' do
-        let(:code) { "Package['httpd']
-          #{operator} Service['httpd']" }
+        let(:code) do
+          <<-END
+            Package['httpd']
+            #{operator} Service['httpd']
+          END
+        end
 
         it { expect(problems).to have(0).problems }
       end

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe 'autoloader_layout' do
   context 'foo::bar in foo/manifests/bar.pp' do
-    let(:code) { "class foo::bar { }" }
+    let(:code) { 'class foo::bar { }' }
     let(:path) { 'foo/manifests/bar.pp' }
 
     it 'should not detect any problems' do
@@ -43,14 +43,16 @@ describe 'autoloader_layout' do
   end
 
   context 'foo included in bar/manifests/init.pp' do
-    let(:code) { "
-      class bar {
-        class {'foo':
-          someparam => 'somevalue',
+    let(:code) do
+      <<-END
+        class bar {
+          class {'foo':
+            someparam => 'somevalue',
+          }
         }
-      }
-      "
-    }
+      END
+    end
+
     let(:path) { 'bar/manifests/init.pp' }
 
     it 'should not detect any problems' do
@@ -100,6 +102,4 @@ describe 'autoloader_layout' do
       expect(problems).to have(0).problems
     end
   end
-
-
 end

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

@@ -4,29 +4,33 @@ describe 'class_inherits_from_params_class' do
   let(:msg) { 'class inheriting from params class' }
 
   context 'parameterised class that inherits from a params class' do
-    let(:code) { "
-      # commented
-      class foo($bar = $name) inherits foo::params { }"
-    }
+    let(:code) do
+      <<-END
+        # commented
+        class foo($bar = $name) inherits foo::params { }
+      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(40)
+      expect(problems).to contain_warning(msg).on_line(2).in_column(42)
     end
   end
 
   context 'class without parameters' do
-    let(:code) {"
-      class myclass {
+    let(:code) do
+      <<-END
+        class myclass {
 
-        if ( $::lsbdistcodename == 'squeeze' ) {
-          #TODO
+          if ( $::lsbdistcodename == 'squeeze' ) {
+            #TODO
+          }
         }
-      }
-    "}
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems

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

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

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

@@ -4,7 +4,7 @@ describe 'inherits_across_namespaces' do
   let(:msg) { 'class inherits across module namespaces' }
 
   context 'class inheriting from parent in same module namespace' do
-    let(:code) { "class foo::bar inherits foo { }" }
+    let(:code) { 'class foo::bar inherits foo { }' }
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -12,7 +12,7 @@ describe 'inherits_across_namespaces' do
   end
 
   context 'class inheriting from sister in same module namespace' do
-    let(:code) { "class foo::bar inherits foo::baz { }" }
+    let(:code) { 'class foo::bar inherits foo::baz { }' }
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -20,7 +20,7 @@ describe 'inherits_across_namespaces' do
   end
 
   context 'class inheriting from another module namespace' do
-    let(:code) { "class foo::bar inherits baz { }" }
+    let(:code) { 'class foo::bar inherits baz { }' }
 
     it 'should only detect a single problem' do
       expect(problems).to have(1).problem

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

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe 'names_containing_uppercase' do
-  
   context 'defined type named FooBar' do
     let(:code) { 'define FooBar { }' }
     let(:path) { 'foobar/manifests/init.pp' }
@@ -47,17 +46,17 @@ describe 'names_containing_uppercase' 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

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

@@ -42,4 +42,17 @@ describe 'names_containing_dash' do
       expect(problems).to contain_error(class_msg).on_line(1).in_column(7)
     end
   end
+
+  context 'multiple classes' do
+    let(:code) do
+      <<-END
+        class foo::bar_foo { }
+        class foo::baz-foo { }
+      END
+    end
+
+    it 'should create an error' do
+      expect(problems).to contain_error(class_msg).on_line(2).in_column(15)
+    end
+  end
 end

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

@@ -5,7 +5,7 @@ describe 'nested_classes_or_defines' do
   let(:define_msg) { 'defined type defined inside a class' }
 
   context 'class on its own' do
-    let(:code) { "class foo { }" }
+    let(:code) { 'class foo { }' }
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -13,30 +13,34 @@ describe 'nested_classes_or_defines' do
   end
 
   context 'class inside a class' do
-    let(:code) { "
-      class foo {
-        class bar {
+    let(:code) do
+      <<-END
+        class foo {
+          class 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(class_msg).on_line(3).in_column(9)
+      expect(problems).to contain_warning(class_msg).on_line(2).in_column(11)
     end
   end
 
   context 'instantiating a parametised class inside a class' do
-    let(:code) { "
-      class bar {
-        class { 'foo':
-          bar => 'foobar'
+    let(:code) do
+      <<-END
+        class bar {
+          class { 'foo':
+            bar => 'foobar'
+          }
         }
-      }"
-    }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -44,13 +48,15 @@ describe 'nested_classes_or_defines' do
   end
 
   context 'instantiating a parametised class inside a define' do
-    let(:code) { "
-      define bar() {
-        class { 'foo':
-          bar => 'foobar'
+    let(:code) do
+      <<-END
+        define bar() {
+          class { 'foo':
+            bar => 'foobar'
+          }
         }
-      }"
-    }
+      END
+    end
 
     it 'should not detect any problems' do
       expect(problems).to have(0).problems
@@ -58,19 +64,21 @@ describe 'nested_classes_or_defines' do
   end
 
   context 'define inside a class' do
-    let(:code) { "
-      class foo {
-        define bar() {
+    let(:code) do
+      <<-END
+        class foo {
+          define bar() {
+          }
         }
-      }"
-    }
+      END
+    end
 
     it 'should only detect a single problem' do
       expect(problems).to have(1).problems
     end
 
     it 'should create a warning' do
-      expect(problems).to contain_warning(define_msg).on_line(3).in_column(9)
+      expect(problems).to contain_warning(define_msg).on_line(2).in_column(11)
     end
   end
 end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'parameter_order' do
   let(:msg) { 'optional parameter listed before required parameter' }
 
-  ['define', 'class'].each do |type|
+  %w[define class].each do |type|
     context "#{type} with attrs in order" do
       let(:code) { "#{type} foo($bar, $baz='gronk') { }" }
 
@@ -27,17 +27,19 @@ describe 'parameter_order' do
         expect(problems).to have(1).problem
       end
 
-      col = (type == "class" ? 23 : 24)
+      col = (type == 'class' ? 23 : 24)
       it 'should create a warning' do
         expect(problems).to contain_warning(msg).on_line(1).in_column(col)
       end
     end
 
     context "#{type} parameter set to another variable" do
-      let(:code) { "
-        #{type} foo($bar, $baz = $name, $gronk=$::fqdn) {
-        }"
-      }
+      let(:code) do
+        <<-END
+          #{type} foo($bar, $baz = $name, $gronk=$::fqdn) {
+          }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -45,29 +47,33 @@ describe 'parameter_order' do
     end
 
     context "#{type} parameter set to another variable with incorrect order" do
-      let(:code) { "
-        #{type} foo($baz = $name, $bar, $gronk=$::fqdn) {
-        }"
-      }
+      let(:code) do
+        <<-END
+          #{type} foo($baz = $name, $bar, $gronk=$::fqdn) {
+          }
+        END
+      end
 
       it 'should only detect a single problem' do
         expect(problems).to have(1).problem
       end
 
-      col = (type == "class" ? 33 : 34)
+      col = (type == 'class' ? 35 : 36)
       it 'should create a warning' do
-        expect(problems).to contain_warning(msg).on_line(2).in_column(col)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(col)
       end
     end
 
     context 'issue-101' do
-      let(:code) { "
-        #{type} b (
-          $foo,
-          $bar='',
-          $baz={}
-        ) { }
-      " }
+      let(:code) do
+        <<-END
+          #{type} b (
+            $foo,
+            $bar='',
+            $baz={}
+          ) { }
+        END
+      end
 
       it 'should not detect any problems' do
         expect(problems).to have(0).problems
@@ -75,52 +81,71 @@ describe 'parameter_order' do
     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,
-        ) { }
-      "}
+      let(:code) do
+        <<-END
+          $var1 = 'test'
+
+          #{type} test (
+            $entries = {
+              '200 xxx' => {
+                param1 => $var1,
+                param2 => 'value2',
+                param3 => 'value3',
+              }
+            },
+            $mandatory => undef,
+          ) { }
+        END
+      end
 
       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) }
+      let(:code) do
+        <<-END
+          $var1 = 'test'
+
+          #{type} test (
+            $entries = {
+              '200 xxx' => {
+                param1 => $var1,
+                param2 => 'value2',
+                param3 => 'value3',
+              }
+            },
+            $optional,
+            $mandatory => undef,
+          ) { }
+        END
+      end
+
+      it { expect(problems).to contain_warning(msg).on_line(11).in_column(13) }
     end
 
     context "#{type} parameter w/array containing a variable" do
-      let(:code) {"
-        #{type} test (
-          $var1 = [$::hostname, 'host'],
-        ) { }
-      "}
+      let(:code) do
+        <<-END
+          #{type} test (
+            $var1 = [$::hostname, 'host'],
+          ) { }
+        END
+      end
 
       it { expect(problems).to have(0).problem }
     end
+
+    context "#{type} parameter with Optional data type" do
+      let(:code) do
+        <<-END
+          #{type} test(
+            String $test = 'value',
+            Optional[String] $optional,
+          ) { }
+        END
+      end
+
+      it { expect(problems).to have(0).problems }
+    end
   end
 end