puppet-lint 0.4.0.pre1 → 1.0.0

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

@@ -1,42 +1,48 @@
 require 'spec_helper'
 
 describe 'autoloader_layout' do
-  describe 'foo::bar in foo/manifests/bar.pp' do
+  context 'foo::bar in foo/manifests/bar.pp' do
     let(:code) { "class foo::bar { }" }
-    let(:fullpath) { '/etc/puppet/modules/foo/manifests/bar.pp' }
+    let(:path) { 'foo/manifests/bar.pp' }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'foo::bar::baz in foo/manifests/bar/baz.pp' do
+  context 'foo::bar::baz in foo/manifests/bar/baz.pp' do
     let(:code) { 'define foo::bar::baz() { }' }
-    let(:fullpath) { '/etc/puppet/modules/foo/manifests/bar/baz.pp' }
+    let(:path) { 'foo/manifests/bar/baz.pp' }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'foo in foo/manifests/init.pp' do
+  context 'foo in foo/manifests/init.pp' do
     let(:code) { 'class foo { }' }
-    let(:fullpath) { '/etc/puppet/modules/foo/manifests/init.pp' }
+    let(:path) { 'foo/manifests/init.pp' }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'foo::bar in foo/manifests/init.pp' do
+  context 'foo::bar in foo/manifests/init.pp' do
     let(:code) { 'class foo::bar { }' }
-    let(:fullpath) { '/etc/puppet/modules/foo/manifests/init.pp' }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :error,
-        :message    => "foo::bar not in autoload module layout",
-        :linenumber => 1,
-        :column     => 7,
-      })
-    }
+    let(:path) { 'foo/manifests/init.pp' }
+    let(:msg) { 'foo::bar not in autoload module layout' }
+
+    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(1).in_column(7)
+    end
   end
 
-  describe 'foo included in bar/manifests/init.pp' do
+  context 'foo included in bar/manifests/init.pp' do
     let(:code) { "
       class bar {
         class {'foo':
@@ -45,7 +51,55 @@ describe 'autoloader_layout' do
       }
       "
     }
-    let(:fullpath) { '/etc/puppet/modules/bar/manifests/init.pp' }
-    its(:problems) { should be_empty }
+    let(:path) { 'bar/manifests/init.pp' }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'foo in puppet-foo/manifests/init.pp' do
+    let(:code) { 'class foo { }' }
+    let(:path) { 'puppet-foo/manifests/init.pp' }
+
+    it 'should detect a single problem' do
+      expect(problems).to have(1).problems
+    end
+  end
+
+  context 'foo in puppet-foo/manifests/bar.pp with relative option' do
+    before do
+      PuppetLint.configuration.relative = true
+    end
+
+    after do
+      PuppetLint.configuration.relative = false
+    end
+
+    let(:code) { 'class foo { }' }
+    let(:path) { 'puppet-foo/manifests/bar.pp' }
+
+    it 'should detect a single problem' do
+      expect(problems).to have(1).problems
+    end
   end
+
+  context 'foo in puppet-foo/manifests/init.pp with relative option' do
+    before do
+      PuppetLint.configuration.relative = true
+    end
+
+    after do
+      PuppetLint.configuration.relative = false
+    end
+
+    let(:code) { 'class foo { }' }
+    let(:path) { 'puppet-foo/manifests/init.pp' }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+
 end

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

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
 describe 'class_inherits_from_params_class' do
-  describe 'parameterised class that inherits from a 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 { }"
     }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "class inheriting from params class",
-        :linenumber => 3,
-        :column     => 40,
-      })
-      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(40)
+    end
   end
 
-  describe 'class without parameters' do
+  context 'class without parameters' do
     let(:code) {"
       class myclass {
 
@@ -28,6 +28,8 @@ describe 'class_inherits_from_params_class' do
       }
     "}
 
-    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_classes/inherits_across_namespaces_spec.rb

@@ -1,29 +1,33 @@
 require 'spec_helper'
 
 describe 'inherits_across_namespaces' do
-  describe 'class inheriting from parent in same module namespace' 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 { }" }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'class inheriting from sister in same module namespace' do
+  context 'class inheriting from sister in same module namespace' do
     let(:code) { "class foo::bar inherits foo::baz { }" }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'class inheriting from another module namespace' do
+  context 'class inheriting from another module namespace' do
     let(:code) { "class foo::bar inherits baz { }" }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "class inherits across module namespaces",
-        :linenumber => 1,
-        :column     => 25,
-      })
-      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(25)
+    end
   end
 end

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

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
 describe 'names_containing_dash' do
-  describe 'module named foo-bar' do
+  let(:class_msg) { 'class name containing a dash' }
+  let(:define_msg) { 'defined type name containing a dash' }
+
+  context 'module named foo-bar' do
     let(:code) { 'class foo-bar { }' }
-    let(:fullpath) { '/etc/puppet/modules/foo-bar/manifests/init.pp' }
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'class name containing a dash',
-        :linenumber => 1,
-        :column     => 7,
-      })
+    let(:path) { 'foo-bar/manifests/init.pp' }
+
+    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(7)
     end
   end
 
-  describe 'define named foo-bar' do
+  context 'define named foo-bar' do
     let(:code) { 'define foo::foo-bar { }' }
-    let(:fullpath) { '/etc/puppet/modules/foo/manifests/foo-bar.pp' }
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'defined type name containing a dash',
-        :linenumber => 1,
-        :column     => 8,
-      })
+    let(:path) { 'foo/manifests/foo-bar.pp' }
+
+    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(8)
     end
   end
 
-  describe 'class named bar-foo' do
+  context 'class named bar-foo' do
     let(:code) { 'class foo::bar-foo { }' }
-    let(:fullpath) { '/etc/puppet/modules/foo/manifests/bar-foo.pp' }
-
-    its(:problems) do
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'class name containing a dash',
-        :linenumber => 1,
-        :column     => 7,
-      })
+    let(:path) { 'foo/manifests/bar-foo.pp' }
+
+    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(7)
     end
   end
 end

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

@@ -1,13 +1,18 @@
 require 'spec_helper'
 
 describe 'nested_classes_or_defines' do
-  describe 'class on its own' do
+  let(:class_msg) { 'class defined inside a class' }
+  let(:define_msg) { 'defined type defined inside a class' }
+
+  context 'class on its own' do
     let(:code) { "class foo { }" }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'class inside a class' do
+  context 'class inside a class' do
     let(:code) { "
       class foo {
         class bar {
@@ -15,18 +20,16 @@ describe 'nested_classes_or_defines' do
       }"
     }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "class defined inside a class",
-        :linenumber => 3,
-        :column     => 9,
-      })
-      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(class_msg).on_line(3).in_column(9)
+    end
   end
 
-  describe 'instantiating a parametised class inside a class' do
+  context 'instantiating a parametised class inside a class' do
     let(:code) { "
       class bar {
         class { 'foo':
@@ -35,10 +38,12 @@ describe 'nested_classes_or_defines' do
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'instantiating a parametised class inside a define' do
+  context 'instantiating a parametised class inside a define' do
     let(:code) { "
       define bar() {
         class { 'foo':
@@ -47,10 +52,12 @@ describe 'nested_classes_or_defines' do
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'define inside a class' do
+  context 'define inside a class' do
     let(:code) { "
       class foo {
         define bar() {
@@ -58,14 +65,12 @@ describe 'nested_classes_or_defines' do
       }"
     }
 
-  its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "define defined inside a class",
-        :linenumber => 3,
-        :column     => 9,
-      })
-      should_not have_problem :kind => :error
-    }
+    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)
+    end
   end
 end

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

@@ -1,59 +1,63 @@
 require 'spec_helper'
 
 describe 'parameter_order' do
-  describe 'define with attrs in order' do
+  let(:msg) { 'optional parameter listed before required parameter' }
+
+  context 'define with attrs in order' do
     let(:code) { "define foo($bar, $baz='gronk') { }" }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'define with parameter that calls a function' do
+  context 'define with parameter that calls a function' do
     let(:code) { "define foo($bar=extlookup($name)) {}" }
 
-    its(:problems) { should == [] }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'define with attrs out of order' do
+  context 'define with attrs out of order' do
     let(:code) { "define foo($bar='baz', $gronk) { }" }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "optional parameter listed before required parameter",
-        :linenumber => 1,
-        :column     => 24,
-      })
-      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(24)
+    end
   end
 
-  describe 'class/define parameter set to another variable' do
+  context 'class/define parameter set to another variable' do
     let(:code) { "
       define foo($bar, $baz = $name, $gronk=$::fqdn) {
       }"
     }
 
-    its(:problems) { should be_empty }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 
-  describe 'class/define parameter set to another variable with incorrect order' do
+  context 'class/define parameter set to another variable with incorrect order' do
     let(:code) { "
       define foo($baz = $name, $bar, $gronk=$::fqdn) {
       }"
     }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => "optional parameter listed before required parameter",
-        :linenumber => 2,
-        :column     => 32,
-      })
-      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(2).in_column(32)
+    end
   end
 
-  describe 'issue-101' do
+  context 'issue-101' do
     let(:code) { "
       define b (
         $foo,
@@ -62,6 +66,8 @@ describe 'parameter_order' do
       ) { }
     " }
 
-    its(:problems) { should == [] }
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
   end
 end