database_cleaner 1.7.0 → 1.8.0.beta

data/lib/database_cleaner/configuration.rb

@@ -1,74 +1,77 @@
 require 'database_cleaner/base'
+require 'database_cleaner/deprecation'
+require 'forwardable'
 
 module DatabaseCleaner
 
-  class NoORMDetected < StandardError;   end
-  class UnknownStrategySpecified < ArgumentError;   end
+  class NoORMDetected < StandardError; end
+  class UnknownStrategySpecified < ArgumentError; end
 
-  class << self
-    def init_cleaners
-      @cleaners ||= {}
-      # ghetto ordered hash.. maintains 1.8 compat and old API
-      @connections ||= []
-    end
-
-    def [](orm,opts = {})
+  class Cleaners < Hash
+    # FIXME this method conflates creation with lookup... both a command and a query. yuck.
+    def [](orm, opts = {})
       raise NoORMDetected unless orm
-      init_cleaners
-      # TODO: deprecate
-      # this method conflates creation with lookup.  Both a command and a query. Yuck.
-      if @cleaners.has_key? [orm, opts]
-        @cleaners[[orm, opts]]
-      else
-        add_cleaner(orm, opts)
-      end
-    end
+      fetch([orm, opts]) { add_cleaner(orm, opts) }
+    end 
 
-    def add_cleaner(orm,opts = {})
-      init_cleaners
-      cleaner = DatabaseCleaner::Base.new(orm,opts)
-      @cleaners[[orm, opts]] = cleaner
-      @connections << cleaner
-      cleaner
+    def strategy=(strategy)
+      add_cleaner(:autodetect) if none?
+      values.each { |cleaner| cleaner.strategy = strategy }
+      remove_duplicates
     end
 
-    def app_root=(desired_root)
-      @app_root = desired_root
+    def orm=(orm)
+      add_cleaner(:autodetect) if none?
+      values.each { |cleaner| cleaner.orm = orm }
+      remove_duplicates
     end
 
-    def app_root
-      @app_root ||= Dir.pwd
+    # TODO privatize the following methods in 2.0
+
+    def add_cleaner(orm, opts = {})
+      self[[orm, opts]] = ::DatabaseCleaner::Base.new(orm, opts)
     end
 
-    def connections
-      # double yuck.. can't wait to deprecate this whole class...
-      unless defined?(@cleaners) && @cleaners
-        autodetected = ::DatabaseCleaner::Base.new
-        add_cleaner(autodetected.orm)
-      end
-      @connections
+    def remove_duplicates
+      replace(reduce(Cleaners.new) do |cleaners, (key, value)|
+        cleaners[key] = value unless cleaners.values.include?(value)
+        cleaners
+      end)
     end
+  end
 
-    def logger=(log_source)
-      @logger = log_source
+  class Configuration
+    def initialize
+      @cleaners ||= Cleaners.new
     end
 
-    def logger
-      return @logger if @logger
+    extend Forwardable
+    delegate [
+      :[],
+      :strategy=,
+      :orm=,
+    ] => :cleaners
+
+    attr_accessor :cleaners
 
-      @logger = Logger.new(STDOUT)
-      @logger.level = Logger::ERROR
-      @logger
+    def app_root
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.app_root` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner::ActiveRecord.config_file_location`, instead."
+      @app_root ||= Dir.pwd
     end
 
-    def strategy=(stratagem)
-      connections.each { |connect| connect.strategy = stratagem }
-      remove_duplicates
+    def app_root= value
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.app_root=` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner::ActiveRecord.config_file_location=`, instead."
+      @app_root = value
     end
 
-    def orm=(orm)
-      connections.each { |connect| connect.orm = orm }
-      remove_duplicates
+    def logger
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.logger` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+      @logger ||= Logger.new(STDOUT).tap { |l| l.level = Logger::ERROR }
+    end
+
+    def logger= value
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.logger=` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+      @logger = value
     end
 
     def start
@@ -79,8 +82,6 @@ module DatabaseCleaner
       connections.each { |connection| connection.clean }
     end
 
-    alias clean! clean
-
     def cleaning(&inner_block)
       connections.inject(inner_block) do |curr_block, connection|
         proc { connection.cleaning(&curr_block) }
@@ -91,41 +92,50 @@ module DatabaseCleaner
       connections.each { |connection| connection.clean_with(*args) }
     end
 
-    alias clean_with! clean_with
+    # TODO remove the following methods in 2.0
 
-    def remove_duplicates
-      temp = []
-      connections.each do |connect|
-        temp.push connect unless temp.include? connect
+    def clean!
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.clean!` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.clean`, instead."
+      clean
+    end
+
+    def clean_with!(*args)
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.clean_with!` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.clean_with`, instead."
+      clean_with(*args)
+    end
+
+    def init_cleaners
+      DatabaseCleaner.deprecate "Calling `DatabaseCleaner.init_cleaners` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+    end
+
+    def connections
+      if called_externally?(caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner.connections` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.cleaners`, instead."
       end
-      @connections = temp
-    end
-
-    def orm_module(symbol)
-      case symbol
-        when :active_record
-          DatabaseCleaner::ActiveRecord
-        when :data_mapper
-          DatabaseCleaner::DataMapper
-        when :mongo
-          DatabaseCleaner::Mongo
-        when :mongoid
-          DatabaseCleaner::Mongoid
-        when :mongo_mapper
-          DatabaseCleaner::MongoMapper
-        when :moped
-          DatabaseCleaner::Moped
-        when :couch_potato
-          DatabaseCleaner::CouchPotato
-        when :sequel
-          DatabaseCleaner::Sequel
-        when :ohm
-          DatabaseCleaner::Ohm
-        when :redis
-          DatabaseCleaner::Redis
-        when :neo4j
-          DatabaseCleaner::Neo4j
+      add_cleaner(:autodetect) if @cleaners.none?
+      @cleaners.values
+    end
+
+    # TODO privatize the following methods in 2.0
+
+    def add_cleaner(orm, opts = {})
+      if called_externally?(caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner.add_cleaner` is deprecated, and will be removed in database_cleaner 2.0. Use `DatabaseCleaner.[]`, instead."
       end
+      @cleaners.add_cleaner(orm, opts = {})
+    end
+
+    def remove_duplicates
+      if called_externally?(caller)
+        DatabaseCleaner.deprecate "Calling `DatabaseCleaner.remove_duplicates` is deprecated, and will be removed in database_cleaner 2.0 with no replacement."
+      end
+      @cleaners.remove_duplicates
+    end
+
+    private
+
+    def called_externally?(caller)
+      __FILE__ != caller.first.split(":").first
     end
   end
 end

data/lib/database_cleaner/deprecation.rb

@@ -0,0 +1,21 @@
+module DatabaseCleaner
+  def deprecate message
+    method = caller.first[/\d+:in `(.*)'$/, 1].to_sym
+    @@deprecator ||= Deprecator.new
+    @@deprecator.deprecate method, message
+  end
+  module_function :deprecate
+
+  class Deprecator
+    def initialize
+      @methods_already_warned = {}
+    end
+
+    def deprecate method, message
+      return if @methods_already_warned.key?(method)
+      $stderr.puts message
+      @methods_already_warned[method] = true
+    end
+  end
+end
+

data/lib/database_cleaner/null_strategy.rb

@@ -1,18 +1,18 @@
 module DatabaseCleaner
   class NullStrategy
-    def self.start
+    def start
       # no-op
     end
     
-     def self.db=(connection)
-       # no-op
-     end
+    def db=(connection)
+      # no-op
+    end
      
-    def self.clean
+    def clean
       # no-op
     end
 
-    def self.cleaning(&block)
+    def cleaning(&block)
       # no-op
       yield
     end

data/lib/database_cleaner/orm_autodetector.rb

@@ -0,0 +1,31 @@
+require 'active_support/core_ext/string/inflections'
+
+module DatabaseCleaner
+  class ORMAutodetector
+    ORMS = %w[ActiveRecord DataMapper MongoMapper Mongoid CouchPotato Sequel Moped Ohm Redis Neo4j]
+
+    def orm
+      @autodetected = true
+      autodetected_orm or raise no_orm_detected_error
+      autodetected_orm.underscore.to_sym
+    end
+
+    def autodetected?
+      !!@autodetected
+    end
+
+    private
+
+    def autodetected_orm
+      ORMS.find do |orm|
+        Kernel.const_get(orm) rescue next
+      end
+    end
+
+    def no_orm_detected_error
+      orm_list = ORMS.join(", ").sub(ORMS.last, "or #{ORMS.last}")
+      NoORMDetected.new("No known ORM was detected!  Is #{orm_list} loaded?")
+    end
+  end
+  private_constant :ORMAutodetector
+end

data/lib/database_cleaner/safeguard.rb

@@ -12,8 +12,32 @@ module DatabaseCleaner
           super("ENV['#{env}'] is set to production. Please refer to https://github.com/DatabaseCleaner/database_cleaner#safeguards")
         end
       end
+
+      class NotWhitelistedUrl < Error
+        def initialize
+          super("ENV['DATABASE_URL'] is set to a URL that is not on the whitelist. Please refer to https://github.com/DatabaseCleaner/database_cleaner#safeguards")
+        end
+      end
+    end
+
+    class WhitelistedUrl
+      def run
+        return if skip?
+        raise Error::NotWhitelistedUrl if database_url_not_whitelisted?
+      end
+
+      private
+
+        def database_url_not_whitelisted?
+          !DatabaseCleaner.url_whitelist.include?(ENV['DATABASE_URL'])
+        end
+
+        def skip?
+          !DatabaseCleaner.url_whitelist
+        end
     end
 
+
     class RemoteDatabaseUrl
       LOCAL = %w(localhost 127.0.0.1)
 
@@ -28,12 +52,22 @@ module DatabaseCleaner
         end
 
         def remote?(url)
-          url && !LOCAL.any? { |str| url.include?(str) }
+          return false unless url
+
+          parsed = URI.parse(url)
+          return false if parsed.scheme == 'sqlite3:'
+
+          host = parsed.host
+          return false unless host
+          return false if LOCAL.include?(host)
+          return false if host.end_with? '.local'
+          true
         end
 
         def skip?
           ENV['DATABASE_CLEANER_ALLOW_REMOTE_DATABASE_URL'] ||
-            DatabaseCleaner.allow_remote_database_url
+            DatabaseCleaner.allow_remote_database_url ||
+            DatabaseCleaner.url_whitelist
         end
     end
 
@@ -62,7 +96,8 @@ module DatabaseCleaner
 
     CHECKS = [
       RemoteDatabaseUrl,
-      Production
+      Production,
+      WhitelistedUrl
     ]
 
     def run

data/lib/database_cleaner/spec.rb

@@ -0,0 +1,2 @@
+require "database_cleaner/spec/database_helper"
+require "database_cleaner/spec/shared_examples"

data/lib/database_cleaner/spec/database_helper.rb

@@ -0,0 +1,82 @@
+require 'yaml'
+
+module DatabaseCleaner
+  module Spec
+    class DatabaseHelper < Struct.new(:db)
+      def self.with_all_dbs &block
+        %w[mysql mysql2 sqlite3 postgres].map(&:to_sym).each do |db|
+          yield new(db)
+        end
+      end
+
+      def setup
+        create_db
+        establish_connection
+        load_schema
+      end
+
+      attr_reader :connection
+
+      def teardown
+        drop_db
+      end
+
+      private
+
+      def establish_connection(config = default_config)
+        raise NotImplementedError
+      end
+
+      def create_db
+        if db == :sqlite3
+          # NO-OP
+        elsif db == :postgres
+          establish_connection default_config.merge('database' => 'postgres')
+          connection.execute "CREATE DATABASE #{default_config['database']}" rescue nil
+        else
+          establish_connection default_config.merge("database" => nil)
+          connection.execute "CREATE DATABASE IF NOT EXISTS #{default_config['database']}"
+        end
+      end
+
+      def load_schema
+        connection.execute <<-SQL
+          CREATE TABLE IF NOT EXISTS users (
+            id SERIAL PRIMARY KEY,
+            name INTEGER
+          );
+        SQL
+
+        connection.execute <<-SQL
+          CREATE TABLE IF NOT EXISTS agents (
+            name INTEGER
+          );
+        SQL
+      end
+
+      def drop_db
+        if db == :sqlite3
+          begin
+            File.unlink(db_config['sqlite3']['database'])
+          rescue Errno::ENOENT
+          end
+        elsif db == :postgres
+          # FIXME
+          connection.execute "DROP TABLE IF EXISTS users"
+          connection.execute "DROP TABLE IF EXISTS agents"
+        else
+          connection.execute "DROP DATABASE IF EXISTS #{default_config['database']}"
+        end
+      end
+
+      def db_config
+        config_path = 'spec/support/config.yml'
+        @db_config ||= YAML.load(IO.read(config_path))
+      end
+
+      def default_config
+        db_config[db.to_s]
+      end
+    end
+  end
+end