halyard-puppet-lint 1.2.0

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'slash_comments' do
+  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
+
+  context 'with fix enabled' do
+    before do
+      PuppetLint.configuration.fix = true
+    end
+
+    after do
+      PuppetLint.configuration.fix = false
+    end
+
+    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
+
+      it 'should replace the double slash with a hash' do
+        expect(manifest).to eq("# foo")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe 'star_comments' do
+  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

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'case_without_default' do
+  let(:msg) { 'case statement without a default case' }
+
+  context 'case statement with a default case' do
+    let(:code) { "
+      case $foo {
+        bar: { }
+        default: { }
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'case statement without a default case' do
+    let(:code) { "
+      case $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(2).in_column(7)
+    end
+  end
+  
+  context 'nested case statements without a default case on the outermost' do
+    let(:code) { "
+      case $foo {
+        case $foop {
+	  bar: {}
+	  default: {}
+	}
+      }"
+    }
+
+    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)
+    end
+  end
+
+  context 'three nested case statements with two missing default cases' do
+    let(:code) { "
+      case $foo {
+        case $foop {
+	  bar: {}
+	  case $woop {
+	    baz: {}
+	  }
+	  default: {}
+	}
+      }"
+    }
+
+    it 'should detect two problems' do
+      expect(problems).to have(2).problems
+    end
+
+    it 'should create two warnings' do
+      expect(problems).to contain_warning(msg).on_line(2).in_column(7)
+      expect(problems).to contain_warning(msg).on_line(5).in_column(4)
+    end
+  end
+
+  context 'issue-117' do
+    let(:code) { "
+      $mem = inline_template('<%
+        mem,unit = scope.lookupvar(\'::memorysize\').split
+        mem = mem.to_f
+        # Normalize mem to bytes
+        case unit
+            when nil:  mem *= (1<<0)
+            when \'kB\': mem *= (1<<10)
+            when \'MB\': mem *= (1<<20)
+            when \'GB\': mem *= (1<<30)
+            when \'TB\': mem *= (1<<40)
+        end
+        %><%= mem.to_i %>')
+    "}
+
+    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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'selector_inside_resource' do
+  let(:msg) { 'selector inside resource block' }
+
+  context 'resource with a selector' do
+    let(:code) { "
+      file { 'foo':
+        ensure => $bar ? {
+          true    => present,
+          default => absent,
+        },
+      }"
+    }
+
+    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 'resource with a variable as a attr value' do
+    let(:code) { "
+      file { 'foo',
+        ensure => $bar,
+      }"
+    }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+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 {}" }
+
+    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
+
+  describe 'documented class' do
+    let(:code) { "
+      # foo
+      class test {}
+    "}
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  describe 'undocumented defined type' do
+    let(:code) { "define test {}" }
+
+    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
+
+  describe 'documented defined type' do
+    let(:code) { "
+      # foo
+      define test {}
+    "}
+
+    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,146 @@
+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
+
+    context 'multiple bare node names' do
+      let(:code) { "node foo, bar, baz { }" }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should create 3 warnings' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(6)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(11)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(16)
+      end
+    end
+
+    context 'mixed node name types' do
+      let(:code) { "node foo, 'bar', baz { }" }
+
+      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(1).in_column(6)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(18)
+      end
+    end
+
+    context 'multiple node blocks' do
+      let(:code) { "node foo { } node bar { }" }
+
+      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(1).in_column(6)
+        expect(problems).to contain_warning(msg).on_line(1).in_column(19)
+      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
+
+    context 'multiple bare node names' do
+      let(:code) { "node foo, bar, baz { }" }
+      let(:fixed) { "node 'foo', 'bar', 'baz' { }" }
+
+      it 'should detect 3 problems' do
+        expect(problems).to have(3).problems
+      end
+
+      it 'should fix the 3 problems' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(6)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(11)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(16)
+      end
+
+      it 'should quote all three node names' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+
+    context 'mixed node name types' do
+      let(:code) { "node foo, 'bar', baz { }" }
+      let(:fixed) { "node 'foo', 'bar', 'baz' { }" }
+
+      it 'should detect 2 problems' do
+        expect(problems).to have(2).problems
+      end
+
+      it 'should fix the 2 problems' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(6)
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(18)
+      end
+
+      it 'should quote the 2 unquoted node names' do
+        expect(manifest).to eq(fixed)
+      end
+    end
+  end
+end