halyard-puppet-lint 1.2.0

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe 'autoloader_layout' do
+  context 'foo::bar in foo/manifests/bar.pp' do
+    let(:code) { "class foo::bar { }" }
+    let(:path) { 'foo/manifests/bar.pp' }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'foo::bar::baz in foo/manifests/bar/baz.pp' do
+    let(:code) { 'define foo::bar::baz() { }' }
+    let(:path) { 'foo/manifests/bar/baz.pp' }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'foo in foo/manifests/init.pp' do
+    let(:code) { 'class foo { }' }
+    let(:path) { 'foo/manifests/init.pp' }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'foo::bar in foo/manifests/init.pp' do
+    let(:code) { 'class foo::bar { }' }
+    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
+
+  context 'foo included in bar/manifests/init.pp' do
+    let(:code) { "
+      class bar {
+        class {'foo':
+          someparam => 'somevalue',
+        }
+      }
+      "
+    }
+    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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+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 { }"
+    }
+
+    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
+
+  context 'class without parameters' do
+    let(:code) {"
+      class myclass {
+
+        if ( $::lsbdistcodename == 'squeeze' ) {
+          #TODO
+        }
+      }
+    "}
+
+    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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+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 { }" }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'class inheriting from sister in same module namespace' do
+    let(:code) { "class foo::bar inherits foo::baz { }" }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'class inheriting from another module namespace' do
+    let(:code) { "class foo::bar inherits baz { }" }
+
+    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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'names_containing_dash' 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(:path) { 'foo-bar/manifests/init.pp' }
+
+    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(class_msg).on_line(1).in_column(7)
+    end
+  end
+
+  context 'define named foo-bar' do
+    let(:code) { 'define foo::foo-bar { }' }
+    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 an error' do
+      expect(problems).to contain_error(define_msg).on_line(1).in_column(8)
+    end
+  end
+
+  context 'class named bar-foo' do
+    let(:code) { 'class foo::bar-foo { }' }
+    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 an error' do
+      expect(problems).to contain_error(class_msg).on_line(1).in_column(7)
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'nested_classes_or_defines' 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 { }" }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'class inside a class' do
+    let(:code) { "
+      class foo {
+        class 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(class_msg).on_line(3).in_column(9)
+    end
+  end
+
+  context 'instantiating a parametised class inside a class' do
+    let(:code) { "
+      class bar {
+        class { 'foo':
+          bar => 'foobar'
+        }
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'instantiating a parametised class inside a define' do
+    let(:code) { "
+      define bar() {
+        class { 'foo':
+          bar => 'foobar'
+        }
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'define inside a class' do
+    let(:code) { "
+      class foo {
+        define bar() {
+        }
+      }"
+    }
+
+    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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe 'parameter_order' do
+  let(:msg) { 'optional parameter listed before required parameter' }
+
+  context 'define with attrs in order' do
+    let(:code) { "define foo($bar, $baz='gronk') { }" }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'define with parameter that calls a function' do
+    let(:code) { "define foo($bar=extlookup($name)) {}" }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'define with attrs out of order' do
+    let(:code) { "define foo($bar='baz', $gronk) { }" }
+
+    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
+
+  context 'class/define parameter set to another variable' do
+    let(:code) { "
+      define foo($bar, $baz = $name, $gronk=$::fqdn) {
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'class/define parameter set to another variable with incorrect order' do
+    let(:code) { "
+      define foo($baz = $name, $bar, $gronk=$::fqdn) {
+      }"
+    }
+
+    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
+
+  context 'issue-101' do
+    let(:code) { "
+      define b (
+        $foo,
+        $bar='',
+        $baz={}
+      ) { }
+    " }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+end

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

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

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

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe 'variable_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
+      }"
+    }
+
+    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
+
+  context 'class with no variables declared accessing top scope explicitly' do
+    let(:code) { "
+      class foo {
+        $bar = $::baz
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'class with no variables declared accessing local array index' do
+    let(:code) { "
+      class foo {
+        $bar = ['one', 'two', 'three']
+        $baz = $bar[1]
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'class with no variables declared accessing local hash key' do
+    let(:code) { "
+      class foo {
+        $bar = {
+          'one'   => 1,
+          'two'   => 2,
+          'three' => 3,
+        }
+        $baz = $bar['two']
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+
+  context 'class with variables declared accessing local scope' do
+    let(:code) { "
+      class foo {
+        $bar = 1
+        $baz = $bar
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'class with parameters accessing local scope' do
+    let(:code) { "
+      class foo($bar='UNSET') {
+        $baz = $bar
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'defined type with no variables declared accessing top scope' do
+    let(:code) { "
+      define foo() {
+        $bar = $fqdn
+      }"
+    }
+
+    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
+
+  context 'defined type with no variables declared accessing top scope explicitly' do
+    let(:code) { "
+      define foo() {
+        $bar = $::fqdn
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context '$name should be auto defined' do
+    let(:code) { "
+      define foo() {
+        $bar = $name
+        $baz = $title
+        $gronk = $module_name
+        $meep = $1
+      }"
+    }
+
+    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
+
+  %w{alias audit before loglevel noop notify require schedule stage subscribe tag}.each do |metaparam|
+    context "referencing #{metaparam} metaparam value as a variable" do
+      let(:code) { "
+        class foo() {
+          $#{metaparam}
+        }
+      " }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+  end
+
+  context 'support the use of facts and trusted facts for Puppet 3.5 onwards' do
+    let(:code) { "
+      class foo() {
+        if $facts['osfamily'] == 'redhat' or $trusted['osfamily'] == 'redhat' {
+         $redhat = true
+        }
+      }
+    " }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+end