puppet-lint 0.4.0.pre1 → 1.0.0

data/spec/puppet-lint/plugins/check_documentation/documentation_spec.rb

@@ -1,16 +1,18 @@
 require 'spec_helper'
 
 describe 'documentation' do
+  let(:class_msg) { 'class not documented' }
+  let(:define_msg) { 'defined type not documented' }
+
   describe 'undocumented class' do
     let(:code) { "class test {}" }
 
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'class not documented',
-        :linenumber => 1,
-        :column     => 1,
-      })
+    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(1).in_column(1)
     end
   end
 
@@ -20,19 +22,20 @@ describe 'documentation' do
       class test {}
     "}
 
-    its(:problems) { should == [] }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
   describe 'undocumented defined type' do
     let(:code) { "define test {}" }
 
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'defined type not documented',
-        :linenumber => 1,
-        :column     => 1,
-      })
+    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(define_msg).on_line(1).in_column(1)
     end
   end
 
@@ -42,6 +45,8 @@ describe 'documentation' do
       define test {}
     "}
 
-    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_nodes/unquoted_node_name_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe 'unquoted_node_name' do
+  let(:msg) { 'unquoted node name found' }
+
+  context 'with fix disabled' do
+    context 'unquoted node name' do
+      let(:code) { "node 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(6)
+      end
+    end
+
+    context 'default node' do
+      let(:code) { "node default { }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'single quoted node name' do
+      let(:code) { "node 'foo' { }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'regex node name' do
+      let(:code) { "node /foo/ { }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+  end
+
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'unquoted node name' do
+      let(:code) { "node 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(6)
+      end
+
+      it 'should quote the node name' do
+        expect(manifest).to eq("node 'foo' { }")
+      end
+    end
+  end
+end

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

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'duplicate_params' do
-  describe 'resource with duplicate parameters' do
+  let(:msg) { 'duplicate parameter found in resource' }
+
+  context 'resource with duplicate parameters' do
     let(:code) { "
       file { '/tmp/foo':
         ensure => present,
@@ -11,17 +13,17 @@ describe 'duplicate_params' do
       }"
     }
 
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :error,
-        :message    => 'duplicate parameter found in resource',
-        :linenumber => 6,
-        :column     => 9,
-      })
-    }
+    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)
+    end
   end
-  describe 'bug #145: resource with a hash and no duplicate parameters' do
-    let (:code) { "
+
+  context 'bug #145: resource with a hash and no duplicate parameters' do
+    let(:code) { "
       class {'fooname':
         hashes => [
           { foo => 'bar01',},
@@ -29,13 +31,14 @@ describe 'duplicate_params' do
         ],
       }"
     }
-    its (:problems) {
-      should be_empty
-    }
+
+    it 'should not detect any errors' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'bug #145: resource with a hash and duplicate parameters in subhash' do
-    let (:code) { "
+  context 'bug #145: resource with a hash and duplicate parameters in subhash' do
+    let(:code) { "
       class {'fooname':
         hashes => [
           { foo => 'bar01',
@@ -43,18 +46,18 @@ describe 'duplicate_params' do
         ],
       }"
     }
-    its (:problems) {
-      should only_have_problem({
-        :kind       => :error,
-        :message    => 'duplicate parameter found in resource',
-        :linenumber => 5,
-        :column     => 13,
-      })
-    }
+
+    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)
+    end
   end
 
-  describe 'bug #145: resource with a hash and duplicate parameters in parent type' do
-    let (:code) { "
+  context 'bug #145: resource with a hash and duplicate parameters in parent type' do
+    let(:code) { "
       class {'fooname':
         hashes    => [
           { foo     => 'bar01', },
@@ -64,25 +67,26 @@ describe 'duplicate_params' do
         hashes    => 'dupe',
       }"
     }
-    its (:problems) {
-      should only_have_problem({
-        :kind       => :error,
-        :message    => 'duplicate parameter found in resource',
-        :linenumber => 8,
-        :column     => 9,
-      })
-    }
+
+    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)
+    end
   end
+
   describe 'bug #145: more hash tests and no duplicate parameters' do
-    let (:code) { "
+    let(:code) { "
       class test {
         $foo = { param => 'value', }
         $bar = { param => 'bar', }
       }"
     }
-    its (:problems) {
-      should be_empty
-    }
 
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 end

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

@@ -1,23 +1,29 @@
 require 'spec_helper'
 
 describe 'ensure_first_param' do
-  describe 'ensure as only attr in a single line resource' do
+  let(:msg) { "ensure found on line but it's not the first attribute" }
+
+  context 'ensure as only attr in a single line resource' do
     let(:code) { "file { 'foo': ensure => present }" }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'ensure as only attr in a multi line resource' do
+  context 'ensure as only attr in a multi line resource' do
     let(:code) { "
       file { 'foo':
         ensure => present,
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'ensure as second attr in a multi line resource' do
+  context 'ensure as second attr in a multi line resource' do
     let(:code) { "
       file { 'foo':
         mode   => '0000',
@@ -25,12 +31,16 @@ describe 'ensure_first_param' do
       }"
     }
 
-    its(:problems) {
-      should only_have_problem :kind => :warning, :message => "ensure found on line but it's not the first attribute", :linenumber => 4
-    }
+    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(9)
+    end
   end
 
-  describe 'ensure as first attr in a multi line resource' do
+  context 'ensure as first attr in a multi line resource' do
     let(:code) { "
       file { 'foo':
         ensure => present,
@@ -38,6 +48,8 @@ describe 'ensure_first_param' do
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 end

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

@@ -1,26 +1,89 @@
 require 'spec_helper'
 
 describe 'ensure_not_symlink_target' do
-  describe 'file resource creating a symlink with seperate target attr' do
-    let(:code) { "
-      file { 'foo':
-        ensure => link,
-        target => '/foo/bar',
-      }"
-    }
-
-    its(:problems) { should be_empty }
+  let(:msg) { 'symlink target specified in ensure attr' }
+
+  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',
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'file resource creating a symlink with target specified in ensure' do
+      let(:code) { "
+        file { 'foo':
+          ensure => '/foo/bar',
+        }"
+      }
+
+      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)
+      end
+    end
   end
 
-  describe 'file resource creating a symlink with target specified in ensure' do
-    let(:code) { "
-      file { 'foo':
-        ensure => '/foo/bar',
-      }"
-    }
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    context 'file resource creating a symlink with seperate target attr' do
+      let(:code) { "
+        file { 'foo':
+          ensure => link,
+          target => '/foo/bar',
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    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',
+        }"
+      }
+
+      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)
+      end
 
-    its(:problems) {
-      should only_have_problem :kind => :warning, :message => "symlink target specified in ensure attr", :linenumber => 3
-    }
+      it 'should create a new target param' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

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

@@ -1,110 +1,75 @@
 require 'spec_helper'
 
 describe 'file_mode' do
-  describe '3 digit file mode' do
-    let(:code) { "file { 'foo': mode => '777' }" }
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => "mode should be represented as a 4 digit octal value or symbolic mode",
-        :linenumber => 1,
-        :column     => 23,
-      })
-    end
-  end
+  let(:msg) { 'mode should be represented as a 4 digit octal value or symbolic mode' }
 
-  describe '3 digit file mode w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
-    end
+  context 'with fix disabled' do
+    context '3 digit file mode' do
+      let(:code) { "file { 'foo': mode => '777' }" }
 
-    after do
-      PuppetLint.configuration.fix = false
-    end
-
-    let(:code) { "file { 'foo': mode => '777' }" }
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    its(:manifest) { should == "file { 'foo': mode => '0777' }" }
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => 'mode should be represented as a 4 digit octal value or symbolic mode',
-        :linenumber => 1,
-      })
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(23)
+      end
     end
-  end
 
-  describe '4 digit file mode' do
-    let(:code) { "file { 'foo': mode => '0777' }" }
+    context '4 digit file mode' do
+      let(:code) { "file { 'foo': mode => '0777' }" }
 
-    its(:problems) { should be_empty }
-  end
-
-  describe '4 digit file mode w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
-    end
-
-    after do
-      PuppetLint.configuration.fix = false
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
 
-    let(:code) { "file { 'foo': mode => '0777' }" }
-
-    its(:problems) { should be_empty }
-    its(:manifest) { should == "file { 'foo': mode => '0777' }" }
-  end
-
-  describe 'file mode as a variable' do
-    let(:code) { "file { 'foo': mode => $file_mode }" }
-
-    its(:problems) { should be_empty }
-  end
+    context 'file mode as a variable' do
+      let(:code) { "file { 'foo': mode => $file_mode }" }
 
-  describe 'file mode as a variable w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
 
-    after do
-      PuppetLint.configuration.fix = false
-    end
-
-    let(:code) { "file { 'foo': mode => $file_mode }" }
-
-    its(:problems) { should be_empty }
-    its(:manifest) { should == "file { 'foo': mode => $file_mode }" }
-  end
+    context 'symbolic file mode' do
+      let(:code) { "file { 'foo': mode => 'u=rw,og=r' }" }
 
-  describe 'symbolic file mode' do
-    let(:code) { "file { 'foo': mode => 'u=rw,og=r' }" }
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-    its(:problems) { should be_empty }
-  end
+    context 'file mode undef unquoted' do
+      let(:code) { "file { 'foo': mode => undef }" }
 
-  describe 'symbolic file mode w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
 
-    after do
-      PuppetLint.configuration.fix = false
-    end
+    context 'file mode undef quoted' do
+      let(:code) { "file { 'foo': mode => 'undef' }" }
 
-    let(:code) { "file { 'foo': mode => 'u=rw,og=r' }" }
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    its(:problems) { should be_empty }
-    its(:manifest) { should == "file { 'foo': mode => 'u=rw,og=r' }" }
-  end
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(23)
+      end
+    end
 
-  describe 'file mode undef unquoted' do
-    let(:code) { "file { 'foo': mode => undef }" }
+    context 'mode as audit value' do
+      let(:code) { "file { '/etc/passwd': audit => [ owner, mode ], }" }
 
-    its(:problems) { should be_empty }
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
   end
 
-  describe 'file mode undef unquoted w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -113,44 +78,36 @@ describe 'file_mode' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { "file { 'foo': mode => undef }" }
+    context '3 digit file mode' do
+      let(:code) { "file { 'foo': mode => '777' }" }
 
-    its(:problems) { should be_empty }
-    its(:manifest) { should == "file { 'foo': mode => undef }" }
-  end
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-  describe 'file mode undef quoted' do
-    let(:code) { "file { 'foo': mode => 'undef' }" }
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(23)
+      end
 
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => "mode should be represented as a 4 digit octal value or symbolic mode",
-        :linenumber => 1,
-        :column     => 23,
-      })
+      it 'should zero pad the file mode' do
+        expect(manifest).to eq("file { 'foo': mode => '0777' }")
+      end
     end
-  end
 
-  describe 'file mode undef quoted' do
-    before do
-      PuppetLint.configuration.fix = true
-    end
+    context 'file mode undef quoted' do
+      let(:code) { "file { 'foo': mode => 'undef' }" }
 
-    after do
-      PuppetLint.configuration.fix = false
-    end
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    let(:code) { "file { 'foo': mode => 'undef' }" }
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(23)
+      end
 
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => "mode should be represented as a 4 digit octal value or symbolic mode",
-        :linenumber => 1,
-        :column     => 23,
-      })
+      it 'should not modify the original manifest' do
+        expect(manifest).to eq(code)
+      end
     end
-    its(:manifest) { should == "file { 'foo': mode => 'undef' }" }
   end
 end