backup 3.0.26 → 3.0.27

data/spec/configuration/helpers_spec.rb

@@ -8,25 +8,30 @@ describe 'Backup::Configuration::Helpers' do
     module Backup
       class Foo
         include Backup::Configuration::Helpers
-        attr_accessor :accessor
+        attr_accessor :accessor, :accessor_two
         attr_reader :reader
+
         attr_deprecate :removed,
                        :version => '1.1'
-        attr_deprecate :replaced,
+
+        attr_deprecate :removed_with_message,
                        :version => '1.2',
-                       :replacement => :accessor
-        attr_deprecate :replaced_with_value,
+                       :message => 'This has no replacement.'
+
+        attr_deprecate :removed_with_action,
                        :version => '1.3',
-                       :replacement => :accessor,
-                       :value => 'new_value'
-        attr_deprecate :replaced_with_lambda,
-                       :version => '1.4',
-                       :replacement => :accessor,
-                       :value => lambda {|val| val ? '1' : '0' }
-        attr_deprecate :replaced_with_lambda_nil,
+                       :action => lambda {|klass, val|
+                         klass.accessor = val ? '1' : '0'
+                         klass.accessor_two = 'updated'
+                       }
+
+        attr_deprecate :removed_with_action_and_message,
                        :version => '1.4',
-                       :replacement => :accessor,
-                       :value => Proc.new {}
+                       :message => "Updating accessors.",
+                       :action => lambda {|klass, val|
+                         klass.accessor = val ? '1' : '0'
+                         klass.accessor_two = 'updated'
+                       }
       end
     end
   end
@@ -55,7 +60,8 @@ describe 'Backup::Configuration::Helpers' do
     it 'should cache the Configuration::Store for the class' do
       Backup::Foo.instance_variable_get(:@configuration).should be_nil
       Backup::Foo.defaults.should be(configuration)
-      Backup::Foo.instance_variable_get(:@configuration).should be(configuration)
+      Backup::Foo.instance_variable_get(
+          :@configuration).should be(configuration)
       Backup::Foo.defaults.should be(configuration)
     end
   end
@@ -75,7 +81,7 @@ describe 'Backup::Configuration::Helpers' do
   describe '.deprecations' do
     it 'should return @deprecations' do
       Backup::Foo.deprecations.should be_a(Hash)
-      Backup::Foo.deprecations.keys.count.should be(5)
+      Backup::Foo.deprecations.keys.count.should be(4)
     end
 
     it 'should set @deprecations to an empty hash if not set' do
@@ -91,42 +97,40 @@ describe 'Backup::Configuration::Helpers' do
 
     it 'should add deprected attributes' do
       Backup::Foo.send(:attr_deprecate, :attr1)
-      Backup::Foo.send(:attr_deprecate, :attr2, :version => '1.3')
-      Backup::Foo.send(:attr_deprecate, :attr3, :replacement => :new_attr3)
+      Backup::Foo.send(:attr_deprecate, :attr2,
+                       :version => '2')
+      Backup::Foo.send(:attr_deprecate, :attr3,
+                       :version => '3',
+                       :message => 'attr3 message')
       Backup::Foo.send(:attr_deprecate, :attr4,
-                       :version => '1.4', :replacement => :new_attr4)
-      Backup::Foo.send(:attr_deprecate, :attr5,
-                       :version => '1.5',
-                       :replacement => :new_attr5,
-                       :value => 'new_value')
+                       :version => '4',
+                       :message => 'attr4 message',
+                       :action  => 'attr4 action')
 
       Backup::Foo.deprecations.should == {
         :attr1 => { :version => nil,
-                    :replacement => nil,
-                    :value => nil },
-        :attr2 => { :version => '1.3',
-                    :replacement => nil,
-                    :value => nil },
-        :attr3 => { :version => nil,
-                    :replacement => :new_attr3,
-                    :value => nil },
-        :attr4 => { :version => '1.4',
-                    :replacement => :new_attr4,
-                    :value => nil },
-        :attr5 => { :version => '1.5',
-                    :replacement => :new_attr5,
-                    :value => 'new_value' }
+                    :message => nil,
+                    :action  => nil },
+        :attr2 => { :version => '2',
+                    :message => nil,
+                    :action  => nil },
+        :attr3 => { :version => '3',
+                    :message => 'attr3 message',
+                    :action  => nil },
+        :attr4 => { :version => '4',
+                    :message => 'attr4 message',
+                    :action  => 'attr4 action' }
       }
     end
   end
 
   describe '.log_deprecation_warning' do
-    context 'when a replacement is specified' do
+    context 'when no message given' do
       it 'should log a warning that the attribute has been removed' do
         Backup::Logger.expects(:warn).with do |err|
           err.message.should ==
               "ConfigurationError: [DEPRECATION WARNING]\n" +
-              "  Backup::Foo.removed has been deprecated as of backup v.1.1"
+              "  Backup::Foo#removed has been deprecated as of backup v.1.1"
         end
 
         deprecation = Backup::Foo.deprecations[:removed]
@@ -134,21 +138,22 @@ describe 'Backup::Configuration::Helpers' do
       end
     end
 
-    context 'when no replacement is specified' do
-      it 'should log a warning that the attribute has been replaced' do
+    context 'when a message is given' do
+      it 'should log warning with the message' do
         Backup::Logger.expects(:warn).with do |err|
           err.message.should ==
               "ConfigurationError: [DEPRECATION WARNING]\n" +
-              "  Backup::Foo.replaced has been deprecated as of backup v.1.2\n" +
-              "  This setting has been replaced with:\n" +
-              "  Backup::Foo.accessor"
+              "  Backup::Foo#removed_with_message has been deprecated " +
+              "as of backup v.1.2\n" +
+              "  This has no replacement."
         end
 
-        deprecation = Backup::Foo.deprecations[:replaced]
-        Backup::Foo.log_deprecation_warning(:replaced, deprecation)
+        deprecation = Backup::Foo.deprecations[:removed_with_message]
+        Backup::Foo.log_deprecation_warning(:removed_with_message, deprecation)
+
       end
     end
-  end
+  end # describe '.log_deprecation_warning'
 
   describe '#load_defaults!' do
     let(:klass) { Backup::Foo.new }
@@ -183,224 +188,60 @@ describe 'Backup::Configuration::Helpers' do
     end
   end
 
-  describe '#missing_method' do
-    describe 'instantiating a class when defaults have been set' do
-      context 'when the missing method is an attribute set operator' do
-        context 'and the method has been deprecated' do
-          context 'and the deprecated method has a replacement' do
-            context 'and a replacement value is specified' do
-              it 'should set the the replacement value on the replacement' do
-                Backup::Foo.defaults do |f|
-                  f.replaced_with_value = 'attr_value'
-                end
-
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-                Backup::Logger.expects(:warn).with(
-                  "Backup::Foo.accessor is being set to 'new_value'"
-                )
-
-                klass = Backup::Foo.new
-                klass.send(:load_defaults!)
-                klass.accessor.should == 'new_value'
-              end
-            end
-
-            context 'and the replacement value is a lambda' do
-              it 'should set replacement value using the lambda' do
-                value = [true, false].shuffle.first
-                new_value = value ? '1' : '0'
-
-                Backup::Foo.defaults do |f|
-                  f.replaced_with_lambda = value
-                end
-
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-                Backup::Logger.expects(:warn).with(
-                  "Backup::Foo.accessor is being set to '#{ new_value }'"
-                )
-
-                klass = Backup::Foo.new
-                klass.send(:load_defaults!)
-                klass.accessor.should == new_value
-              end
-
-              it 'should not set the replacement if the lambda returns nil' do
-                Backup::Foo.defaults do |f|
-                  f.replaced_with_lambda_nil = 'foo'
-                end
-
-                Backup::Foo.any_instance.expects(:accessor=).never
-
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-
-                klass = Backup::Foo.new
-                klass.send(:load_defaults!)
-                klass.accessor.should be_nil
-              end
-            end
-
-            context 'and no replacement value is specified' do
-              it 'should set the original value on the replacement' do
-                Backup::Foo.defaults do |f|
-                  f.replaced = 'attr_value'
-                end
-
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-                Backup::Logger.expects(:warn).with(
-                  "Backup::Foo.accessor is being set to 'attr_value'"
-                )
-
-                klass = Backup::Foo.new
-                klass.send(:load_defaults!)
-                klass.accessor.should == 'attr_value'
-              end
-            end
-          end
-
-          context 'and the deprecated method has no replacement' do
-            it 'should only log a warning' do
-              Backup::Foo.defaults do |f|
-                f.removed = 'attr_value'
-              end
-
-              Backup::Logger.expects(:warn).with(
-                instance_of(Backup::Errors::ConfigurationError)
-              )
-
-              klass = Backup::Foo.new
-              klass.send(:load_defaults!)
-              klass.accessor.should be_nil
-            end
-          end
-        end
+  describe '#method_missing' do
+    context 'when the method is a deprecated method' do
+      before do
+        Backup::Logger.expects(:warn).with(
+          instance_of(Backup::Errors::ConfigurationError)
+        )
+      end
 
-        context 'and the method is not a deprecated method' do
-          it 'should raise a NoMethodError' do
-            Backup::Foo.defaults do |f|
-              f.foobar = 'attr_value'
-            end
+      context 'when an :action is specified' do
+        it 'should call the :action' do
+          value = [true, false].shuffle.first
+          expected_value = value ? '1' : '0'
 
-            Backup::Logger.expects(:warn).never
+          klass = Backup::Foo.new
+          klass.removed_with_action = value
 
-            klass = Backup::Foo.new
-            expect do
-              klass.send(:load_defaults!)
-            end.to raise_error(NoMethodError)
-          end
+          klass.accessor.should == expected_value
+          # lambda additionally sets :accessor_two
+          klass.accessor_two.should == 'updated'
         end
       end
-    end # describe 'instantiating a class when defaults have been set'
-
-    describe 'instantiating a new class and directly setting values' do
-      context 'when the missing method is an attribute set operator' do
-        context 'and the method has been deprecated' do
-          context 'and the deprecated method has a replacement' do
-            context 'and a replacement value is specified' do
-              it 'should set the the replacement value on the replacement' do
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-                Backup::Logger.expects(:warn).with(
-                  "Backup::Foo.accessor is being set to 'new_value'"
-                )
-
-                klass = Backup::Foo.new
-                klass.replaced_with_value = 'attr_value'
-                klass.accessor.should == 'new_value'
-              end
-            end
-
-            context 'and the replacement value is a lambda' do
-              it 'should set replacement value using the lambda' do
-                value = [true, false].shuffle.first
-                new_value = value ? '1' : '0'
-
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-                Backup::Logger.expects(:warn).with(
-                  "Backup::Foo.accessor is being set to '#{ new_value }'"
-                )
-
-                klass = Backup::Foo.new
-                klass.replaced_with_lambda = value
-                klass.accessor.should == new_value
-              end
-
-              it 'should not set the replacement if the lambda returns nil' do
-                Backup::Foo.any_instance.expects(:accessor=).never
-
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-
-                klass = Backup::Foo.new
-                klass.replaced_with_lambda_nil = 'foo'
-                klass.accessor.should be_nil
-              end
-            end
-
-            context 'and no replacement value is specified' do
-              it 'should set the original value on the replacement' do
-                Backup::Logger.expects(:warn).with(
-                  instance_of(Backup::Errors::ConfigurationError)
-                )
-                Backup::Logger.expects(:warn).with(
-                  "Backup::Foo.accessor is being set to 'attr_value'"
-                )
-
-                klass = Backup::Foo.new
-                klass.replaced = 'attr_value'
-                klass.accessor.should == 'attr_value'
-              end
-            end
-          end
-
-
-          context 'and the deprecated method has no replacement' do
-            it 'should only log a warning' do
-              Backup::Logger.expects(:warn).with(
-                instance_of(Backup::Errors::ConfigurationError)
-              )
-
-              klass = Backup::Foo.new
-              klass.removed = 'attr_value'
-              klass.accessor.should be_nil
-            end
-          end
-        end
 
-        context 'and the method is not a deprecated method' do
-          it 'should raise a NoMethodError' do
-            Backup::Logger.expects(:warn).never
+      context 'when no :action is specified' do
+        it 'should only log the warning' do
+          Backup::Foo.any_instance.expects(:accessor=).never
 
-            klass = Backup::Foo.new
-            expect do
-              klass.foobar = 'attr_value'
-            end.to raise_error(NoMethodError)
-          end
+          klass = Backup::Foo.new
+          klass.removed = 'foo'
+
+          klass.accessor.should be_nil
         end
       end
+    end
 
-      context 'when the missing method is not a set operation' do
-        it 'should raise a NoMethodError' do
-          Backup::Logger.expects(:warn).never
+    context 'when the method is not a deprecated method' do
+      it 'should raise a NoMethodError' do
+        Backup::Logger.expects(:warn).never
 
-          klass = Backup::Foo.new
-          expect do
-            klass.removed
-          end.to raise_error(NoMethodError)
-        end
+        klass = Backup::Foo.new
+        expect do
+          klass.foobar = 'attr_value'
+        end.to raise_error(NoMethodError)
       end
-    end # describe 'instantiating a new class and directly setting values'
-  end
+    end
+
+    context 'when the method is not a set operation' do
+      it 'should raise a NoMethodError' do
+        Backup::Logger.expects(:warn).never
 
+        klass = Backup::Foo.new
+        expect do
+          klass.removed
+        end.to raise_error(NoMethodError)
+      end
+    end
+  end # describe '#method_missing'
 end

data/spec/database/mongodb_spec.rb

@@ -473,19 +473,18 @@ describe Backup::Database::MongoDB do
   end
 
   describe 'deprecations' do
-    after do
-      Backup::Database::MongoDB.clear_defaults!
-    end
-
     describe '#utility_path' do
       before do
         Backup::Database::MongoDB.any_instance.stubs(:utility)
-        Backup::Logger.expects(:warn).with(
-          instance_of(Backup::Errors::ConfigurationError)
-        )
-        Backup::Logger.expects(:warn).with(
-          "Backup::Database::MongoDB.mongodump_utility is being set to 'foo'"
-        )
+        Backup::Logger.expects(:warn).with {|err|
+          err.should be_an_instance_of Backup::Errors::ConfigurationError
+          err.message.should match(
+            /Use MongoDB#mongodump_utility instead/
+          )
+        }
+      end
+      after do
+        Backup::Database::MongoDB.clear_defaults!
       end
 
       context 'when set directly' do