database_cleaner 1.6.2 → 1.7.0

data/spec/database_cleaner/data_mapper/truncation_spec.rb

@@ -1,11 +0,0 @@
-require 'database_cleaner/data_mapper/truncation'
-require 'database_cleaner/shared_strategy'
-
-module DatabaseCleaner
-  module DataMapper
-    describe Truncation do
-      it_should_behave_like "a generic strategy"
-      it_should_behave_like "a generic truncation strategy"
-    end
-  end
-end

data/spec/database_cleaner/generic/base_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/shared_strategy'
-require 'database_cleaner/generic/base'
-require 'active_record'
-
-module ::DatabaseCleaner
-  module Generic
-    class ExampleStrategy
-      include ::DatabaseCleaner::Generic::Base
-
-      def start; end
-    end
-
-    describe ExampleStrategy do
-      context "class methods" do
-        subject { ExampleStrategy }
-
-        describe "#available_strategies" do
-          it "should have available strategies" do
-            expect(subject.available_strategies).to be_empty
-          end
-        end
-      end
-
-      it_should_behave_like "a generic strategy"
-
-      describe "#db" do
-        it "should be :default" do
-          expect(subject.db).to eql(:default)
-        end
-      end
-
-      describe "#cleaning" do
-        let (:connection) { double("connection") }
-        let (:strategy) { ExampleStrategy.new }
-        before do
-          # DatabaseCleaner.strategy = :truncation
-          connection.stub(:disable_referential_integrity).and_yield
-          connection.stub(:database_cleaner_view_cache).and_return([])
-          connection.stub(:database_cleaner_table_cache).and_return([])
-          ::ActiveRecord::Base.stub(:connection).and_return(connection)
-        end
-
-        it "calls #clean even if there is an exception" do
-          strategy.should_receive :clean
-          expect do
-            strategy.cleaning do
-              raise NoMethodError
-            end
-          end.to raise_exception(NoMethodError)
-        end
-
-        it "calls #clean after processing the block" do
-          strategy.should_receive :clean
-          strategy.cleaning do
-          end
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/generic/truncation_spec.rb

@@ -1,118 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/generic/truncation'
-
-module ::DatabaseCleaner
-  module Generic
-    class TruncationExample
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def only
-        @only
-      end
-
-      def except
-        @tables_to_exclude
-      end
-
-      def reset_ids?
-        !!@reset_ids
-      end
-
-      def pre_count?
-        !!@pre_count
-      end
-    end
-
-    class MigrationExample < TruncationExample
-      def migration_storage_names
-        %w[migration_storage_name]
-      end
-    end
-
-    describe TruncationExample do
-      subject(:truncation_example) { TruncationExample.new }
-
-      it "will start" do
-        expect { truncation_example.start }.to_not raise_error
-      end
-
-      it "expects clean to be implemented later" do
-        expect { truncation_example.clean }.to raise_error(NotImplementedError)
-      end
-
-      context "private methods" do
-        it { should_not respond_to(:tables_to_truncate) }
-
-        it 'expects #tables_to_truncate to be implemented later' do
-          expect{ truncation_example.send :tables_to_truncate }.to raise_error(NotImplementedError)
-        end
-
-        it { should_not respond_to(:migration_storage_names) }
-        its(:migration_storage_names) { should be_empty }
-      end
-
-      describe "initialize" do
-        it { expect{ subject }.to_not raise_error }
-
-        it "should accept a hash of options" do
-          expect{ TruncationExample.new {} }.to_not raise_error
-        end
-
-        it { expect{ TruncationExample.new( { :a_random_param => "should raise ArgumentError"  } ) }.to     raise_error(ArgumentError) }
-        it { expect{ TruncationExample.new( { :except => "something",:only => "something else" } ) }.to     raise_error(ArgumentError) }
-        it { expect{ TruncationExample.new( { :only   => "something"                           } ) }.to_not raise_error }
-        it { expect{ TruncationExample.new( { :except => "something"                           } ) }.to_not raise_error }
-        it { expect{ TruncationExample.new( { :pre_count => "something"                        } ) }.to_not raise_error }
-        it { expect{ TruncationExample.new( { :reset_ids => "something"                        } ) }.to_not raise_error }
-
-        context "" do
-          subject { TruncationExample.new( { :only => ["something"] } ) }
-          its(:only)   { should eq ["something"] }
-          its(:except) { should eq [] }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :except => ["something"] } ) }
-          its(:only)   { should eq nil }
-          its(:except) { should include("something") }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :reset_ids => ["something"] } ) }
-          its(:reset_ids?) { should eq true }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :reset_ids => nil } ) }
-          its(:reset_ids?) { should eq false }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :pre_count => ["something"] } ) }
-          its(:pre_count?) { should eq true }
-        end
-
-        context "" do
-          subject { TruncationExample.new( { :pre_count => nil } ) }
-          its(:pre_count?) { should eq false }
-        end
-
-        context "" do
-          subject { MigrationExample.new }
-          its(:only)   { should eq nil }
-          its(:except) { should eq %w[migration_storage_name] }
-        end
-
-        context "" do
-          EXCEPT_TABLES = ["something"]
-          subject { MigrationExample.new( { :except => EXCEPT_TABLES } ) }
-
-          it "should not modify the array of excepted tables" do
-            subject.except.should include("migration_storage_name")
-            EXCEPT_TABLES.should_not include("migration_storage_name")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/mongo/mongo_examples.rb

@@ -1,26 +0,0 @@
-module MongoTest
-  class ThingBase
-    def self.collection
-      @connection ||= ::Mongo::Connection.new('127.0.0.1')
-      @db ||= @connection.db('database_cleaner_specs')
-      @mongo ||= @db.collection(name) || @db.create_collection(name)
-    end
-
-    def self.count
-      @mongo.count
-    end
-
-    def initialize(attrs={})
-      @attrs = attrs
-    end
-
-    def save!
-      self.class.collection.insert(@attrs)
-    end
-  end
-
-  class Widget < ThingBase
-  end
-  class Gadget < ThingBase
-  end
-end

data/spec/database_cleaner/mongo/truncation_spec.rb

@@ -1,72 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'mongo'
-require 'database_cleaner/mongo/truncation'
-require File.dirname(__FILE__) + '/mongo_examples'
-
-module DatabaseCleaner
-  module Mongo
-
-    describe Truncation do
-      let(:args) {{}}
-      let(:truncation) { described_class.new(args).tap { |t| t.db=@db } }
-      #doing this in the file root breaks autospec, doing it before(:all) just fails the specs
-      before(:all) do
-        @connection = ::Mongo::Connection.new('127.0.0.1')
-        @test_db = 'database_cleaner_specs'
-        @db = @connection.db(@test_db)
-      end
-
-      after(:each) do
-        @connection.drop_database(@test_db)
-      end
-
-      def ensure_counts(expected_counts)
-        # I had to add this sanity_check garbage because I was getting non-determinisc results from mongo at times..
-        # very odd and disconcerting...
-        expected_counts.each do |model_class, expected_count|
-          model_class.count.should equal(expected_count), "#{model_class} expected to have a count of #{expected_count} but was #{model_class.count}"
-        end
-      end
-
-      def create_widget(attrs={})
-        MongoTest::Widget.new({:name => 'some widget'}.merge(attrs)).save!
-      end
-
-      def create_gadget(attrs={})
-        MongoTest::Gadget.new({:name => 'some gadget'}.merge(attrs)).save!
-      end
-
-      it "truncates all collections by default" do
-        create_widget
-        create_gadget
-        ensure_counts(MongoTest::Widget => 1, MongoTest::Gadget => 1)
-        truncation.clean
-        ensure_counts(MongoTest::Widget => 0, MongoTest::Gadget => 0)
-      end
-
-      context "when collections are provided to the :only option" do
-        let(:args) {{:only => ['MongoTest::Widget']}}
-        it "only truncates the specified collections" do
-          create_widget
-          create_gadget
-          ensure_counts(MongoTest::Widget => 1, MongoTest::Gadget => 1)
-          truncation.clean
-          ensure_counts(MongoTest::Widget => 0, MongoTest::Gadget => 1)
-        end
-      end
-
-      context "when collections are provided to the :except option" do
-        let(:args) {{:except => ['MongoTest::Widget']}}
-        it "truncates all but the specified collections" do
-          create_widget
-          create_gadget
-          ensure_counts(MongoTest::Widget => 1, MongoTest::Gadget => 1)
-          truncation.clean
-          ensure_counts(MongoTest::Widget => 1, MongoTest::Gadget => 0)
-        end
-      end
-
-    end
-
-  end
-end

data/spec/database_cleaner/mongo_mapper/base_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-require 'database_cleaner/mongo_mapper/base'
-require 'database_cleaner/shared_strategy'
-
-module DatabaseCleaner
-  describe MongoMapper do
-    it { should respond_to(:available_strategies) }
-  end
-
-  module MongoMapper
-    class ExampleStrategy
-      include ::DatabaseCleaner::MongoMapper::Base
-    end
-
-    describe ExampleStrategy do
-
-      it_should_behave_like "a generic strategy"
-
-      describe "db" do
-        it { should respond_to(:db=) }
-
-        it "should store my desired db" do
-          subject.db = :my_db
-          subject.db.should eq :my_db
-        end
-
-        it "should default to :default" do
-          subject.db.should eq :default
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/mongo_mapper/mongo_examples.rb

@@ -1,8 +0,0 @@
-class Widget
-  include ::MongoMapper::Document
-  key :name, String
-end
-class Gadget
-  include ::MongoMapper::Document
-  key :name, String
-end

data/spec/database_cleaner/mongo_mapper/truncation_spec.rb

@@ -1,74 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'mongo_mapper'
-require 'database_cleaner/mongo_mapper/truncation'
-require File.dirname(__FILE__) + '/mongo_examples'
-
-module DatabaseCleaner
-  module MongoMapper
-
-    describe Truncation do
-
-      #doing this in the file root breaks autospec, doing it before(:all) just fails the specs
-      before(:all) do
-          ::MongoMapper.connection = ::Mongo::Connection.new('127.0.0.1')
-          @test_db = 'database_cleaner_specs'
-          ::MongoMapper.database = @test_db
-      end
-
-      before(:each) do
-        ::MongoMapper.connection.drop_database(@test_db)
-      end
-
-      def ensure_counts(expected_counts)
-        # I had to add this sanity_check garbage because I was getting non-determinisc results from mongomapper at times..
-        # very odd and disconcerting...
-        sanity_check = expected_counts.delete(:sanity_check)
-        begin
-          expected_counts.each do |model_class, expected_count|
-            model_class.count.should equal(expected_count), "#{model_class} expected to have a count of #{expected_count} but was #{model_class.count}"
-          end
-        rescue RSpec::Expectations::ExpectationNotMetError => e
-          raise !sanity_check ? e : RSpec::ExpectationNotMetError::ExpectationNotMetError.new("SANITY CHECK FAILURE! This should never happen here: #{e.message}")
-        end
-      end
-
-      def create_widget(attrs={})
-        Widget.new({:name => 'some widget'}.merge(attrs)).save!
-      end
-
-      def create_gadget(attrs={})
-        Gadget.new({:name => 'some gadget'}.merge(attrs)).save!
-      end
-
-      it "truncates all collections by default" do
-        create_widget
-        create_gadget
-        ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
-        Truncation.new.clean
-        ensure_counts(Widget => 0, Gadget => 0)
-      end
-
-      context "when collections are provided to the :only option" do
-        it "only truncates the specified collections" do
-          create_widget
-          create_gadget
-          ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
-          Truncation.new(:only => ['widgets']).clean
-          ensure_counts(Widget => 0, Gadget => 1)
-        end
-      end
-
-      context "when collections are provided to the :except option" do
-        it "truncates all but the specified collections" do
-          create_widget
-          create_gadget
-          ensure_counts(Widget => 1, Gadget => 1, :sanity_check => true)
-          Truncation.new(:except => ['widgets']).clean
-          ensure_counts(Widget => 1, Gadget => 0)
-        end
-      end
-
-    end
-
-  end
-end

data/spec/database_cleaner/moped/moped_examples.rb

@@ -1,32 +0,0 @@
-module MopedTest
-  class ThingBase
-    def self.collection
-      @db ||= 'database_cleaner_specs'
-      @session ||= ::Moped::Session.new(['127.0.0.1:27017'], database: @db)
-      @collection ||= @session[name]
-    end
-
-    def self.count
-      @collection.find.count
-    end
-
-    def initialize(attrs={})
-      @attrs = attrs
-    end
-
-    def save!
-      self.class.collection.insert(@attrs)
-    end
-  end
-
-  class Widget < ThingBase
-  end
-  class Gadget < ThingBase
-  end
-  class System < ThingBase
-    def self.collection
-      super
-      @collection = @session['system_logs']
-    end
-  end
-end

data/spec/database_cleaner/moped/truncation_spec.rb

@@ -1,80 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'moped'
-require 'database_cleaner/moped/truncation'
-require File.dirname(__FILE__) + '/moped_examples'
-
-module DatabaseCleaner
-  module Moped
-
-    describe Truncation do
-      let(:args) {{}}
-      let(:truncation) { described_class.new(args) }
-      #doing this in the file root breaks autospec, doing it before(:all) just fails the specs
-      before(:all) do
-        @test_db = 'database_cleaner_specs'
-        @session = ::Moped::Session.new(['127.0.0.1:27017'], database: @test_db)
-      end
-
-      before(:each) do
-        truncation.db = @test_db
-      end
-
-      after(:each) do
-        @session.drop
-      end
-
-      def ensure_counts(expected_counts)
-        # I had to add this sanity_check garbage because I was getting non-determinisc results from mongo at times..
-        # very odd and disconcerting...
-        expected_counts.each do |model_class, expected_count|
-          model_class.count.should equal(expected_count), "#{model_class} expected to have a count of #{expected_count} but was #{model_class.count}"
-        end
-      end
-
-      def create_widget(attrs={})
-        MopedTest::Widget.new({:name => 'some widget'}.merge(attrs)).save!
-      end
-
-      def create_gadget(attrs={})
-        MopedTest::Gadget.new({:name => 'some gadget'}.merge(attrs)).save!
-      end
-
-      def create_system(attrs={})
-        MopedTest::System.new({:name => 'some system'}.merge(attrs)).save!
-      end
-
-      it "truncates all collections by default" do
-        create_widget
-        create_gadget
-        create_system
-        ensure_counts(MopedTest::Widget => 1, MopedTest::Gadget => 1, MopedTest::System => 1)
-        truncation.clean
-        ensure_counts(MopedTest::Widget => 0, MopedTest::Gadget => 0, MopedTest::System => 0)
-      end
-
-      context "when collections are provided to the :only option" do
-        let(:args) {{:only => ['MopedTest::Widget']}}
-        it "only truncates the specified collections" do
-          create_widget
-          create_gadget
-          ensure_counts(MopedTest::Widget => 1, MopedTest::Gadget => 1)
-          truncation.clean
-          ensure_counts(MopedTest::Widget => 0, MopedTest::Gadget => 1)
-        end
-      end
-
-      context "when collections are provided to the :except option" do
-        let(:args) {{:except => ['MopedTest::Widget']}}
-        it "truncates all but the specified collections" do
-          create_widget
-          create_gadget
-          ensure_counts(MopedTest::Widget => 1, MopedTest::Gadget => 1)
-          truncation.clean
-          ensure_counts(MopedTest::Widget => 1, MopedTest::Gadget => 0)
-        end
-      end
-
-    end
-
-  end
-end