Refactor spec tests

Author: stschulte

spec/integration/provider/oratab/parsed_spec.rb

@@ -8,51 +8,87 @@
 
   before :each do
     described_class.stubs(:suitable?).returns true
+    described_class.stubs(:default_target).returns fake_oratab
     Puppet::Type.type(:oratab).stubs(:defaultprovider).returns described_class
+  end
 
-    @fake_oratab = tmpfilename('oratab')
-    FileUtils.cp(my_fixture('input'), @fake_oratab)
-    described_class.stubs(:default_target).returns @fake_oratab
+  let :fake_oratab do
+    filename = tmpfilename('oratab')
+    unless File.exists? filename
+      FileUtils.cp(my_fixture('input'), filename)
+    end
+    filename
+  end
 
-    @resource_absent = Puppet::Type.type(:oratab).new(
+  # this resource is absent in our fake oratab
+  let :resource_absent do
+    Puppet::Type.type(:oratab).new(
       :name   => 'NO_SUCH_DATABASE',
       :ensure => :absent
     )
-    @resource_present = Puppet::Type.type(:oratab).new(
+  end
+
+  # this resource is present in our fake oratab and completly insync
+  let :resource_present do
+    Puppet::Type.type(:oratab).new(
       :name   => 'DB_INSYNC',
       :ensure => :present,
       :home   => '/u01/app/oracle/product/10.1.0/db_1',
       :atboot => :yes
     )
-    @resource_create = Puppet::Type.type(:oratab).new(
+  end
+
+  # this resource is not present in our fake oratab
+  let :resource_create do
+    Puppet::Type.type(:oratab).new(
       :name        => 'DB_CREATE',
       :ensure      => :present,
       :home        => '/u01/app/oracle/product/10.1.0/db_2',
       :description => 'added by puppet',
       :atboot      => :no
     )
-    @resource_delete = Puppet::Type.type(:oratab).new(
+  end
+
+  # this resource is present in our fake oratab
+  let :resource_delete do
+    Puppet::Type.type(:oratab).new(
       :name   => 'DB_DELETE',
       :ensure => :absent
     )
-    @resource_sync_home = Puppet::Type.type(:oratab).new(
+  end
+
+  # this resource is present in our fake oratab but with :home => '/u01/app/oracle/product/10.1.0/db_4'
+  let :resource_sync_home do
+     Puppet::Type.type(:oratab).new(
       :name   => 'DB_SYNC_HOME',
       :ensure => :present,
       :home   => '/new/home'
     )
-    @resource_sync_atboot = Puppet::Type.type(:oratab).new(
+  end
+
+  # this resource is present in our fake oratab but with :atboot => :no
+  let :resource_sync_atboot do
+     Puppet::Type.type(:oratab).new(
       :name   => 'DB_SYNC_ATBOOT',
       :ensure => :present,
       :home   => '/u01/app/oracle/product/10.1.0/db_1',
       :atboot => :yes
     )
-    @resource_sync_description = Puppet::Type.type(:oratab).new(
+  end
+
+  # this resource is present in our fake oratab but with :description => 'change me'
+  let :resource_sync_description do
+    Puppet::Type.type(:oratab).new(
       :name        => 'DB_SYNC_DESCRIPTION',
       :ensure      => :present,
       :atboot      => :no,
       :description => 'new desc'
     )
-    @resource_delete_description = Puppet::Type.type(:oratab).new(
+  end
+
+  # this resource is present in our fake oratab but with :description => 'delete me'
+  let :resource_delete_description do
+    Puppet::Type.type(:oratab).new(
       :name        => 'DB_DELETE_DESCRIPTION',
       :ensure      => :present,
       :description => ''
@@ -75,7 +111,7 @@ def run_in_catalog(*resources)
   end
 
   def check_content_against(fixture)
-    content = File.read(@fake_oratab).lines.map{|l| l.chomp}.reject{|l| l=~ /^\s*#|^\s*$/}.sort.join("\n")
+    content = File.read(fake_oratab).lines.map{|l| l.chomp}.reject{|l| l=~ /^\s*#|^\s*$/}.sort.join("\n")
     expected_content = File.read(my_fixture(fixture)).lines.map{|l| l.chomp}.reject{|l| l=~ /^\s*#|^\s*$/}.sort.join("\n")
     content.should == expected_content
   end
@@ -84,44 +120,44 @@ def check_content_against(fixture)
 
     describe "with ensure set to absent" do
       it "should do nothing if already absent" do
-        run_in_catalog(@resource_absent)
+        run_in_catalog(resource_absent)
         check_content_against('input')
       end
 
       it "should remove oratab entry if currently present" do
-        run_in_catalog(@resource_delete)
+        run_in_catalog(resource_delete)
         check_content_against('output_single_delete')
       end
     end
 
     describe "with ensure set to present" do
       it "should do nothing if already present and in sync" do
-        run_in_catalog(@resource_present)
+        run_in_catalog(resource_present)
         check_content_against('input')
       end
 
       it "should create an oratab entry if currently absent" do
-        run_in_catalog(@resource_create)
+        run_in_catalog(resource_create)
         check_content_against('output_single_create')
       end
 
       it "should sync home if out of sync" do
-        run_in_catalog(@resource_sync_home)
+        run_in_catalog(resource_sync_home)
         check_content_against('output_single_sync_home')
       end
 
       it "should sync atboot if out of sync" do
-        run_in_catalog(@resource_sync_atboot)
+        run_in_catalog(resource_sync_atboot)
         check_content_against('output_single_sync_atboot')
       end
 
       it "should sync description if out sync" do
-        run_in_catalog(@resource_sync_description)
+        run_in_catalog(resource_sync_description)
         check_content_against('output_single_sync_description')
       end
 
       it "should remove the description (including the #-sign) if description is empty" do
-        run_in_catalog(@resource_delete_description)
+        run_in_catalog(resource_delete_description)
         check_content_against('output_single_sync_description_delete')
       end
     end
@@ -130,14 +166,14 @@ def check_content_against(fixture)
   describe "when managing multiple resources" do
     it "should to the right thing (tm)" do
       run_in_catalog(
-        @resource_absent,
-        @resource_present,
-        @resource_create,
-        @resource_delete,
-        @resource_sync_home,
-        @resource_sync_atboot,
-        @resource_sync_description,
-        @resource_delete_description
+        resource_absent,
+        resource_present,
+        resource_create,
+        resource_delete,
+        resource_sync_home,
+        resource_sync_atboot,
+        resource_sync_description,
+        resource_delete_description
       )
       check_content_against('output_multiple')
     end

spec/unit/provider/oratab/parsed_spec.rb

@@ -8,26 +8,28 @@
     described_class.stubs(:suitable?).returns true
     described_class.stubs(:default_target).returns my_fixture('oratab')
     Puppet::Type.type(:oratab).stubs(:defaultprovider).returns described_class
-    @resource = Puppet::Type.type(:oratab).new(
+  end
+
+  let :provider do
+    described_class.new(
       :name        => 'TEST01',
       :ensure      => :present,
       :home        => '/u01/app/oracle/product/9.2.0.1.0',
       :atboot      => :yes,
-      :description => 'managed by puppet'
+      :description => 'managed by puppet',
     )
-    @provider = described_class.new(@resource)
   end
 
   [:destroy, :create, :exists?].each do |method|
     it "should respond to #{method}" do
-      @provider.should respond_to method
+      provider.should respond_to method
     end
   end
 
   [:home, :atboot, :description].each do |property|
     it "should have getter and setter for property #{property}" do
-      @provider.should respond_to property
-      @provider.should respond_to "#{property}=".intern
+      provider.should respond_to property
+      provider.should respond_to "#{property}=".intern
     end
   end
 

spec/unit/type/oratab_spec.rb

@@ -4,12 +4,6 @@
 
 describe Puppet::Type.type(:oratab) do
 
-  before do
-    @provider_class = described_class.provide(:fake) { mk_resource_methods }
-    @provider_class.stubs(:suitable?).returns true
-    described_class.stubs(:defaultprovider).returns @provider_class
-  end
-
   it "should have :name as its keyattribute" do
     described_class.key_attributes.should == [:name]
   end
@@ -32,60 +26,60 @@
 
     describe "for ensure" do
       it "should support present" do
-        proc { described_class.new(:name => 'foo', :ensure => :present) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :ensure => :present) }.to_not raise_error
       end
 
       it "should support absent" do
-        proc { described_class.new(:name => 'foo', :ensure => :absent) }.should_not raise_error
+        expect { described_class.new(:name => 'foo', :ensure => :absent) }.to_not raise_error
       end
 
       it "should not support other values" do
-        proc { described_class.new(:name => 'foo', :ensure => :foo) }.should raise_error(Puppet::Error, /Invalid value/)
+        expect { described_class.new(:name => 'foo', :ensure => :foo) }.to raise_error(Puppet::Error, /Invalid value/)
       end
     end
 
     describe "for name" do
       it "should support a valid name" do
-        proc { described_class.new(:name => 'TEST01E', :ensure => :present) }.should_not raise_error
-        proc { described_class.new(:name => 'MY_FANCY_DB', :ensure => :present) }.should_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :ensure => :present) }.to_not raise_error
+        expect { described_class.new(:name => 'MY_FANCY_DB', :ensure => :present) }.to_not raise_error
       end
 
       it "should not support whitespace" do
-        proc { described_class.new(:name => 'TEST 01E', :ensure => :present) }.should raise_error(Puppet::Error, /Name.*whitespace/)
-        proc { described_class.new(:name => 'TEST01E ', :ensure => :present) }.should raise_error(Puppet::Error, /Name.*whitespace/)
-        proc { described_class.new(:name => ' TEST01E', :ensure => :present) }.should raise_error(Puppet::Error, /Name.*whitespace/)
-        proc { described_class.new(:name => "TEST\t01E", :ensure => :present) }.should raise_error(Puppet::Error, /Name.*whitespace/)
+        expect { described_class.new(:name => 'TEST 01E', :ensure => :present) }.to raise_error(Puppet::Error, /Name.*whitespace/)
+        expect { described_class.new(:name => 'TEST01E ', :ensure => :present) }.to raise_error(Puppet::Error, /Name.*whitespace/)
+        expect { described_class.new(:name => ' TEST01E', :ensure => :present) }.to raise_error(Puppet::Error, /Name.*whitespace/)
+        expect { described_class.new(:name => "TEST\t01E", :ensure => :present) }.to raise_error(Puppet::Error, /Name.*whitespace/)
       end
 
       it "should not support an empty name" do
-        proc { described_class.new(:name => '', :ensure => :present) }.should raise_error(Puppet::Error, /Name.*empty/)
+        expect { described_class.new(:name => '', :ensure => :present) }.to raise_error(Puppet::Error, /Name.*empty/)
       end
     end
 
     describe "for home" do
       it "should support an absolute  path" do
-        proc { described_class.new(:name => 'TEST01E', :home => '/my/home', :ensure => :present) }.should_not raise_error
-        proc { described_class.new(:name => 'TEST01E', :home => '/my/fancy path', :ensure => :present) }.should_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :home => '/my/home', :ensure => :present) }.to_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :home => '/my/fancy path', :ensure => :present) }.to_not raise_error
       end
       it "should not support a relative path" do
-        proc { described_class.new(:name => 'TEST01E', :home => './my/home', :ensure => :present) }.should raise_error(Puppet::Error, /Home must be an absolute path/)
-        proc { described_class.new(:name => 'TEST01E', :home => 'my/home', :ensure => :present) }.should raise_error(Puppet::Error, /Home must be an absolute path/)
+        expect { described_class.new(:name => 'TEST01E', :home => './my/home', :ensure => :present) }.to raise_error(Puppet::Error, /Home must be an absolute path/)
+        expect { described_class.new(:name => 'TEST01E', :home => 'my/home', :ensure => :present) }.to raise_error(Puppet::Error, /Home must be an absolute path/)
       end
     end
 
     describe "for atboot" do
       it "should support yes" do
-        proc { described_class.new(:name => 'TEST01E', :atboot => :yes) }.should_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :atboot => :yes) }.to_not raise_error
       end
 
       it "should support no" do
-        proc { described_class.new(:name => 'TEST01E', :atboot => :no) }.should_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :atboot => :no) }.to_not raise_error
       end
       it "should support Y" do
-        proc { described_class.new(:name => 'TEST01E', :atboot => :Y) }.should_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :atboot => :Y) }.to_not raise_error
       end
       it "should support N" do
-        proc { described_class.new(:name => 'TEST01E', :atboot => :N) }.should_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :atboot => :N) }.to_not raise_error
       end
       it "should alias Y to yes" do
         described_class.new(:name => 'TEST01E', :atboot => :Y)[:atboot].should == :yes
@@ -94,16 +88,15 @@
         described_class.new(:name => 'TEST01E', :atboot => :N)[:atboot].should == :no
       end
       it "should not support other values" do
-        proc { described_class.new(:name => 'TEST01E', :atboot => :yess) }.should raise_error(Puppet::Error, /Invalid value/)
+        expect { described_class.new(:name => 'TEST01E', :atboot => :yess) }.to raise_error(Puppet::Error, /Invalid value/)
       end
     end
 
     describe "for description" do
       it "should support a valid description" do
-        proc { described_class.new(:name => 'TEST01E', :description => 'added by agent install') }.should_not raise_error
+        expect { described_class.new(:name => 'TEST01E', :description => 'added by agent install') }.to_not raise_error
       end
     end
 
   end
 end
-