database_cleaner 0.6.7 → 2.0.1

data/lib/database_cleaner/data_mapper/truncation.rb

@@ -1,175 +0,0 @@
-require "database_cleaner/generic/truncation"
-require 'database_cleaner/data_mapper/base'
-
-module DataMapper
-  module Adapters
-
-    class DataObjectsAdapter
-
-      def storage_names(repository = :default)
-        raise NotImplementedError
-      end
-
-    end
-
-    class MysqlAdapter < DataObjectsAdapter
-
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        select 'SHOW TABLES'
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)};")
-      end
-
-      # copied from activerecord
-      def disable_referential_integrity
-        old = select("SELECT @@FOREIGN_KEY_CHECKS;")
-        begin
-          execute("SET FOREIGN_KEY_CHECKS = 0;")
-          yield
-        ensure
-          execute("SET FOREIGN_KEY_CHECKS = ?", *old)
-        end
-      end
-
-    end
-
-
-    class Sqlite3Adapter < DataObjectsAdapter
-
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 177
-        sql = <<-SQL.compress_lines
-          SELECT name
-          FROM sqlite_master
-          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
-        SQL
-        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
-        select(sql)
-      end
-
-      def truncate_table(table_name)
-        execute("DELETE FROM #{quote_name(table_name)};")
-      end
-
-      # this is a no-op copied from activerecord
-      # i didn't find out if/how this is possible
-      # activerecord also doesn't do more here
-      def disable_referential_integrity
-        yield
-      end
-
-    end
-
-    class SqliteAdapter < DataObjectsAdapter
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 177
-        sql = <<-SQL.compress_lines
-          SELECT name
-          FROM sqlite_master
-          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
-        SQL
-        # activerecord-2.1.0/lib/active_record/connection_adapters/sqlite_adapter.rb: 181
-        select(sql)
-      end
-
-      def truncate_table(table_name)
-        execute("DELETE FROM #{quote_name(table_name)};")
-      end
-
-      # this is a no-op copied from activerecord
-      # i didn't find out if/how this is possible
-      # activerecord also doesn't do more here
-      def disable_referential_integrity
-        yield
-      end
-
-    end
-
-    # FIXME
-    # i don't know if this works
-    # i basically just copied activerecord code to get a rough idea what they do.
-    # i don't have postgres available, so i won't be the one to write this.
-    # maybe codes below gets some postgres/datamapper user going, though.
-    class PostgresAdapter < DataObjectsAdapter
-
-      # taken from http://github.com/godfat/dm-mapping/tree/master
-      def storage_names(repository = :default)
-        sql = <<-SQL.compress_lines
-          SELECT table_name FROM "information_schema"."tables"
-          WHERE table_schema = current_schema() and table_type = 'BASE TABLE'
-        SQL
-        select(sql)
-      end
-
-      def truncate_table(table_name)
-        execute("TRUNCATE TABLE #{quote_name(table_name)} CASCADE;")
-      end
-
-      # FIXME
-      # copied from activerecord
-      def supports_disable_referential_integrity?
-        version = select("SHOW server_version")[0][0].split('.')
-        (version[0].to_i >= 8 && version[1].to_i >= 1) ? true : false
-      rescue
-        return false
-      end
-
-      # FIXME
-      # copied unchanged from activerecord
-      def disable_referential_integrity(repository = :default)
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} DISABLE TRIGGER ALL"
-          end.join(";"))
-        end
-        yield
-      ensure
-        if supports_disable_referential_integrity? then
-          execute(storage_names(repository).collect do |name|
-            "ALTER TABLE #{quote_name(name)} ENABLE TRIGGER ALL"
-          end.join(";"))
-        end
-      end
-
-    end
-
-  end
-end
-
-
-module DatabaseCleaner
-  module DataMapper
-    class Truncation
-      include ::DatabaseCleaner::DataMapper::Base
-      include ::DatabaseCleaner::Generic::Truncation
-
-      def clean(repository = nil)
-        repository = self.db if repository.nil?
-        adapter = ::DataMapper.repository(repository).adapter
-        adapter.disable_referential_integrity do
-          tables_to_truncate(repository).each do |table_name|
-            adapter.truncate_table table_name
-          end
-        end
-      end
-
-      private
-
-      def tables_to_truncate(repository = nil)
-        repository = self.db if repository.nil?
-        (@only || ::DataMapper.repository(repository).adapter.storage_names(repository)) - @tables_to_exclude
-      end
-
-      # overwritten
-      def migration_storage_name
-        'migration_info'
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/generic/base.rb

@@ -1,23 +0,0 @@
-module ::DatabaseCleaner
-   module Generic
-     module Base
-
-       def self.included(base)
-         base.extend(ClassMethods)
-         base.send(:include, InstanceMethods)
-       end
-
-       module InstanceMethods
-         def db
-           :default
-         end
-       end
-
-       module ClassMethods
-         def available_strategies
-           %W[]
-         end
-       end
-     end
-   end
-end

data/lib/database_cleaner/generic/truncation.rb

@@ -1,43 +0,0 @@
-module DatabaseCleaner
-  module Generic
-    module Truncation
-      def self.included(base)
-       base.send(:include, InstanceMethods)
-      end
-
-      module InstanceMethods
-        def initialize(opts={})
-          if !opts.empty? && !(opts.keys - [:only, :except]).empty?
-            raise ArgumentError, "The only valid options are :only and :except. You specified #{opts.keys.join(',')}."
-          end
-          if opts.has_key?(:only) && opts.has_key?(:except)
-            raise ArgumentError, "You may only specify either :only or :either.  Doing both doesn't really make sense does it?"
-          end
-
-          @only = opts[:only]
-          @tables_to_exclude = (opts[:except] || []).dup
-          @tables_to_exclude << migration_storage_name unless migration_storage_name.nil?
-        end
-
-        def start
-          #included for compatability reasons, do nothing if you don't need to
-        end
-
-        def clean
-          raise NotImplementedError
-        end
-
-        private
-          def tables_to_truncate
-            raise NotImplementedError
-          end
-
-          # overwrite in subclasses
-          # default implementation given because migration storage need not be present
-          def migration_storage_name
-            nil
-          end
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo/truncation.rb

@@ -1,22 +0,0 @@
-module DatabaseCleaner
-  module Mongo
-    module Truncation
-
-      def clean
-        if @only
-          collections.each { |c| c.remove if @only.include?(c.name) }
-        else
-          collections.each { |c| c.remove unless @tables_to_exclude.include?(c.name) }
-        end
-        true
-      end
-
-      private
-
-      def collections
-        database.collections.select { |c| c.name !~ /^system\./ }
-      end
-
-    end
-  end
-end

data/lib/database_cleaner/mongo_mapper/base.rb

@@ -1,20 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module MongoMapper
-    def self.available_strategies
-      %w[truncation]
-    end
-
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db || :default
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongo_mapper/truncation.rb

@@ -1,19 +0,0 @@
-require 'database_cleaner/mongo_mapper/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/mongo/truncation'
-
-module DatabaseCleaner
-  module MongoMapper
-    class Truncation
-      include ::DatabaseCleaner::MongoMapper::Base
-      include ::DatabaseCleaner::Generic::Truncation
-      include ::DatabaseCleaner::Mongo::Truncation
-      
-      private
-
-      def database
-        ::MongoMapper.database
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongoid/base.rb

@@ -1,20 +0,0 @@
-require 'database_cleaner/generic/base'
-module DatabaseCleaner
-  module Mongoid
-    def self.available_strategies
-      %w[truncation]
-    end
-
-    module Base
-      include ::DatabaseCleaner::Generic::Base
-
-      def db=(desired_db)
-        @db = desired_db
-      end
-
-      def db
-        @db || :default
-      end
-    end
-  end
-end

data/lib/database_cleaner/mongoid/truncation.rb

@@ -1,20 +0,0 @@
-require 'database_cleaner/mongoid/base'
-require 'database_cleaner/generic/truncation'
-require 'database_cleaner/mongo/truncation'
-
-module DatabaseCleaner
-  module Mongoid
-    class Truncation
-      include ::DatabaseCleaner::Mongoid::Base
-      include ::DatabaseCleaner::Generic::Truncation
-      include ::DatabaseCleaner::Mongo::Truncation
-
-      private
-
-      def database
-        ::Mongoid.database
-      end
-
-  end
-  end
-end

data/lib/database_cleaner/null_strategy.rb

@@ -1,15 +0,0 @@
-module DatabaseCleaner
-  class NullStrategy
-    def self.start
-      # no-op
-    end
-    
-     def self.db=(connection)
-       # no-op
-     end
-     
-    def self.clean
-      # no-op
-    end
-  end
-end

data/spec/database_cleaner/active_record/base_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper'
-require 'active_record'
-require 'database_cleaner/active_record/base'
-require 'database_cleaner/shared_strategy_spec'
-
-module DatabaseCleaner
-  describe ActiveRecord do
-    it { should respond_to(:available_strategies) }
-
-    describe "config_file_location" do
-      subject { ActiveRecord.config_file_location }
-
-      it "should default to DatabaseCleaner.root / config / database.yml" do
-        ActiveRecord.config_file_location=nil
-        DatabaseCleaner.should_receive(:app_root).and_return("/path/to")
-        subject.should == '/path/to/config/database.yml'
-      end
-    end
-
-  end
-
-  module ActiveRecord
-    class ExampleStrategy
-      include ::DatabaseCleaner::ActiveRecord::Base
-    end
-
-    describe ExampleStrategy do
-      let :config_location do
-        '/path/to/config/database.yml'
-      end
-
-      before { ::DatabaseCleaner::ActiveRecord.stub(:config_file_location).and_return(config_location) }
-
-      it_should_behave_like "a generic strategy"
-
-      describe "db" do
-        it { should respond_to(:db=) }
-
-        it "should store my desired db" do
-          subject.stub(:load_config)
-
-          subject.db = :my_db
-          subject.db.should == :my_db
-        end
-
-        it "should default to :default" do
-          subject.db.should == :default
-        end
-
-        it "should load_config when I set db" do
-          subject.should_receive(:load_config)
-          subject.db = :my_db
-        end
-      end
-
-      describe "load_config" do
-
-        it { should respond_to(:load_config) }
-
-        before do
-          yaml = <<-Y
-my_db:
-  database: <%= "ONE".downcase %>
-          Y
-          File.stub(:file?).with(config_location).and_return(true)
-          IO.stub(:read).with(config_location).and_return(yaml)
-        end
-
-        it "should parse the config" do
-          YAML.should_receive(:load).and_return( {:nil => nil} )
-          subject.load_config
-        end
-
-        it "should process erb in the config" do
-          transformed = <<-Y
-my_db:
-  database: one
-          Y
-          YAML.should_receive(:load).with(transformed).and_return({ "my_db" => {"database" => "one"} })
-          subject.load_config
-        end
-
-        it "should store the relevant config in connection_hash" do
-          subject.should_receive(:db).and_return(:my_db)
-          subject.load_config
-          subject.connection_hash.should == {"database" => "one"}
-        end
-
-        it "should skip config if config file is not available" do
-          File.should_receive(:file?).with(config_location).and_return(false)
-          subject.load_config
-          subject.connection_hash.should be_blank
-        end
-      end
-
-      describe "connection_hash" do
-        it { should respond_to(:connection_hash) }
-        it { should respond_to(:connection_hash=) }
-        it "should store connection_hash" do
-          subject.connection_hash = { :key => "value" }
-          subject.connection_hash.should == { :key => "value" }
-        end
-      end
-
-      describe "create_connection_klass" do
-        it "should return a class" do
-          subject.create_connection_klass.should be_a(Class)
-        end
-
-        it "should return a class extending ::ActiveRecord::Base" do
-          subject.create_connection_klass.ancestors.should include(::ActiveRecord::Base)
-        end
-      end
-
-      describe "connection_klass" do
-        it { expect{ subject.connection_klass }.to_not raise_error }
-        it "should default to ActiveRecord::Base" do
-          subject.connection_klass.should == ::ActiveRecord::Base
-        end
-
-        context "when connection_hash is set" do
-          let(:hash) { mock("hash") }
-          before { subject.stub(:connection_hash).and_return(hash) }
-
-          it "should create connection_klass if it doesnt exist if connection_hash is set" do
-            subject.should_receive(:create_connection_klass).and_return(mock('class').as_null_object)
-            subject.connection_klass
-          end
-
-          it  "should configure the class from create_connection_klass if connection_hash is set" do
-            klass = mock('klass')
-            klass.should_receive(:establish_connection).with(hash)
-
-            subject.should_receive(:create_connection_klass).and_return(klass)
-            subject.connection_klass
-          end
-        end
-      end
-    end
-  end
-end

data/spec/database_cleaner/active_record/transaction_spec.rb

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'database_cleaner/active_record/transaction'
-require 'active_record'
-
-module DatabaseCleaner
-  module ActiveRecord
-
-    describe Transaction do
-      let (:connection) { mock("connection") }
-      before(:each) do
-        ::ActiveRecord::Base.stub!(:connection).and_return(connection)
-      end
-
-      describe "#start" do
-        it "should increment open transactions if possible" do
-          connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(true)
-          connection.stub!(:begin_db_transaction)
-
-          connection.should_receive(:increment_open_transactions)
-          Transaction.new.start
-        end
-
-        it "should tell ActiveRecord to increment connection if its not possible to increment current connection" do
-          connection.stub!(:respond_to?).with(:increment_open_transactions).and_return(false)
-          connection.stub!(:begin_db_transaction)
-
-          ::ActiveRecord::Base.should_receive(:increment_open_transactions)
-          Transaction.new.start
-        end
-
-        it "should start a transaction" do
-            connection.stub!(:increment_open_transactions)
-
-            connection.should_receive(:begin_db_transaction)
-            Transaction.new.start
-        end
-      end
-
-      describe "#clean" do
-        it "should start a transaction" do
-            connection.stub!(:decrement_open_transactions)
-
-            connection.should_receive(:rollback_db_transaction)
-            Transaction.new.clean
-        end
-        it "should decrement open transactions if possible" do
-          connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(true)
-          connection.stub!(:rollback_db_transaction)
-
-          connection.should_receive(:decrement_open_transactions)
-          Transaction.new.clean
-        end
-
-        it "should decrement connection via ActiveRecord::Base if connection won't" do
-          connection.stub!(:respond_to?).with(:decrement_open_transactions).and_return(false)
-          connection.stub!(:rollback_db_transaction)
-
-          ::ActiveRecord::Base.should_receive(:decrement_open_transactions)
-          Transaction.new.clean
-        end
-      end
-    end
-
-  end
-end

data/spec/database_cleaner/active_record/truncation_spec.rb

@@ -1,82 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'active_record'
-require 'database_cleaner/active_record/truncation'
-
-
-module ActiveRecord
-  module ConnectionAdapters
-    [MysqlAdapter, Mysql2Adapter, SQLite3Adapter, JdbcAdapter, PostgreSQLAdapter, IBM_DBAdapter].each do |adapter|
-      describe adapter, "#truncate_table" do
-        it "responds" do
-          adapter.new("foo").should respond_to(:truncate_table)
-        end
-        it "should truncate the table"
-      end
-    end
-  end
-end
-
-module DatabaseCleaner
-  module ActiveRecord
-
-    describe Truncation do
-      let(:connection) { mock('connection') }
-
-
-      before(:each) do
-        connection.stub!(:disable_referential_integrity).and_yield
-        connection.stub!(:views).and_return([])
-        ::ActiveRecord::Base.stub!(:connection).and_return(connection)
-      end
-
-      it "should truncate all tables except for schema_migrations" do
-        connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
-
-        connection.should_receive(:truncate_table).with('widgets')
-        connection.should_receive(:truncate_table).with('dogs')
-        connection.should_not_receive(:truncate_table).with('schema_migrations')
-
-        Truncation.new.clean
-      end
-
-      it "should only truncate the tables specified in the :only option when provided" do
-        connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
-
-        connection.should_receive(:truncate_table).with('widgets')
-        connection.should_not_receive(:truncate_table).with('dogs')
-
-        Truncation.new(:only => ['widgets']).clean
-      end
-
-      it "should not truncate the tables specified in the :except option" do
-        connection.stub!(:tables).and_return(%w[schema_migrations widgets dogs])
-
-        connection.should_receive(:truncate_table).with('dogs')
-        connection.should_not_receive(:truncate_table).with('widgets')
-
-        Truncation.new(:except => ['widgets']).clean
-      end
-
-      it "should raise an error when :only and :except options are used" do
-        running {
-          Truncation.new(:except => ['widgets'], :only => ['widgets'])
-        }.should raise_error(ArgumentError)
-      end
-
-      it "should raise an error when invalid options are provided" do
-        running { Truncation.new(:foo => 'bar') }.should raise_error(ArgumentError)
-      end
-
-      it "should not truncate views" do
-        connection.stub!(:tables).and_return(%w[widgets dogs])
-        connection.stub!(:views).and_return(["widgets"])
-
-        connection.should_receive(:truncate_table).with('dogs')
-        connection.should_not_receive(:truncate_table).with('widgets')
-
-        Truncation.new.clean
-      end
-
-    end
-  end
-end