puppet-lint 0.4.0.pre1 → 1.0.0

data/spec/puppet-lint/plugins/check_variables/variable_contains_dash_spec.rb

@@ -1,25 +1,37 @@
 require 'spec_helper'
 
 describe 'variable_contains_dash' do
-  describe 'a variable containing a dash' do
+  let(:msg) { 'variable contains a dash' }
+
+  context 'a variable containing a dash' do
     let(:code) { '$foo-bar' }
 
-    its(:problems) { should have_problem({
-      :kind       => :warning,
-      :message    => 'variable contains a dash',
-      :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(msg).on_line(1).in_column(1)
+    end
   end
 
-  describe 'variable containing a dash' do
+  context 'variable containing a dash' do
     let(:code) { '" $foo-bar"' }
 
-    its(:problems) { should have_problem({
-      :kind       => :warning,
-      :message    => 'variable contains a dash',
-      :linenumber => 1,
-      :column     => 3,
-    }) }
+    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(3)
+    end
+  end
+
+  context 'variable with an array reference containing a dash' do
+    let(:code) { "$foo[bar-baz]" }
+
+    it 'should not detect any problems' do
+      expect(problems).to be_empty
+    end
   end
 end

data/spec/puppet-lint/plugins/check_whitespace/2sp_soft_tabs_spec.rb

@@ -1,20 +1,21 @@
 require 'spec_helper'
 
 describe '2sp_soft_tabs' do
-  describe 'line indented by 3 spaces' do
+  let(:msg) { 'two-space soft tabs not used' }
+
+  context 'when a line is indented by 3 spaces' do
     let(:code) { "
       file { 'foo':
          foo => bar,
       }"
     }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :error,
-        :message    => 'two-space soft tabs not used',
-        :linenumber => 3,
-        :column     => 1,
-      })
-    }
+    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(3).in_column(1)
+    end
   end
 end

data/spec/puppet-lint/plugins/check_whitespace/80chars_spec.rb

@@ -2,37 +2,53 @@
 require 'spec_helper'
 
 describe '80chars' do
-  describe 'file resource with a source line > 80c' do
+  let(:msg) { 'line has more than 80 characters' }
+
+  context 'file resource with a source line > 80c' do
     let(:code) { "
       file {
         source  => 'puppet:///modules/certificates/etc/ssl/private/wildcard.example.com.crt',
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'file resource with a template line > 80c' do
+    let(:code) { "
+      file {
+        content => template('mymodule/this/is/a/truely/absurdly/long/path/that/should/make/you/feel/bad'),
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'length of lines with UTF-8 characters' do
+  context 'length of lines with UTF-8 characters' do
     let(:code) { "
       # ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
       # ┃          Configuration           ┃
       # ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
     }
-    its(:problems) {
-      should be_empty
-    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe '81 character line' do
+  context '81 character line' do
     let(:code) { 'a' * 81 }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'line has more than 80 characters',
-        :linenumber => 1,
-        :column     => 80,
-      })
-    }
+    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(80)
+    end
   end
 end

data/spec/puppet-lint/plugins/check_whitespace/arrow_alignment_spec.rb

@@ -1,304 +1,244 @@
 require 'spec_helper'
 
 describe 'arrow_alignment' do
-  describe 'selectors inside a resource' do
-    let(:code) { "
-      file { 'foo':
-        ensure  => $ensure,
-        require => $ensure ? {
-          present => Class['tomcat::install'],
-          absent  => undef;
-        },
-        foo     => bar,
-      }"
-    }
+  let(:msg) { 'indentation of => is not properly aligned' }
+
+  context 'with fix disabled' do
+    context 'selectors inside a resource' do
+      let(:code) { "
+        file { 'foo':
+          ensure  => $ensure,
+          require => $ensure ? {
+            present => Class['tomcat::install'],
+            absent  => undef;
+          },
+          foo     => bar,
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-    its(:problems) { should be_empty }
-  end
+    context 'selectors in the middle of a resource' do
+      let(:code) { "
+        file { 'foo':
+          ensure => $ensure ? {
+            present => directory,
+            absent  => undef,
+          },
+          owner  => 'tomcat6',
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-  describe 'selectors in the middle of a resource' do
-    let(:code) { "
-      file { 'foo':
-        ensure => $ensure ? {
+    context 'selector inside a resource' do
+      let(:code) { "
+      ensure => $ensure ? {
+        present => directory,
+        absent  => undef,
+      },
+      owner  => 'foo4',
+      group  => 'foo4',
+      mode   => '0755'," }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'selector inside a hash inside a resource' do
+      let(:code) { "
+      server => {
+        ensure => ensure => $ensure ? {
           present => directory,
           absent  => undef,
         },
-        owner  => 'tomcat6',
-      }"
-    }
-
-    its(:problems) { should be_empty }
-  end
-
-  describe 'selector inside a resource' do
-    let(:code) { "
-    ensure => $ensure ? {
-      present => directory,
-      absent  => undef,
-    },
-    owner  => 'foo4',
-    group  => 'foo4',
-    mode   => '0755'," }
-
-    its(:problems) { should be_empty }
-  end
-
-  describe 'selector inside a hash inside a resource' do
-    let(:code) { "
-    server => {
-      ensure => ensure => $ensure ? {
-        present => directory,
-        absent  => undef,
+        ip     => '192.168.1.1'
       },
-      ip     => '192.168.1.1'
-    },
-    owner  => 'foo4',
-    group  => 'foo4',
-    mode   => '0755'," }
+      owner  => 'foo4',
+      group  => 'foo4',
+      mode   => '0755'," }
 
-    its(:problems) { should be_empty }
-  end
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-  describe 'issue #37' do
-    let(:code) { "
-      class { 'lvs::base':
-        virtualeservers => {
-          '192.168.2.13' => {
-            vport           => '11025',
-            service         => 'smtp',
-            scheduler       => 'wlc',
-            protocol        => 'tcp',
-            checktype       => 'external',
-            checkcommand    => '/path/to/checkscript',
-            real_servers    => {
-              'server01' => {
-                real_server => '192.168.2.14',
-                real_port   => '25',
-                forwarding  => 'masq',
-              },
-              'server02' => {
-                real_server => '192.168.2.15',
-                real_port   => '25',
-                forwarding  => 'masq',
+    context 'nested hashes with correct indentation' do
+      let(:code) { "
+        class { 'lvs::base':
+          virtualeservers => {
+            '192.168.2.13' => {
+              vport        => '11025',
+              service      => 'smtp',
+              scheduler    => 'wlc',
+              protocol     => 'tcp',
+              checktype    => 'external',
+              checkcommand => '/path/to/checkscript',
+              real_servers => {
+                'server01' => {
+                  real_server => '192.168.2.14',
+                  real_port   => '25',
+                  forwarding  => 'masq',
+                },
+                'server02' => {
+                  real_server => '192.168.2.15',
+                  real_port   => '25',
+                  forwarding  => 'masq',
+                }
               }
             }
           }
-        }
-      }"
-    }
+        }"
+      }
 
-    its(:problems) { should be_empty }
-  end
-
-  describe 'single resource with a misaligned =>' do
-    let(:code) { "
-      file { '/tmp/foo':
-        foo => 1,
-        bar => 2,
-        gronk => 3,
-        baz  => 4,
-        meh => 5,
-      }"
-    }
-
-    its(:problems) do
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 3,
-        :column     => 13,
-      })
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 4,
-        :column     => 13,
-      })
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 6,
-        :column     => 14,
-      })
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 7,
-        :column     => 13,
-      })
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  describe 'single resource with a misaligned => w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
+    context 'single resource with a misaligned =>' do
+      let(:code) { "
+        file { '/tmp/foo':
+          foo => 1,
+          bar => 2,
+          gronk => 3,
+          baz  => 4,
+          meh => 5,
+        }"
+      }
+
+      it 'should detect four problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should create four warnings' do
+        expect(problems).to contain_warning(msg).on_line(3).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(4).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(6).in_column(16)
+        expect(problems).to contain_warning(msg).on_line(7).in_column(15)
+      end
     end
 
-    after do
-      PuppetLint.configuration.fix = false
+    context 'complex resource with a misaligned =>' do
+      let(:code) { "
+        file { '/tmp/foo':
+          foo => 1,
+          bar  => $baz ? {
+            gronk => 2,
+            meh => 3,
+          },
+          meep => 4,
+          bah => 5,
+        }"
+      }
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create three warnings' do
+        expect(problems).to contain_warning(msg).on_line(3).in_column(15)
+        expect(problems).to contain_warning(msg).on_line(6).in_column(17)
+        expect(problems).to contain_warning(msg).on_line(9).in_column(15)
+      end
     end
 
-    let(:code) { "
-      file { '/tmp/foo':
-        foo => 1,
-        bar => 2,
-        gronk => 3,
-        baz  => 4,
-        meh => 5,
-      }"
-    }
-
-    its(:problems) do
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 3,
-        :column     => 13,
-      })
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 4,
-        :column     => 13,
-      })
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 6,
-        :column     => 14,
-      })
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 7,
-        :column     => 13,
-      })
+    context 'multi-resource with a misaligned =>' do
+      let(:code) { "
+        file {
+          '/tmp/foo': ;
+          '/tmp/bar':
+            foo => 'bar';
+          '/tmp/baz':
+            gronk => 'bah',
+            meh => 'no'
+        }"
+      }
+
+      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(8).in_column(17)
+      end
     end
 
-    its(:manifest) { should == "
-      file { '/tmp/foo':
-        foo   => 1,
-        bar   => 2,
-        gronk => 3,
-        baz   => 4,
-        meh   => 5,
-      }"
-    }
-  end
+    context 'multiple single line resources' do
+      let(:code) { "
+        file { 'foo': ensure => file }
+        package { 'bar': ensure => present }"
+      }
 
-  describe 'complex resource with a misaligned =>' do
-    let(:code) { "
-      file { '/tmp/foo':
-        foo => 1,
-        bar  => $baz ? {
-          gronk => 2,
-          meh => 3,
-        },
-        meep => 4,
-        bah => 5,
-      }"
-    }
-
-    its(:problems) do
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 3,
-        :column     => 13,
-      })
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 6,
-        :column     => 15,
-      })
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 9,
-        :column     => 13,
-      })
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
-  end
 
-  describe 'complex resource with a misaligned => w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
+    context 'resource with unaligned => in commented line' do
+      let(:code) { "
+        file { 'foo':
+          ensure => directory,
+          # purge => true,
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
 
-    after do
-      PuppetLint.configuration.fix = false
-    end
+    context 'single line resource spread out on multiple lines' do
+      let(:code) {"
+        file {
+          'foo': ensure => present,
+        }"
+      }
 
-    let(:code) { "
-      file { '/tmp/foo':
-        foo => 1,
-        bar  => $baz ? {
-          gronk => 2,
-          meh => 3,
-        },
-        meep => 4,
-        bah => 5,
-      }"
-    }
-
-    its(:problems) do
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 3,
-        :column     => 13,
-      })
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 6,
-        :column     => 15,
-      })
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 9,
-        :column     => 13,
-      })
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
 
-    its(:manifest) { should == "
-      file { '/tmp/foo':
-        foo  => 1,
-        bar  => $baz ? {
-          gronk => 2,
-          meh   => 3,
-        },
-        meep => 4,
-        bah  => 5,
-      }"
-    }
-  end
+    context 'multiline resource with a single line of params' do
+      let(:code) { "
+        mymodule::do_thing { 'some thing':
+          whatever => { foo => 'bar', one => 'two' },
+        }"
+      }
 
-  describe 'multi-resource with a misaligned =>' do
-    let(:code) { "
-      file {
-        '/tmp/foo': ;
-        '/tmp/bar':
-          foo => 'bar';
-        '/tmp/baz':
-          gronk => 'bah',
-          meh => 'no'
-      }"
-    }
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 8,
-        :column     => 15,
-      })
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'resource with aligned => too far out' do
+      let(:code) { "
+        file { '/tmp/foo':
+          ensure  => file,
+          mode    => '0444',
+        }"
+      }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create 2 warnings' do
+        expect(problems).to contain_warning(msg).on_line(3).in_column(19)
+        expect(problems).to contain_warning(msg).on_line(4).in_column(19)
+      end
     end
   end
 
-  describe 'multi-resource with a misaligned => w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -307,65 +247,143 @@ describe 'arrow_alignment' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { "
-      file {
-        '/tmp/foo': ;
-        '/tmp/bar':
-          foo => 'bar';
-        '/tmp/baz':
-          gronk => 'bah',
-          meh => 'no'
-      }"
-    }
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => 'indentation of => is not properly aligned',
-        :linenumber => 8,
-        :column     => 15,
-      })
+    context 'single resource with a misaligned =>' do
+      let(:code) { "
+        file { '/tmp/foo':
+          foo => 1,
+          bar => 2,
+          gronk => 3,
+          baz  => 4,
+          meh => 5,
+        }"
+      }
+      let(:fixed) { "
+        file { '/tmp/foo':
+          foo   => 1,
+          bar   => 2,
+          gronk => 3,
+          baz   => 4,
+          meh   => 5,
+        }"
+      }
+
+      it 'should detect four problems' do
+        expect(problems).to have(4).problems
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(4).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(6).in_column(16)
+        expect(problems).to contain_fixed(msg).on_line(7).in_column(15)
+      end
+
+      it 'should align the arrows' do
+        expect(manifest).to eq(fixed)
+      end
     end
 
-    its(:manifest) { should == "
-      file {
-        '/tmp/foo': ;
-        '/tmp/bar':
-          foo => 'bar';
-        '/tmp/baz':
-          gronk => 'bah',
-          meh   => 'no'
-      }"
-    }
-  end
-
-  describe 'multiple single line resources' do
-    let(:code) { "
-      file { 'foo': ensure => file }
-      package { 'bar': ensure => present }"
-    }
-
-    its(:problems) { should be_empty }
-  end
-
-  describe 'resource with unaligned => in commented line' do
-    let(:code) { "
-      file { 'foo':
-        ensure => directory,
-        # purge => true,
-      }"
-    }
-
-    its(:problems) { should be_empty }
-  end
+    context 'complex resource with a misaligned =>' do
+      let(:code) { "
+        file { '/tmp/foo':
+          foo => 1,
+          bar  => $baz ? {
+            gronk => 2,
+            meh => 3,
+          },
+          meep => 4,
+          bah => 5,
+        }"
+      }
+      let(:fixed) { "
+        file { '/tmp/foo':
+          foo  => 1,
+          bar  => $baz ? {
+            gronk => 2,
+            meh   => 3,
+          },
+          meep => 4,
+          bah  => 5,
+        }"
+      }
+
+      it 'should detect three problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(15)
+        expect(problems).to contain_fixed(msg).on_line(6).in_column(17)
+        expect(problems).to contain_fixed(msg).on_line(9).in_column(15)
+      end
+
+      it 'should align the arrows' do
+        expect(manifest).to eq(fixed)
+      end
+    end
 
-  describe 'single line resource spread out on multiple lines' do
-    let(:code) {"
-      file {
-        'foo': ensure => present,
-      }"
-    }
+    context 'multi-resource with a misaligned =>' do
+      let(:code) { "
+        file {
+          '/tmp/foo': ;
+          '/tmp/bar':
+            foo => 'bar';
+          '/tmp/baz':
+            gronk => 'bah',
+            meh => 'no'
+        }"
+      }
+      let(:fixed) { "
+        file {
+          '/tmp/foo': ;
+          '/tmp/bar':
+            foo => 'bar';
+          '/tmp/baz':
+            gronk => 'bah',
+            meh   => 'no'
+        }"
+      }
+
+      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(8).in_column(17)
+      end
+
+      it 'should align the arrows' do
+        expect(manifest).to eq(fixed)
+      end
+    end
 
-    its(:problems) { should == [] }
+    context 'resource with aligned => too far out' do
+      let(:code) { "
+        file { '/tmp/foo':
+          ensure  => file,
+          mode    => '0444',
+        }"
+      }
+
+      let(:fixed) { "
+        file { '/tmp/foo':
+          ensure => file,
+          mode   => '0444',
+        }"
+      }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should create 2 warnings' do
+        expect(problems).to contain_fixed(msg).on_line(3).in_column(19)
+        expect(problems).to contain_fixed(msg).on_line(4).in_column(19)
+      end
+
+      it 'should realign the arrows with the minimum whitespace' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end