puppet-lint 0.4.0.pre1 → 1.0.0

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

@@ -1,23 +1,25 @@
 require 'spec_helper'
 
 describe 'right_to_left_relationship' do
-  describe 'chain 2 resources left to right' do
+  let(:msg) { 'right-to-left (<-) relationship' }
+
+  context 'chain 2 resources left to right' do
     let(:code) { "Class[foo] -> Class[bar]" }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'chain 2 resources right to left' do
+  context 'chain 2 resources right to left' do
     let(:code) { "Class[foo] <- Class[bar]" }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "right-to-left (<-) relationship",
-        :linenumber => 1,
-        :column     => 12,
-      })
-      should_not have_problem :kind => :error
-    }
+    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(1).in_column(12)
+    end
   end
 end

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

@@ -1,35 +1,37 @@
 require 'spec_helper'
 
 describe 'variable_scope' do
-  describe 'class with no variables declared accessing top 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
       }"
     }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "top-scope variable being used without an explicit namespace",
-        :linenumber => 3,
-        :column     => 16,
-      })
-      should_not have_problem :kind => :error
-    }
+    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)
+    end
   end
 
-  describe 'class with no variables declared accessing top scope explicitly' do
+  context 'class with no variables declared accessing top scope explicitly' do
     let(:code) { "
       class foo {
         $bar = $::baz
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'class with variables declared accessing local scope' do
+  context 'class with variables declared accessing local scope' do
     let(:code) { "
       class foo {
         $bar = 1
@@ -37,48 +39,52 @@ describe 'variable_scope' do
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'class with parameters accessing local scope' do
+  context 'class with parameters accessing local scope' do
     let(:code) { "
       class foo($bar='UNSET') {
         $baz = $bar
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'defined type with no variables declared accessing top scope' do
+  context 'defined type with no variables declared accessing top scope' do
     let(:code) { "
       define foo() {
         $bar = $fqdn
       }"
     }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "top-scope variable being used without an explicit namespace",
-        :linenumber => 3,
-        :column     => 16,
-      })
-      should_not have_problem :kind => :error
-    }
+    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)
+    end
   end
 
-  describe 'defined type with no variables declared accessing top scope explicitly' do
+  context 'defined type with no variables declared accessing top scope explicitly' do
     let(:code) { "
       define foo() {
         $bar = $::fqdn
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe '$name should be auto defined' do
+  context '$name should be auto defined' do
     let(:code) { "
       define foo() {
         $bar = $name
@@ -88,6 +94,44 @@ describe 'variable_scope' do
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'define with required parameter' do
+    let(:code) { "
+      define tomcat::base (
+          $max_perm_gen,
+          $owner = hiera('app_user'),
+          $system_properties = {},
+      ) {  }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'future parser blocks' do
+    let(:code) { "
+      class foo() {
+        $foo = [1,2]
+        $foo.each |$a, $b| {
+          $a
+          $c
+        }
+        $b
+      }
+    " }
+
+    it 'should only detect a single problem' 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)
+    end
   end
 end

data/spec/puppet-lint/plugins/check_comments/slash_comments_spec.rb

@@ -1,20 +1,23 @@
 require 'spec_helper'
 
 describe 'slash_comments' do
-  describe 'slash comments' do
-    let(:code) { "// foo" }
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => '// comment found',
-        :linenumber => 1,
-        :column     => 1,
-      })
+  let(:msg) { '// comment found' }
+
+  context 'with fix disabled' do
+    context 'slash comments' do
+      let(:code) { "// foo" }
+
+      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(1).in_column(1)
+      end
     end
   end
 
-  describe 'slash comments w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -23,16 +26,20 @@ describe 'slash_comments' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { '// foo' }
+    context 'slash comments' do
+      let(:code) { '// foo' }
+
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(1)
+      end
 
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => '// comment found',
-        :linenumber => 1,
-        :column     => 1,
-      })
+      it 'should replace the double slash with a hash' do
+        expect(manifest).to eq("# foo")
+      end
     end
-    its(:manifest) { should == '# foo' }
   end
 end

data/spec/puppet-lint/plugins/check_comments/star_comments_spec.rb

@@ -1,19 +1,84 @@
 require 'spec_helper'
 
 describe 'star_comments' do
-  describe 'slash asterisk comment' do
-    let(:code) { "
-      /* foo
-      */
-    "}
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => '/* */ comment found',
-        :linenumber => 2,
-        :column     => 7,
-      })
+  let(:msg) { '/* */ comment found' }
+
+  context 'with fix disabled' do
+    context 'multiline comment w/ one line of content' do
+      let(:code) { "
+        /* foo
+        */
+      "}
+
+      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(2).in_column(9)
+      end
+    end
+  end
+
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'multiline comment w/ one line of content' do
+      let(:code) { "
+        /* foo
+        */
+      "}
+
+      let(:fixed) { "
+        # foo
+      "}
+
+      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(2).in_column(9)
+      end
+
+      it 'should convert the multiline comment' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'multiline comment w/ multiple line of content' do
+      let(:code) { "
+        /* foo
+         * bar
+         * baz
+         */
+        notify { 'foo': }
+      "}
+
+      let(:fixed) { "
+        # foo
+        # bar
+        # baz
+        notify { 'foo': }
+      "}
+
+      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(2).in_column(9)
+      end
+
+      it 'should convert the multiline comment' do
+        expect(manifest).to eq(fixed)
+      end
     end
   end
 end

data/spec/puppet-lint/plugins/check_conditionals/case_without_default_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'case_without_default' do
-  describe 'case statement with a default case' do
+  let(:msg) { 'case statement without a default case' }
+
+  context 'case statement with a default case' do
     let(:code) { "
       case $foo {
         bar: { }
@@ -9,10 +11,12 @@ describe 'case_without_default' do
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'case statement without a default case' do
+  context 'case statement without a default case' do
     let(:code) { "
       case $foo {
         bar: { }
@@ -20,17 +24,16 @@ describe 'case_without_default' do
       }"
     }
 
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'case statement without a default case',
-        :linenumber => 2,
-        :column     => 7,
-      })
+    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(2).in_column(7)
     end
   end
 
-  describe 'issue-117' do
+  context 'issue-117' do
     let(:code) { "
       $mem = inline_template('<%
         mem,unit = scope.lookupvar(\'::memorysize\').split
@@ -46,6 +49,8 @@ describe 'case_without_default' do
         %><%= mem.to_i %>')
     "}
 
-    its(:problems) { should == [] }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 end

data/spec/puppet-lint/plugins/check_conditionals/selector_inside_resource_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'selector_inside_resource' do
-  describe 'resource with a selector' do
+  let(:msg) { 'selector inside resource block' }
+
+  context 'resource with a selector' do
     let(:code) { "
       file { 'foo':
         ensure => $bar ? {
@@ -11,23 +13,24 @@ describe 'selector_inside_resource' do
       }"
     }
 
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'selector inside resource block',
-        :linenumber => 3,
-        :column     => 16,
-      })
+    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)
     end
   end
 
-  describe 'resource with a variable as a attr value' do
+  context 'resource with a variable as a attr value' do
     let(:code) { "
       file { 'foo',
         ensure => $bar,
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 end