chef 16.1.16 → 16.18.30

data/spec/unit/resource/chef_client_scheduled_task_spec.rb

@@ -43,16 +43,26 @@ describe Chef::Resource::ChefClientScheduledTask do
     expect(resource.frequency_modifier).to eql(10)
   end
 
+  it "expects default frequency modifier to be 30 when frequency is set to 'minute'" do
+    resource.frequency "minute"
+    expect(resource.frequency_modifier).to eql(30)
+  end
+
+  it "expects default frequency modifier to be 1 when frequency is set to 'daily'" do
+    resource.frequency "daily"
+    expect(resource.frequency_modifier).to eql(1)
+  end
+
   it "validates the start_time property input" do
     expect { resource.start_time("8:00 am") }.to raise_error(Chef::Exceptions::ValidationFailed)
     expect { resource.start_time("8:00") }.to raise_error(Chef::Exceptions::ValidationFailed)
-    expect { resource.start_time("08:00") }.not_to raise_error(Chef::Exceptions::ValidationFailed)
+    expect { resource.start_time("08:00") }.not_to raise_error
   end
 
   it "validates the start_date property input" do
     expect { resource.start_date("2/1/20") }.to raise_error(Chef::Exceptions::ValidationFailed)
     expect { resource.start_date("02/01/20") }.to raise_error(Chef::Exceptions::ValidationFailed)
-    expect { resource.start_date("02/01/2020") }.not_to raise_error(Chef::Exceptions::ValidationFailed)
+    expect { resource.start_date("02/01/2020") }.not_to raise_error
   end
 
   it "raises an error if frequency_modifier is not a positive number" do
@@ -70,12 +80,12 @@ describe Chef::Resource::ChefClientScheduledTask do
 
   describe "#client_cmd" do
     it "creates a valid command if using all default properties" do
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb") | eql("C:/opscode/chef/bin/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb")
     end
 
     it "uses daemon_options if set" do
       resource.daemon_options ["--foo 1", "--bar 2"]
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --foo 1 --bar 2")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --foo 1 --bar 2") | eql("C:/opscode/chef/bin/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb --foo 1 --bar 2")
     end
 
     it "uses custom config dir if set" do
@@ -86,17 +96,17 @@ describe Chef::Resource::ChefClientScheduledTask do
     it "uses custom log files / paths if set" do
       resource.log_file_name "my-client.log"
       resource.log_directory "C:/foo/bar"
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L C:/foo/bar/my-client.log -c /etc/chef/client.rb")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L C:/foo/bar/my-client.log -c /etc/chef/client.rb") | eql("C:/opscode/chef/bin/chef-client -L C:/foo/bar/my-client.log -c C:\\chef/client.rb")
     end
 
     it "uses custom chef-client binary if set" do
       resource.chef_binary_path "C:/foo/bar/chef-client"
-      expect(provider.client_cmd).to eql("C:/foo/bar/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb")
+      expect(provider.client_cmd).to eql("C:/foo/bar/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb") | eql("C:/foo/bar/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb")
     end
 
     it "sets the license acceptance flag if set" do
       resource.accept_chef_license true
-      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --chef-license accept")
+      expect(provider.client_cmd).to eql("C:/opscode/chef/bin/chef-client -L /etc/chef/log/client.log -c /etc/chef/client.rb --chef-license accept") | eql("C:/opscode/chef/bin/chef-client -L C:\\chef/log/client.log -c C:\\chef/client.rb --chef-license accept")
     end
   end
 end

data/spec/unit/resource/chef_client_systemd_timer_spec.rb

@@ -33,6 +33,12 @@ describe Chef::Resource::ChefClientSystemdTimer do
     expect(resource.user).to eql("root")
   end
 
+  it "validates the cpu_quota property input" do
+    expect { resource.cpu_quota(0) }.to raise_error(Chef::Exceptions::ValidationFailed)
+    expect { resource.cpu_quota(50) }.not_to raise_error
+    expect { resource.cpu_quota(101) }.not_to raise_error
+  end
+
   it "builds a default value for chef_binary_path dist values" do
     expect(resource.chef_binary_path).to eql("/opt/chef/bin/chef-client")
   end
@@ -43,13 +49,16 @@ describe Chef::Resource::ChefClientSystemdTimer do
   end
 
   describe "#chef_client_cmd" do
+
+    let(:root_path) { windows? ? "C:\\chef/client.rb" : "/etc/chef/client.rb" }
+
     it "creates a valid command if using all default properties" do
-      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client -c #{root_path}")
     end
 
     it "uses daemon_options if set" do
       resource.daemon_options ["--foo 1", "--bar 2"]
-      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --foo 1 --bar 2 -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --foo 1 --bar 2 -c #{root_path}")
     end
 
     it "uses custom config dir if set" do
@@ -59,12 +68,41 @@ describe Chef::Resource::ChefClientSystemdTimer do
 
     it "uses custom chef-client binary if set" do
       resource.chef_binary_path "/usr/local/bin/chef-client"
-      expect(provider.chef_client_cmd).to eql("/usr/local/bin/chef-client -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/usr/local/bin/chef-client -c #{root_path}")
     end
 
     it "sets the license acceptance flag if set" do
       resource.accept_chef_license true
-      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --chef-license accept -c /etc/chef/client.rb")
+      expect(provider.chef_client_cmd).to eql("/opt/chef/bin/chef-client --chef-license accept -c #{root_path}")
+    end
+  end
+
+  describe "#service_content" do
+    it "does not set ConditionACPower if run_on_battery property is set to true (the default)" do
+      expect(provider.service_content["Service"]).not_to have_key("ConditionACPower")
+    end
+
+    it "sets ConditionACPower if run_on_battery property is set to false" do
+      resource.run_on_battery false
+      expect(provider.service_content["Service"]["ConditionACPower"]).to eq("true")
+    end
+
+    it "does not set Environment if environment property is empty" do
+      expect(provider.service_content["Service"]).not_to have_key("Environment")
+    end
+
+    it "sets Environment if environment property is set" do
+      resource.environment({ "foo" => "bar" })
+      expect(provider.service_content["Service"]["Environment"]).to eq(["\"foo=bar\""])
+    end
+
+    it "does not set CPUQuota if cpu_quota property is not set" do
+      expect(provider.service_content["Service"]).not_to have_key("CPUQuota")
+    end
+
+    it "sets CPUQuota if cpu_quota property is set" do
+      resource.cpu_quota 50
+      expect(provider.service_content["Service"]["CPUQuota"]).to eq(50)
     end
   end
-end
+end

data/spec/unit/resource/chef_client_trusted_certificate_spec.rb

@@ -0,0 +1,68 @@
+#
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+
+describe Chef::Resource::ChefClientTrustedCertificate do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::ChefClientTrustedCertificate.new("foo", run_context) }
+  let(:provider) { resource.provider_for_action(:add) }
+
+  it "has a resource name of :chef_client_trusted_certificate" do
+    expect(resource.resource_name).to eql(:chef_client_trusted_certificate)
+  end
+
+  it "has a name property of cert_name" do
+    expect(resource.cert_name).to eql("foo")
+  end
+
+  it "sets the default action as :add" do
+    expect(resource.action).to eql([:add])
+  end
+
+  it "supports :remove action" do
+    expect { resource.action :remove }.not_to raise_error
+  end
+
+  describe "#cert_path" do
+    it "appends .pem to new_resource.cert_name value" do
+      resource.cert_name "something"
+      expect(provider.cert_path).to match(%r{trusted_certs/something.pem$})
+    end
+
+    it "does not append .pem if cert_name already ends in .pem" do
+      resource.cert_name "something.pem"
+      expect(provider.cert_path).to match(%r{trusted_certs/something.pem$})
+    end
+  end
+
+  describe "sensitive attribute" do
+    context "should be insensitive by default" do
+      it { expect(resource.sensitive).to(be_falsey) }
+    end
+
+    context "when set" do
+      before { resource.sensitive(true) }
+
+      it "should be set on the resource" do
+        expect(resource.sensitive).to(be_truthy)
+      end
+    end
+  end
+end

data/spec/unit/resource/cron_spec.rb

@@ -132,10 +132,10 @@ describe Chef::Resource::Cron do
 
   describe "weekday" do
     it "rejects any weekday over 7" do
-      expect { resource.weekday "8" }.to raise_error(RangeError)
+      expect { resource.weekday "8" }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
     it "rejects any symbols which don't represent day of week" do
-      expect { resource.weekday :foo }.to raise_error(RangeError)
+      expect { resource.weekday :foo }.to raise_error(Chef::Exceptions::ValidationFailed)
     end
   end
 

data/spec/unit/resource/execute_spec.rb

@@ -63,6 +63,16 @@ describe Chef::Resource::Execute do
         expect(identity[:user]).to eq("user")
       end
     end
+
+    context "when username is passed as an integer" do
+      let(:username) { 499 }
+
+      it "correctly parses the user and domain" do
+        identity = resource.qualify_user(username, password, domain)
+        expect(identity[:domain]).to eq(nil)
+        expect(identity[:user]).to eq(499)
+      end
+    end
   end
 
   shared_examples_for "it received valid credentials" do
@@ -106,172 +116,167 @@ describe Chef::Resource::Execute do
     end
   end
 
-  shared_examples_for "a consumer of the Execute resource" do
-    context "when running on Windows" do
-      before do
-        allow(resource).to receive(:windows?).and_return(true)
-      end
-
-      context "when no user, domain, or password is specified" do
-        let(:username) { nil }
-        let(:domain) { nil }
-        let(:password) { nil }
-        it_behaves_like "it received valid credentials"
-      end
-
-      context "when a valid username is specified" do
-        let(:username) { "starchild" }
-        let(:elevated) { false }
-        context "when a valid domain is specified" do
-          let(:domain) { "mothership" }
-
-          context "when the password is not specified" do
-            let(:password) { nil }
-            it_behaves_like "it received invalid credentials"
-          end
-
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received valid credentials"
-          end
-        end
+  context "when running on Windows" do
+    before do
+      allow(resource).to receive(:windows?).and_return(true)
+    end
 
-        context "when the domain is not specified" do
-          let(:domain) { nil }
-          let(:elevated) { false }
+    context "when no user, domain, or password is specified" do
+      let(:username) { nil }
+      let(:domain) { nil }
+      let(:password) { nil }
+      it_behaves_like "it received valid credentials"
+    end
 
-          context "when the password is not specified" do
-            let(:password) { nil }
-            it_behaves_like "it received invalid credentials"
-          end
+    context "when a valid username is specified" do
+      let(:username) { "starchild" }
+      let(:elevated) { false }
+      context "when a valid domain is specified" do
+        let(:domain) { "mothership" }
 
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received valid credentials"
-          end
+        context "when the password is not specified" do
+          let(:password) { nil }
+          it_behaves_like "it received invalid credentials"
         end
 
-        context "when username is not specified" do
-          let(:username) { nil }
-
-          context "when domain is specified" do
-            let(:domain) { "mothership" }
-            let(:password) { nil }
-            it_behaves_like "it received invalid username and domain"
-          end
-
-          context "when password is specified" do
-            let(:domain) { nil }
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received invalid username and domain"
-          end
+        context "when the password is specified" do
+          let(:password) { "we.funk!" }
+          it_behaves_like "it received valid credentials"
         end
       end
 
-      context "when invalid username is specified" do
-        let(:username) { "user@domain@domain" }
+      context "when the domain is not specified" do
         let(:domain) { nil }
-        let(:password) { "we.funk!" }
-        it_behaves_like "it received invalid username and domain"
-      end
-
-      context "when the domain is provided in both username and domain" do
-        let(:domain) { "some_domain" }
-        let(:password) { "we.funk!" }
+        let(:elevated) { false }
 
-        context "when username is in the form domain\\user" do
-          let(:username) { "mothership\\starchild" }
-          it_behaves_like "it received invalid username and domain"
+        context "when the password is not specified" do
+          let(:password) { nil }
+          it_behaves_like "it received invalid credentials"
         end
 
-        context "when username is in the form user@domain" do
-          let(:username) { "starchild@mothership" }
-          it_behaves_like "it received invalid username and domain"
+        context "when the password is specified" do
+          let(:password) { "we.funk!" }
+          it_behaves_like "it received valid credentials"
         end
       end
 
-      context "when elevated is passed" do
-        let(:elevated) { true }
+      context "when username is not specified" do
+        let(:username) { nil }
 
-        context "when username and password are not passed" do
-          let(:username) { nil }
-          let(:domain) { nil }
+        context "when domain is specified" do
+          let(:domain) { "mothership" }
           let(:password) { nil }
-          it_behaves_like "it received invalid credentials"
+          it_behaves_like "it received invalid username and domain"
         end
 
-        context "when username and password are passed" do
-          let(:username) { "user" }
+        context "when password is specified" do
           let(:domain) { nil }
           let(:password) { "we.funk!" }
-          it_behaves_like "it received valid credentials"
+          it_behaves_like "it received invalid username and domain"
         end
       end
     end
 
-    context "when not running on Windows" do
-      before do
-        allow(resource).to receive(:node).and_return({ platform_family: "ubuntu" })
+    context "when invalid username is specified" do
+      let(:username) { "user@domain@domain" }
+      let(:domain) { nil }
+      let(:password) { "we.funk!" }
+      it_behaves_like "it received invalid username and domain"
+    end
+
+    context "when the domain is provided in both username and domain" do
+      let(:domain) { "some_domain" }
+      let(:password) { "we.funk!" }
+
+      context "when username is in the form domain\\user" do
+        let(:username) { "mothership\\starchild" }
+        it_behaves_like "it received invalid username and domain"
+      end
+
+      context "when username is in the form user@domain" do
+        let(:username) { "starchild@mothership" }
+        it_behaves_like "it received invalid username and domain"
       end
+    end
 
-      context "when no user, domain, or password is specified" do
+    context "when elevated is passed" do
+      let(:elevated) { true }
+
+      context "when username and password are not passed" do
         let(:username) { nil }
         let(:domain) { nil }
         let(:password) { nil }
+        it_behaves_like "it received invalid credentials"
+      end
+
+      context "when username and password are passed" do
+        let(:username) { "user" }
+        let(:domain) { nil }
+        let(:password) { "we.funk!" }
         it_behaves_like "it received valid credentials"
       end
+    end
+  end
+
+  context "when not running on Windows" do
+    before do
+      allow(resource).to receive(:node).and_return({ platform_family: "ubuntu" })
+    end
 
-      context "when the user is specified and the domain and password are not" do
-        let(:username) { "starchild" }
+    context "when no user, domain, or password is specified" do
+      let(:username) { nil }
+      let(:domain) { nil }
+      let(:password) { nil }
+      it_behaves_like "it received valid credentials"
+    end
+
+    context "when the user is specified and the domain and password are not" do
+      let(:username) { "starchild" }
+      let(:domain) { nil }
+      let(:password) { nil }
+      it_behaves_like "it received valid credentials"
+
+      context "when the password is specified and the domain is not" do
+        let(:password) { "we.funk!" }
         let(:domain) { nil }
+        it_behaves_like "it received credentials that are not valid on the platform"
+      end
+
+      context "when the domain is specified and the password is not" do
+        let(:domain) { "mothership" }
         let(:password) { nil }
-        it_behaves_like "it received valid credentials"
+        it_behaves_like "it received credentials that are not valid on the platform"
+      end
 
-        context "when the password is specified and the domain is not" do
+      context "when the domain and password are specified" do
+        let(:domain) { "mothership" }
+        let(:password) { "we.funk!" }
+        it_behaves_like "it received credentials that are not valid on the platform"
+      end
+    end
+
+    context "when the user is not specified" do
+      let(:username) { nil }
+      context "when the domain is specified" do
+        let(:domain) { "mothership" }
+        context "when the password is specified" do
           let(:password) { "we.funk!" }
-          let(:domain) { nil }
           it_behaves_like "it received credentials that are not valid on the platform"
         end
 
-        context "when the domain is specified and the password is not" do
-          let(:domain) { "mothership" }
+        context "when password is not specified" do
           let(:password) { nil }
           it_behaves_like "it received credentials that are not valid on the platform"
         end
+      end
 
-        context "when the domain and password are specified" do
-          let(:domain) { "mothership" }
+      context "when the domain is not specified" do
+        let(:domain) { nil }
+        context "when the password is specified" do
           let(:password) { "we.funk!" }
           it_behaves_like "it received credentials that are not valid on the platform"
         end
       end
-
-      context "when the user is not specified" do
-        let(:username) { nil }
-        context "when the domain is specified" do
-          let(:domain) { "mothership" }
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received credentials that are not valid on the platform"
-          end
-
-          context "when password is not specified" do
-            let(:password) { nil }
-            it_behaves_like "it received credentials that are not valid on the platform"
-          end
-        end
-
-        context "when the domain is not specified" do
-          let(:domain) { nil }
-          context "when the password is specified" do
-            let(:password) { "we.funk!" }
-            it_behaves_like "it received credentials that are not valid on the platform"
-          end
-        end
-      end
     end
   end
-
-  it_behaves_like "a consumer of the Execute resource"
-
 end

data/spec/unit/resource/file/verification_spec.rb

@@ -112,7 +112,8 @@ describe Chef::Resource::File::Verification do
       end
 
       it "returns true if the command succeeds" do
-        v = Chef::Resource::File::Verification.new(parent_resource, "true", {})
+        test_command = platform_specific_verify_command("path")
+        v = Chef::Resource::File::Verification.new(parent_resource, test_command, {})
         expect(v.verify(temp_path)).to eq(true)
       end
 

data/spec/unit/resource/helpers/cron_validations_spec.rb

@@ -34,8 +34,12 @@ describe Chef::ResourceHelpers::CronValidations do
       expect(Chef::ResourceHelpers::CronValidations.validate_dow(8)).to be false
     end
 
+    it "it accepts the string day with full name" do
+      expect(Chef::ResourceHelpers::CronValidations.validate_dow("monday")).to be true
+    end
+
     it "returns false for an invalid string" do
-      expect(Chef::ResourceHelpers::CronValidations.validate_dow("monday")).to be false
+      expect(Chef::ResourceHelpers::CronValidations.validate_dow("funday")).to be false
     end
   end
 

data/spec/unit/resource/homebrew_cask_spec.rb

@@ -19,22 +19,40 @@ require "spec_helper"
 
 describe Chef::Resource::HomebrewCask do
 
-  let(:resource) { Chef::Resource::HomebrewCask.new("fakey_fakerton") }
+  context "name with under bar" do
+    let(:resource) { Chef::Resource::HomebrewCask.new("fakey_fakerton") }
 
-  it "has a resource name of :homebrew_cask" do
-    expect(resource.resource_name).to eql(:homebrew_cask)
-  end
+    it "has a resource name of :homebrew_cask" do
+      expect(resource.resource_name).to eql(:homebrew_cask)
+    end
+
+    it "the cask_name property is the name_property" do
+      expect(resource.cask_name).to eql("fakey_fakerton")
+    end
+
+    it "sets the default action as :install" do
+      expect(resource.action).to eql([:install])
+    end
 
-  it "the cask_name property is the name_property" do
-    expect(resource.cask_name).to eql("fakey_fakerton")
+    it "supports :install, :remove actions" do
+      expect { resource.action :install }.not_to raise_error
+      expect { resource.action :remove }.not_to raise_error
+    end
   end
 
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
+  context "name with high fun" do
+    let(:resource) { Chef::Resource::HomebrewCask.new("fakey-fakerton") }
+
+    it "the cask_name property is the name_property" do
+      expect(resource.cask_name).to eql("fakey-fakerton")
+    end
   end
 
-  it "supports :install, :remove actions" do
-    expect { resource.action :install }.not_to raise_error
-    expect { resource.action :remove }.not_to raise_error
+  context "name with at mark" do
+    let(:resource) { Chef::Resource::HomebrewCask.new("fakey-fakerton@10") }
+
+    it "the cask_name property is the name_property" do
+      expect(resource.cask_name).to eql("fakey-fakerton@10")
+    end
   end
 end

data/spec/unit/resource/homebrew_update_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Chef::Resource::HomebrewUpdate do
+  let(:node) { Chef::Node.new }
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:resource) { Chef::Resource::HomebrewUpdate.new("update", run_context) }
+
+  let(:stamp_dir) { Dir.mktmpdir("brew_update_periodic") }
+  let(:stamp_file) { Dir.mktmpdir("apt_update_periodic") }
+  let(:brew_update_cmd) { %w{homebrew update} }
+
+  it "sets the default action as :periodic" do
+    expect(resource.action).to eql([:periodic])
+  end
+
+  it "supports :periodic, :update actions" do
+    expect { resource.action :periodic }.not_to raise_error
+    expect { resource.action :update }.not_to raise_error
+  end
+
+  it "default frequency is set to be 1 da1y" do
+    expect(resource.frequency).to eql(86_400)
+  end
+
+  it "frequency accepts integers" do
+    resource.frequency(400)
+    expect(resource.frequency).to eql(400)
+  end
+end

data/spec/unit/resource/ifconfig_spec.rb

@@ -90,19 +90,11 @@ describe Chef::Resource::Ifconfig do
     it_should_behave_like "being a platform based on RedHat", "redhat", "4.0"
   end
 
-  describe "when it is an old Debian platform" do
-    it_should_behave_like "being a platform based on an old Debian", "debian", "6.0"
-  end
-
-  describe "when it is a new Debian platform" do
+  describe "when it is a Debian platform" do
     it_should_behave_like "being a platform based on a recent Debian", "debian", "7.0"
   end
 
-  describe "when it is an old Ubuntu platform" do
-    it_should_behave_like "being a platform based on an old Debian", "ubuntu", "11.04"
-  end
-
-  describe "when it is a new Ubuntu platform" do
+  describe "when it is a Ubuntu platform" do
     it_should_behave_like "being a platform based on a recent Debian", "ubuntu", "11.10"
   end