sbf-dm-core 1.3.0.beta

data/lib/dm-core/spec/lib/adapter_helpers.rb

@@ -0,0 +1,63 @@
+module DataMapper
+  module Spec
+    module Adapters
+      module Helpers
+        def supported_by(*adapters, &block)
+          adapters = adapters.map(&:to_sym)
+          adapter  = DataMapper::Spec.adapter_name.to_sym
+          if adapters.include?(:all) || adapters.include?(adapter)
+            describe_adapter(:default, &block)
+          end
+        end
+
+        def with_alternate_adapter(&block)
+          describe_adapter(:alternate, &block)
+        end
+
+        def describe_adapter(kind, &block)
+          describe("with #{kind} adapter") do
+            let(:adapter)    { @adapter    }
+            let(:repository) { @repository }
+
+            before :all do
+              # store these in instance vars for the shared adapter specs
+              @adapter    = DataMapper::Spec.adapter(kind)
+              @repository = DataMapper.repository(@adapter&.name)
+
+              @repository&.scope { DataMapper.finalize }
+
+              # create all tables and constraints before each spec
+              DataMapper::Model.descendants.each do |model|
+                next unless model.respond_to?(:auto_migrate!)
+
+                begin
+                  model.auto_migrate!(@repository&.name)
+                rescue IncompleteModelError
+                  # skip incomplete models
+                end
+              end
+            end
+
+            after :all do
+              # remove all tables and constraints after each spec
+              DataMapper::Model.descendants.each do |model|
+                next unless model.respond_to?(:auto_migrate_down!)
+
+                begin
+                  model.auto_migrate_down!(@repository&.name)
+                rescue IncompleteModelError
+                  # skip incomplete models
+                end
+              end
+              # TODO: consider proper automigrate functionality
+              if @adapter.respond_to?(:reset)
+                @adapter.reset
+              end
+            end
+            instance_eval(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dm-core/spec/lib/collection_helpers.rb

@@ -0,0 +1,21 @@
+module DataMapper
+  module Spec
+    module CollectionHelpers
+      module GroupMethods
+        def self.extended(base)
+          base.class_inheritable_accessor :loaded
+          base.loaded = false
+          super
+        end
+
+        def should_not_be_a_kicker(ivar = :@articles)
+          return if loaded
+
+          it 'is not a kicker' do
+            expect(instance_variable_get(ivar)).not_to be_loaded
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dm-core/spec/lib/counter_adapter.rb

@@ -0,0 +1,38 @@
+class CounterAdapter < DataMapper::Adapters::AbstractAdapter
+  instance_methods.each do |method|
+    next if method =~ /\A__/ ||
+      %w[ send class dup object_id kind_of? instance_of? respond_to? equal? freeze frozen? should should_not instance_variables instance_variable_set instance_variable_get instance_variable_defined? remove_instance_variable extend inspect copy_object ].include?(method.to_s)
+    undef_method method
+  end
+
+  attr_reader :counts
+
+  def kind_of?(klass)
+    super || @adapter.kind_of?(klass)
+  end
+
+  def instance_of?(klass)
+    super || @adapter.instance_of?(klass)
+  end
+
+  def respond_to?(method, include_private = false)
+    super || @adapter.respond_to?(method, include_private)
+  end
+
+  private
+
+  def initialize(adapter)
+    @counts  = Hash.new { |hash, key| hash[key] = 0 }
+    @adapter = adapter
+    @count   = 0
+  end
+
+  def increment_count_for(method)
+    @counts[method] += 1
+  end
+
+  def method_missing(method, *args, &block)
+    increment_count_for(method)
+    @adapter.send(method, *args, &block)
+  end
+end

data/lib/dm-core/spec/lib/pending_helpers.rb

@@ -0,0 +1,50 @@
+module DataMapper
+  module Spec
+    module PendingHelpers
+
+      def pending_if(*args)
+        message, boolean = parse_args(*args)
+
+        if boolean
+          pending(message) { yield }
+        else
+          yield
+        end
+      end
+
+      def rescue_if(*args)
+        message, boolean = parse_args(*args)
+
+        if boolean
+          raised = nil
+          begin
+            yield
+            raised = false
+          rescue Exception
+            raised = true
+          end
+
+          raise "should have raised: #{message || 'TODO'}" if raised == false
+        else
+          yield
+        end
+      end
+
+      private
+
+      def parse_args(*args)
+        case args.map { |arg| arg.class }
+          when [ String, TrueClass ], [ String, FalseClass ] then args
+          when [ String, NilClass ]                          then [ args.first, false      ]
+          when [ String ]                                    then [ args.first, true       ]
+          when [ TrueClass ], [ FalseClass ]                 then [ '',         args.first ]
+          when [ NilClass ]                                  then [ '',         false      ]
+          when []                                            then [ '',         true       ]  # defaults
+          else
+            raise ArgumentError, "Invalid arguments: #{args.inspect}"
+        end
+      end
+
+    end
+  end
+end

data/lib/dm-core/spec/lib/spec_helper.rb

@@ -0,0 +1,74 @@
+module DataMapper
+  module Spec
+
+    module Helpers
+      def reset_raise_on_save_failure(object)
+        object.instance_eval do
+          if defined?(@raise_on_save_failure)
+            remove_instance_variable(:@raise_on_save_failure)
+          end
+        end
+      end
+    end
+
+    # global model cleanup
+    def self.cleanup_models
+      descendants = DataMapper::Model.descendants.to_a
+
+      while (model = descendants.shift)
+        model_name = model.name.to_s.strip
+
+        unless model_name.empty? || model_name[0] == ?#
+          parts         = model_name.split('::')
+          constant_name = parts.pop.to_sym
+          base          = parts.empty? ? Object : DataMapper::Ext::Object.full_const_get(parts.join('::'))
+
+          base.class_eval { remove_const(constant_name) if const_defined?(constant_name) }
+        end
+
+        remove_ivars(model)
+        model.instance_methods(false).each { |method| model.send(:undef_method, method) }
+
+      end
+
+      DataMapper::Model.descendants.clear
+    end
+
+    def self.remove_ivars(object, instance_variables = object.instance_variables)
+      seen  = {}
+      stack = instance_variables.map { |var| [object, var] }
+
+      while (node = stack.pop)
+        object, ivar = node
+
+        # skip "global" and non-DM objects
+        next if object.is_a?(DataMapper::Logger)                    ||
+                object.is_a?(DataMapper::DescendantSet)             ||
+                object.is_a?(DataMapper::Adapters::AbstractAdapter) ||
+                object.class.name.to_s[0, 13] == 'DataObjects::'
+
+        # skip classes and modules in the DataMapper namespace
+        next if object.is_a?(Module) &&
+                object.name.to_s[0, 12] == 'DataMapper::'
+
+        # skip when the ivar is no longer defined in the object
+        next unless object.instance_variable_defined?(ivar)
+
+        value = object.instance_variable_get(ivar)
+
+        # skip descendant sets
+        next if value.is_a?(DataMapper::DescendantSet)
+
+        object.__send__(:remove_instance_variable, ivar) unless object.frozen?
+
+        # skip when the value was seen
+        next if seen.key?(value.object_id)
+
+        seen[value.object_id] = true
+
+        stack.concat(value.instance_variables.map { |ivar| [value, ivar] })
+      end
+    end
+
+  end
+end

data/lib/dm-core/spec/setup.rb

@@ -0,0 +1,164 @@
+require 'dm-core'
+
+module DataMapper
+  module Spec
+    class << self
+      def root
+        @root ||= default_root
+      end
+
+      def root=(path)
+        @root = Pathname(path)
+      end
+
+      %w(setup setup! adapter adapter_name).each do |action|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{action}(kind = :default)
+            perform_action(kind, :#{action})
+          end
+        RUBY
+      end
+
+      def configure
+        @configured = begin
+          setup_logger
+          require_plugins
+          require_spec_adapter
+          true
+        end
+      end
+
+      def configured?
+        @configured
+      end
+
+      def setup_logger
+        return unless (log = ENV.fetch('LOG', nil))
+
+        logger = DataMapper::Logger.new(log_stream(log), :debug)
+        logger.auto_flush = true
+        logger
+      end
+
+      def require_spec_adapter
+        desired_adapter = ENV['ADAPTER'] || ENV.fetch('ADAPTERS', nil)
+        if desired_adapter.nil? || desired_adapter == 'in_memory'
+          ENV['ADAPTER_SUPPORTS'] = 'all'
+          Adapters.use(Adapters::InMemoryAdapter)
+        else
+          require "dm-#{desired_adapter}-adapter/spec/setup"
+        end
+      end
+
+      def require_plugins
+        adapter = ENV['ADAPTER'] || ENV.fetch('ADAPTERS', nil)
+        plugins = ENV['PLUGINS'] || ENV.fetch('PLUGIN', nil)
+        plugins = plugins.to_s.split(/[,\s]+/)
+        plugins.push('dm-migrations') unless adapter == 'in_memory'
+        plugins.uniq.each { |plugin| require plugin }
+      end
+
+      def spec_adapters
+        @spec_adapters ||= {}
+      end
+
+      private def perform_action(kind, action)
+        configure unless configured?
+        spec_adapters[kind].send(action)
+      end
+
+      private def default_root
+        Pathname(Dir.pwd).join('spec')
+      end
+
+      private def log_stream(log)
+        (log == 'file') ? root.join('log/dm.log') : $stdout
+      end
+    end
+
+    module Adapters
+      def self.use(adapter_class)
+        Spec.spec_adapters[:default]   = adapter_class.new(:default)
+        Spec.spec_adapters[:alternate] = adapter_class.new(:alternate)
+      end
+
+      class Adapter
+        attr_reader :name
+
+        def initialize(name)
+          @name = name.to_sym
+        end
+
+        def adapter
+          @adapter ||= setup!
+        end
+
+        alias_method :setup, :adapter
+
+        def setup!
+          adapter = DataMapper.setup(name, connection_uri)
+          test_connection(adapter)
+          adapter
+        rescue Exception => e
+          puts "Could not connect to the database using '#{connection_uri}' because of: #{e.inspect}"
+        end
+
+        def adapter_name
+          @adapter_name ||= infer_adapter_name
+        end
+
+        def connection_uri
+          "#{adapter_name}://#{username}%s@#{host}/#{storage_name}".tap do |s|
+            return s % (password.empty? ? '' : ":#{password}")
+          end
+        end
+
+        def storage_name
+          send("#{name}_storage_name")
+        end
+
+        def default_storage_name
+          'datamapper_default_tests'
+        end
+
+        def alternate_storage_name
+          'datamapper_alternate_tests'
+        end
+
+        def username
+          ENV.fetch('DM_DB_USER', 'datamapper')
+        end
+
+        def password
+          ENV.fetch('DM_DB_PASSWORD', 'datamapper')
+        end
+
+        def host
+          ENV.fetch('DM_DB_HOST', '127.0.0.1')
+        end
+
+        # Test the connection
+        #
+        # Overwrite this method if you need to perform custom connection testing
+        #
+        # @raise [Exception]
+        def test_connection(adapter)
+          return unless adapter.respond_to?(:select)
+
+          adapter.select('SELECT 1')
+        end
+
+        private def infer_adapter_name
+          demodulized = DataMapper::Inflector.demodulize(self.class.name.chomp('Adapter'))
+          DataMapper::Inflector.underscore(demodulized).freeze
+        end
+      end
+
+      class InMemoryAdapter < Adapter
+        def connection_uri
+          {adapter: :in_memory}
+        end
+      end
+    end
+  end
+end