puppet-lint 0.4.0.pre1 → 1.0.0

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

@@ -1,20 +1,23 @@
 require 'spec_helper'
 
 describe 'unquoted_file_mode' do
-  describe '4 digit unquoted file mode' do
-    let(:code) { "file { 'foo': mode => 0777 }" }
-
-    its(:problems) do
-      should only_have_problem(
-        :kind       => :warning,
-        :message    => "unquoted file mode",
-        :linenumber => 1,
-        :column     => 23,
-      )
+  let(:msg) { 'unquoted file mode' }
+
+  context 'with fix disabled' do
+    context '4 digit unquoted file mode' do
+      let(:code) { "file { 'foo': mode => 0777 }" }
+
+      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(23)
+      end
     end
   end
 
-  describe '4 digit unquoted file mode w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -23,16 +26,20 @@ describe 'unquoted_file_mode' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { "file { 'foo': mode => 0777 }" }
+    context '4 digit unquoted file mode w/fix' do
+      let(:code) { "file { 'foo': mode => 0777 }" }
+
+      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(23)
+      end
 
-    its(:problems) do
-      should only_have_problem(
-        :kind       => :fixed,
-        :message    => "unquoted file mode",
-        :linenumber => 1,
-        :column     => 23,
-      )
+      it 'should single quote the file mode' do
+        expect(manifest).to eq("file { 'foo': mode => '0777' }")
+      end
     end
-    its(:manifest) { should == "file { 'foo': mode => '0777' }" }
   end
 end

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

@@ -1,132 +1,144 @@
 require 'spec_helper'
 
 describe 'unquoted_resource_title' do
-  describe 'quoted resource title on single line resource' do
-    let(:code) { "file { 'foo': }" }
+  let(:msg) { 'unquoted resource title' }
 
-    its(:problems) { should be_empty }
-  end
-
-  describe 'unquoted resource title on single line resource' do
-    let(:code) { "file { foo: }" }
-
-    its(:problems) {
-      should only_have_problem(
-        :kind       => :warning,
-        :message    => "unquoted resource title",
-        :linenumber => 1,
-        :column     => 8,
-      )
-    }
-  end
+  context 'with fix disabled' do
+    context 'quoted resource title on single line resource' do
+      let(:code) { "file { 'foo': }" }
 
-  describe 'unquoted resource title on single line resource 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
+    context 'unquoted resource title on single line resource' do
+      let(:code) { "file { 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(8)
+      end
     end
 
-    let(:code) { "file { foo: }" }
+    context 'quoted resource title on multi line resource' do
+      let(:code) { "
+        file { 'foo':
+        }"
+      }
 
-    its(:problems) {
-      should only_have_problem(
-        :kind       => :fixed,
-        :message    => "unquoted resource title",
-        :linenumber => 1,
-        :column     => 8,
-      )
-    }
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-    its(:manifest) { should == "file { 'foo': }" }
-  end
+    context 'unquoted resource title on multi line resource' do
+      let(:code) { "
+        file { foo:
+        }"
+      }
 
-  describe 'quoted resource title on multi line resource' do
-    let(:code) { "
-      file { 'foo':
-      }"
-    }
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    its(:problems) { should be_empty }
-  end
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(2).in_column(16)
+      end
+    end
 
-  describe 'unquoted resource title on multi line resource' do
-    let(:code) { "
-      file { foo:
-      }"
-    }
-
-    its(:problems) {
-      should only_have_problem(
-        :kind       => :warning,
-        :message    => "unquoted resource title",
-        :linenumber => 2,
-        :column     => 14,
-      )
-    }
-  end
+    context 'condensed resources with quoted titles' do
+      let(:code) { "
+        file {
+          'foo': ;
+          'bar': ;
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-  describe 'unquoted resource title on multi line resource w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
+    context 'condensed resources with an unquoted title' do
+      let(:code) { "
+        file {
+          '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(4).in_column(11)
+      end
     end
 
-    after do
-      PuppetLint.configuration.fix = false
+    context 'single line resource with an array of titles (all quoted)' do
+      let(:code) { "file { ['foo', 'bar']: }" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
     end
 
-    let(:code) { "
-      file { foo:
-      }"
-    }
-
-    its(:problems) {
-      should only_have_problem(
-        :kind       => :fixed,
-        :message    => "unquoted resource title",
-        :linenumber => 2,
-        :column     => 14,
-      )
-    }
-
-    its(:manifest) { should == "
-      file { 'foo':
-      }"
-    }
-  end
+    context 'resource inside a case statement' do
+      let(:code) { "
+        case $ensure {
+          'absent': {
+            file { \"some_file_${name}\":
+              ensure => absent,
+            }
+          }
+        }"
+      }
 
-  describe 'condensed resources with quoted titles' do
-    let(:code) { "
-      file {
-        'foo': ;
-        'bar': ;
-      }"
-    }
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-    its(:problems) { should be_empty }
-  end
+    context 'issue #116' do
+      let(:code) { "
+        $config_file_init = $::operatingsystem ? {
+          /(?i:Debian|Ubuntu|Mint)/ => '/etc/default/foo',
+          default                   => '/etc/sysconfig/foo',
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
 
-  describe 'condensed resources with an unquoted title' do
-    let(:code) { "
-      file {
-        'foo': ;
-        bar: ;
-      }"
-    }
-
-    its(:problems) {
-      should only_have_problem(
-        :kind       => :warning,
-        :message    => "unquoted resource title",
-        :linenumber => 4,
-        :column     => 9,
-      )
-    }
+    context 'case statement' do
+      let(:code) { %{
+        case $operatingsystem {
+          centos: {
+            $version = '1.2.3'
+          }
+          solaris: {
+            $version = '3.2.1'
+          }
+          default: {
+            fail("Module ${module_name} is not supported on ${operatingsystem}")
+          }
+        }}
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
   end
 
-  describe 'condensed resources with an unquoted title w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -135,76 +147,70 @@ describe 'unquoted_resource_title' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { "
-      file {
-        'foo': ;
-        bar: ;
-      }"
-    }
-
-    its(:problems) {
-      should only_have_problem(
-        :kind       => :fixed,
-        :message    => "unquoted resource title",
-        :linenumber => 4,
-        :column     => 9,
-      )
-    }
-
-    its(:manifest) { should == "
-      file {
-        'foo': ;
-        'bar': ;
-      }"
-    }
-  end
-
-  describe 'single line resource with an array of titles (all quoted)' do
-    let(:code) { "file { ['foo', 'bar']: }" }
+    context 'unquoted resource title on single line resource' do
+      let(:code) { "file { foo: }" }
 
-    its(:problems) { should be_empty }
-  end
-
-  describe 'resource inside a case statement' do
-    let(:code) { "
-      case $ensure {
-        'absent': {
-          file { \"some_file_${name}\":
-            ensure => absent,
-          }
-        }
-      }"
-    }
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    its(:problems) { should == [] }
-  end
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(8)
+      end
 
-  describe 'issue #116' do
-    let(:code) { "
-      $config_file_init = $::operatingsystem ? {
-        /(?i:Debian|Ubuntu|Mint)/ => '/etc/default/foo',
-        default                   => '/etc/sysconfig/foo',
-      }"
-    }
+      it 'should single quote the resource title' do
+        expect(manifest).to eq("file { 'foo': }")
+      end
+    end
 
-    its(:problems) { should == [] }
-  end
+    context 'unquoted resource title on multi line resource' do
+      let(:code) { "
+        file { foo:
+        }"
+      }
+      let(:fixed) { "
+        file { '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(2).in_column(16)
+      end
+
+      it 'should single quote the resource title' do
+        expect(manifest).to eq(fixed)
+      end
+    end
 
-  describe 'case statement' do
-    let(:code) { %{
-      case $operatingsystem {
-        centos: {
-          $version = '1.2.3'
-        }
-        solaris: {
-          $version = '3.2.1'
-        }
-        default: {
-          fail("Module ${module_name} is not supported on ${operatingsystem}")
-        }
-      }}
-    }
-
-    its(:problems) { should == [] }
+    context 'condensed resources with an unquoted title' do
+      let(:code) { "
+        file {
+          'foo': ;
+          bar: ;
+        }"
+      }
+      let(:fixed) { "
+        file {
+          'foo': ;
+          'bar': ;
+        }"
+      }
+
+      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(4).in_column(11)
+      end
+
+      it 'should single quote the resource title' do
+        expect(manifest).to eq(fixed)
+      end
+    end
   end
 end

data/spec/puppet-lint/plugins/check_strings/double_quoted_strings_spec.rb

@@ -1,43 +1,141 @@
 require 'spec_helper'
 
 describe 'double_quoted_strings' do
-  describe 'double quoted string containing a variable inside single quotes' do
-    let(:code) { "exec { \"/usr/bin/wget -O - '${source}' | /usr/bin/apt-key add -\": }" }
+  let(:msg) { 'double quoted string containing no variables' }
 
-    its(:problems) { should be_empty }
-  end
+  context 'with fix disabled' do
+    context 'double quoted string containing a variable inside single quotes' do
+      let(:code) { "exec { \"/usr/bin/wget -O - '${source}' | /usr/bin/apt-key add -\": }" }
 
-  describe 'double quoted string containing a variable inside single quotes 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
+    context 'multiple strings in a line' do
+      let(:code) { "\"aoeu\" '${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
 
-    let(:code) { "exec { \"/usr/bin/wget -O - '${source}' | /usr/bin/apt-key add -\": }" }
+    context 'double quoted string nested in a single quoted string' do
+      let(:code) { "'grep \"status=sent\" /var/log/mail.log'" }
 
-    its(:problems) { should be_empty }
-    its(:manifest) {
-      should == "exec { \"/usr/bin/wget -O - '${source}' | /usr/bin/apt-key add -\": }"
-    }
-  end
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'double quoted string after a comment' do
+      let(:code) { "service { 'foo': } # \"bar\"" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'double quoted string containing newline but no variables' do
+      let(:code) { %{"foo\n"} }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'double quoted string with backslash for continuation' do
+      let(:code) { %{
+        class puppet::master::maintenance (
+        ) {
+          cron { 'puppet_master_reports_cleanup':
+            command     => "/usr/bin/find /var/lib/puppet/reports -type f -mtime +15 \
+                           -delete && /usr/bin/find /var/lib/puppet/reports -mindepth 1 \
+                           -empty -type d -delete",
+            minute      => '15',
+            hour        => '5',
+          }
+        }
+      } }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'double quoted true' do
+      let(:code) { "class { 'foo': boolFlag => \"true\" }" }
+
+      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(28)
+      end
+    end
+
+    context 'double quoted false' do
+      let(:code) { "class { 'foo': boolFlag => \"false\" }" }
+
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-  describe 'multiple strings in a line' do
-    let(:code) { "\"aoeu\" '${foo}'" }
-
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'double quoted string containing no variables',
-        :linenumber => 1,
-        :column     => 1,
-      })
-    }
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(28)
+      end
+    end
+
+    context 'double quoted stings containing supported escape patterns' do
+      let(:code) {%{
+        $string1 = "this string contins \n newline"
+        $string2 = "this string contains \ttab"
+        $string3 = "this string contains \${escaped} var"
+        $string4 = "this string contains \\"escaped \\" double quotes"
+        $string5 = "this string contains \\'escaped \\' single quotes"
+        $string6 = "this string contains \r line return"
+        }}
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'double quoted string with random escape should be rejected' do
+      let(:code) {%{ $ztring = "this string contains \l random esape" } }
+
+      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
+
+    context 'single quotes in a double quoted string' do
+      let(:code) { "\"this 'string' 'has' lots of 'quotes'\"" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
+
+    context 'double quoted string containing single quoted string' do
+      let(:code) { %[notify { "'foo'": }] }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
+    end
   end
 
-  describe 'multiple strings in a line w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -46,77 +144,56 @@ describe 'double_quoted_strings' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { "\"aoeu\" '${foo}'" }
+    context 'double quoted string containing a variable inside single quotes' do
+      let(:code) { "exec { \"/usr/bin/wget -O - '${source}' | /usr/bin/apt-key add -\": }" }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'double quoted string containing no variables',
-        :linenumber => 1,
-        :column     => 1,
-      })
-    }
-    its(:manifest) { should == "'aoeu' '${foo}'" }
-  end
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
 
-  describe 'double quoted string nested in a single quoted string' do
-    let(:code) { "'grep \"status=sent\" /var/log/mail.log'" }
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
 
-    its(:problems) { should be_empty }
-  end
+    context 'double quoted string containing a lone dollar' do
+      let(:code) {"\"sed -i 's/^;*[[:space:]]*${name}[[:space:]]*=.*$/${name} = ${value}/g' file\"" }
 
-  describe 'double quoted string after a comment' do
-    let(:code) { "service { 'foo': } # \"bar\"" }
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
 
-    its(:problems) { should be_empty }
-  end
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
 
-  describe 'double quoted string containing newline but no variables' do
-    let(:code) { %{"foo\n"} }
+    context 'multiple strings in a line' do
+      let(:code) { "\"aoeu\" '${foo}'" }
 
-    its(:problems) { should be_empty }
-  end
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-  describe 'double quoted string with backslash for continuation' do
-    let(:code) { %{
-      class puppet::master::maintenance (
-      ) {
-        cron { 'puppet_master_reports_cleanup':
-          command     => "/usr/bin/find /var/lib/puppet/reports -type f -mtime +15 \
-                         -delete && /usr/bin/find /var/lib/puppet/reports -mindepth 1 \
-                         -empty -type d -delete",
-          minute      => '15',
-          hour        => '5',
-        }
-      }
-    } }
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(1)
+      end
 
-    its(:problems) { should == [] }
-  end
+      it 'should convert the double quoted string into single quotes' do
+        expect(manifest).to eq("'aoeu' '${foo}'")
+      end
+    end
 
-  describe 'double quoted true' do
-    let(:code) { "class { 'foo': boolFlag => \"true\" }" }
-
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'double quoted string containing no variables',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-  end
+    context 'single quotes in a double quoted string' do
+      let(:code) { "\"this 'string' 'has' lots of 'quotes'\"" }
+
+      it 'should not detect any problems' do
+        expect(problems).to have(0).problems
+      end
 
-  describe 'double quoted false' do
-    let(:code) { "class { 'foo': boolFlag => \"false\" }" }
-
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'double quoted string containing no variables',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
+      it 'should not modify the manifest' do
+        expect(manifest).to eq(code)
+      end
+    end
   end
 end