puppet-lint 0.4.0.pre1 → 1.0.0

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

@@ -1,20 +1,60 @@
 require 'spec_helper'
 
 describe 'only_variable_string' do
-  describe 'string containing only a variable' do
-    let(:code) { '"${foo}"' }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'string containing only a variable',
-        :linenumber => 1,
-        :column     => 3,
-      })
-    }
+  let(:msg) { 'string containing only a variable' }
+
+  context 'with fix disabled' do
+    context 'string containing only a variable' 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(3)
+      end
+    end
+
+    context 'string containing only a variable w/ ref' do
+      let(:code) { '"${foo[0]}"' }
+
+      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 'string containing only a variable w/ lots of refs' do
+      let(:code) { '"${foo[0][aoeuaoeu][bar][999]}"' }
+
+      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 'string containing only a variable as a hash key' do
+      let(:code) { "
+        $bar = 'key'
+        $foo = {
+          \"$bar\" => 1,
+        }"
+      }
+
+      it 'should not detect any problems' do
+        expect(problems).to be_empty
+      end
+    end
   end
 
-  describe 'string containing only a variable w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -23,17 +63,52 @@ describe 'only_variable_string' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { '"${foo}"' }
+    context 'string containing only a variable' 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(3)
+      end
+
+      it 'should unquote the variable' do
+        expect(manifest).to eq("$foo")
+      end
+    end
+
+    context 'string contaiting only a variable w/ ref' do
+      let(:code) { '"${foo[0]}"' }
+
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => 'string containing only a variable',
-        :linenumber => 1,
-        :column     => 3,
-      })
-    }
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(3)
+      end
 
-    its(:manifest) { should == "$foo" }
+      it 'should unquoted the variable' do
+        expect(manifest).to eq("$foo[0]")
+      end
+    end
+
+    context 'string containing only a variable w/ lots of refs' do
+      let(:code) { '"${foo[0][aoeuaoeu][bar][999]}"' }
+
+      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(3)
+      end
+
+      it 'should unquote the variable' do
+        expect(manifest).to eq("$foo[0][aoeuaoeu][bar][999]")
+      end
+    end
   end
 end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'puppet_url_without_modules' do
+  let(:msg) { 'puppet:// URL without modules/ found' }
+
+  context 'puppet:// url with modules' do
+    let(:code) { "'puppet:///modules/foo'" }
+
+    it 'should not detect any problems' do
+      expect(problems).to have(0).problems
+    end
+  end
+
+  context 'puppet:// url without modules' do
+    let(:code) { "'puppet:///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

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

@@ -1,81 +1,59 @@
 require 'spec_helper'
 
 describe 'quoted_booleans' do
-  describe 'quoted false' do
-    let(:code) { "class { 'foo': boolFlag => 'false' }" }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-  end
+  let(:msg) { 'quoted boolean value found' }
 
-  describe 'quoted true' do
-    let(:code) { "class { 'foo': boolFlag => 'true' }" }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-  end
+  context 'with fix disabled' do
+    context 'quoted false' do
+      let(:code) { "class { 'foo': boolFlag => 'false' }" }
 
-  describe 'double quoted true' do
-    let(:code) { "class { 'foo': boolFlag => \"true\" }" }
-
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-  end
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-  describe 'double quoted false' do
-    let(:code) { "class { 'foo': boolFlag => \"false\" }" }
-
-    its(:problems) {
-      should have_problem({
-        :kind       => :warning,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-  end
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(28)
+      end
+    end
 
-  describe 'quoted false w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
+    context '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
 
-    after do
-      PuppetLint.configuration.fix = false
+    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
 
-    let(:code) { "class { 'foo': boolFlag => 'false' }" }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-    its(:manifest) { should == "class { 'foo': boolFlag => false }" }
+    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
+
+      it 'should create a warning' do
+        expect(problems).to contain_warning(msg).on_line(1).in_column(28)
+      end
+    end
   end
 
-  describe 'quoted true w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -84,60 +62,68 @@ describe 'quoted_booleans' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { "class { 'foo': boolFlag => 'true' }" }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-    its(:manifest) { should == "class { 'foo': boolFlag => true }" }
-  end
+    context 'quoted false' do
+      let(:code) { "class { 'foo': boolFlag => 'false' }" }
 
-  describe 'double quoted true w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
-    end
+      it 'should only detect a single problem' do
+        expect(problems).to have(1).problem
+      end
 
-    after do
-      PuppetLint.configuration.fix = false
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(28)
+      end
+
+      it 'should unquote the boolean' do
+        expect(manifest).to eq("class { 'foo': boolFlag => false }")
+      end
     end
 
-    let(:code) { "class { 'foo': boolFlag => \"true\" }" }
-
-    its(:problems) {
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-    its(:manifest) { should == "class { 'foo': boolFlag => true }" }
-  end
+    context 'quoted true' do
+      let(:code) { "class { 'foo': boolFlag => 'true' }" }
 
-  describe 'double quoted false w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
+      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(28)
+      end
+
+      it 'should unquote the boolean' do
+        expect(manifest).to eq("class { 'foo': boolFlag => true }")
+      end
     end
 
-    after do
-      PuppetLint.configuration.fix = false
+    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 fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(28)
+      end
+
+      it 'should unquote the boolean' do
+        expect(manifest).to eq("class { 'foo': boolFlag => true }")
+      end
     end
 
-    let(:code) { "class { 'foo': boolFlag => \"false\" }" }
-
-    its(:problems) {
-      should have_problem({
-        :kind       => :fixed,
-        :message    => 'quoted boolean value found',
-        :linenumber => 1,
-        :column     => 28,
-      })
-    }
-    its(:manifest) { should == "class { 'foo': boolFlag => false }" }
+    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
+
+      it 'should fix the manifest' do
+        expect(problems).to contain_fixed(msg).on_line(1).in_column(28)
+      end
+
+      it 'should unquote the boolean' do
+        expect(manifest).to eq("class { 'foo': boolFlag => false }")
+      end
+    end
   end
 end

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

@@ -1,16 +1,17 @@
 require 'spec_helper'
 
 describe 'single_quote_string_with_variables' do
-  describe 'multiple strings in a line' do
+  let(:msg) { 'single quoted string containing a variable found' }
+
+  context 'multiple strings in a line' do
     let(:code) { "\"aoeu\" '${foo}'" }
 
-    its(:problems) {
-      should have_problem({
-        :kind       => :error,
-        :message    => 'single quoted string containing a variable found',
-        :linenumber => 1,
-        :column     => 8,
-      })
-    }
+    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(8)
+    end
   end
 end

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

@@ -1,55 +1,35 @@
 require 'spec_helper'
 
 describe 'variables_not_enclosed' do
-  describe 'variable not enclosed in {}' do
-    let(:code) { '" $gronk"' }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'variable not enclosed in {}',
-        :linenumber => 1,
-        :column     => 3,
-      })
-    }
-  end
+  let(:msg) { 'variable not enclosed in {}' }
 
-  describe 'variable not enclosed in {} w/fix' do
-    before do
-      PuppetLint.configuration.fix = true
-    end
+  context 'with fix disabled' do
+    context 'variable not enclosed in {}' do
+      let(:code) { '" $gronk"' }
 
-    after do
-      PuppetLint.configuration.fix = false
+      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
 
-    let(:code) { '" $gronk"' }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => 'variable not enclosed in {}',
-        :linenumber => 1,
-        :column     => 3,
-      })
-    }
-    its(:manifest) { should == '" ${gronk}"' }
-  end
+    context 'variable not enclosed in {} after many tokens' do
+      let(:code) { ("'groovy'\n" * 20) + '" $gronk"' }
 
-  describe 'variable not enclosed in {} after many tokens' do
-    let(:code) { ("'groovy'\n" * 20) + '" $gronk"' }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :warning,
-        :message    => 'variable not enclosed in {}',
-        :linenumber => 21,
-        :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(21).in_column(3)
+      end
+    end
   end
 
-  describe 'variable not enclosed in {} after many tokens w/fix' do
+  context 'with fix enabled' do
     before do
       PuppetLint.configuration.fix = true
     end
@@ -58,16 +38,36 @@ describe 'variables_not_enclosed' do
       PuppetLint.configuration.fix = false
     end
 
-    let(:code) { ("'groovy'\n" * 20) + '" $gronk"' }
-
-    its(:problems) {
-      should only_have_problem({
-        :kind       => :fixed,
-        :message    => 'variable not enclosed in {}',
-        :linenumber => 21,
-        :column     => 3,
-      })
-    }
-    its(:manifest) { should == ("'groovy'\n" * 20) + '" ${gronk}"' }
+    context 'variable not enclosed in {}' do
+      let(:code) { '" $gronk"' }
+
+      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(3)
+      end
+
+      it 'should enclose the variable in braces' do
+        expect(manifest).to eq('" ${gronk}"')
+      end
+    end
+
+    context 'variable not enclosed in {} after many tokens' do
+      let(:code) { ("'groovy'\n" * 20) + '" $gronk"' }
+
+      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(21).in_column(3)
+      end
+
+      it 'should enclose the variable in braces' do
+        expect(manifest).to eq(("'groovy'\n" * 20) + '" ${gronk}"')
+      end
+    end
   end
 end