ardm-core 1.2.1

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

@@ -0,0 +1,20 @@
+module DataMapper
+  module Spec
+    module CollectionHelpers
+      module GroupMethods
+        def self.extended(base)
+          base.class_inheritable_accessor :loaded
+          base.loaded = false
+        end
+
+        def should_not_be_a_kicker(ivar = :@articles)
+          unless loaded
+            it 'should not be a kicker' do
+              instance_variable_get(ivar).should_not be_loaded
+            end
+          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.kind_of?(DataMapper::Logger)                    ||
+                object.kind_of?(DataMapper::DescendantSet)             ||
+                object.kind_of?(DataMapper::Adapters::AbstractAdapter) ||
+                object.class.name[0, 13] == 'DataObjects::'
+
+        # skip classes and modules in the DataMapper namespace
+        next if object.kind_of?(Module) &&
+                !object.name.nil?       &&
+                object.name[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.kind_of?(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,173 @@
+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
+        if log = ENV['LOG']
+          logger = DataMapper::Logger.new(log_stream(log), :debug)
+          logger.auto_flush = true
+        end
+      end
+
+      def require_spec_adapter
+        desired_adapter = ENV['ADAPTER']
+        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
+        plugins = ENV['PLUGINS'] || ENV['PLUGIN']
+        plugins = plugins.to_s.split(/[,\s]+/)
+        unless ENV['ADAPTER'] == 'in_memory'
+          plugins.push('dm-migrations')
+        end
+        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
+
+      def default_root
+        Pathname(Dir.pwd).join('spec')
+      end
+
+      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}:#{password}@#{host}/#{storage_name}"
+        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', 'localhost')
+        end
+
+        # Test the connection
+        #
+        # Overwrite this method if you need to perform custom connection testing
+        #
+        # @raise [Exception]
+        def test_connection(adapter)
+          if adapter.respond_to?(:select)
+            adapter.select('SELECT 1')
+          end
+        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

data/lib/dm-core/spec/shared/adapter_spec.rb

@@ -0,0 +1,326 @@
+share_examples_for 'An Adapter' do
+
+  def self.adapter_supports?(*methods)
+
+    # FIXME obviously this needs a real fix!
+    # --------------------------------------
+    # Probably, delaying adapter_supports?
+    # to be executed after DataMapper.setup
+    # has been called will solve our current
+    # problem with described_type() being nil
+    # for as long as DataMapper.setup wasn't
+    # called
+    return true if ENV['ADAPTER_SUPPORTS'] == 'all'
+
+    methods.all? do |method|
+      # TODO: figure out a way to see if the instance method is only inherited
+      # from the Abstract Adapter, and not defined in it's class.  If that is
+      # the case return false
+
+      # CRUD methods can be inherited from parent class
+      described_type.instance_methods.any? { |instance_method| method.to_s == instance_method.to_s }
+    end
+  end
+
+  before :all do
+    raise '+@adapter+ should be defined in before block' unless instance_variable_get('@adapter')
+
+    class ::Heffalump
+      include DataMapper::Resource
+
+      property :id,        Serial
+      property :color,     String
+      property :num_spots, Integer
+      property :striped,   Boolean
+    end
+
+    DataMapper.finalize
+
+    # create all tables and constraints before each spec
+    if @repository.respond_to?(:auto_migrate!)
+      Heffalump.auto_migrate!
+    end
+  end
+
+  if adapter_supports?(:create)
+    describe '#create' do
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.create(:color => 'peach')
+        }.should_not raise_error
+      end
+
+      it 'should set the identity field for the resource' do
+        heffalump = Heffalump.new(:color => 'peach')
+        heffalump.id.should be_nil
+        heffalump.save
+        heffalump.id.should_not be_nil
+      end
+    end
+  else
+    it 'needs to support #create'
+  end
+
+  if adapter_supports?(:read)
+    describe '#read' do
+      before :all do
+        @heffalump = Heffalump.create(:color => 'brownish hue')
+        #just going to borrow this, so I can check the return values
+        @query = Heffalump.all.query
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          Heffalump.all()
+        }.should_not raise_error
+      end
+
+      it 'should return stuff' do
+        Heffalump.all.should be_include(@heffalump)
+      end
+    end
+  else
+    it 'needs to support #read'
+  end
+
+  if adapter_supports?(:update)
+    describe '#update' do
+      before do
+        @heffalump = Heffalump.create(:color => 'indigo')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.color = 'violet'
+          @heffalump.save
+        }.should_not raise_error
+      end
+
+      it 'should not alter the identity field' do
+        id = @heffalump.id
+        @heffalump.color = 'violet'
+        @heffalump.save
+        @heffalump.id.should == id
+      end
+
+      it 'should update altered fields' do
+        @heffalump.color = 'violet'
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == 'violet'
+      end
+
+      it 'should not alter other fields' do
+        color = @heffalump.color
+        @heffalump.num_spots = 3
+        @heffalump.save
+        Heffalump.get(*@heffalump.key).color.should == color
+      end
+    end
+  else
+    it 'needs to support #update'
+  end
+
+  if adapter_supports?(:delete)
+    describe '#delete' do
+      before do
+        @heffalump = Heffalump.create(:color => 'forest green')
+      end
+
+      it 'should not raise any errors' do
+        lambda {
+          @heffalump.destroy
+        }.should_not raise_error
+      end
+
+      it 'should delete the requested resource' do
+        id = @heffalump.id
+        @heffalump.destroy
+        Heffalump.get(id).should be_nil
+      end
+    end
+  else
+    it 'needs to support #delete'
+  end
+
+  if adapter_supports?(:read, :create)
+    describe 'query matching' do
+      before :all do
+        @red  = Heffalump.create(:color => 'red')
+        @two  = Heffalump.create(:num_spots => 2)
+        @five = Heffalump.create(:num_spots => 5)
+      end
+
+      describe 'conditions' do
+        describe 'eql' do
+          it 'should be able to search for objects included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..5).should be_include(@five)
+          end
+
+          it 'should be able to search for objects included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...6).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots => 1..4).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots => 1...5).should_not be_include(@five)
+          end
+        end
+
+        describe 'not' do
+          it 'should be able to search for objects with not equal value' do
+            Heffalump.all(:color.not => 'red').should_not be_include(@red)
+          end
+
+          it 'should include objects that are not like the value' do
+            Heffalump.all(:color.not => 'black').should be_include(@red)
+          end
+
+          it 'should be able to search for objects with not nil value' do
+            Heffalump.all(:color.not => nil).should be_include(@red)
+          end
+
+          it 'should not include objects with a nil value' do
+            Heffalump.all(:color.not => nil).should_not be_include(@two)
+          end
+
+          it 'should be able to search for object with a nil value using required properties' do
+            Heffalump.all(:id.not => nil).should == [ @red, @two, @five ]
+          end
+
+          it 'should be able to search for objects not in an empty list (match all)' do
+            Heffalump.all(:color.not => []).should == [ @red, @two, @five ]
+          end
+
+          it 'should be able to search for objects in an empty list and another OR condition (match none on the empty list)' do
+            Heffalump.all(
+              :conditions => DataMapper::Query::Conditions::Operation.new(
+                :or,
+                DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:color], []),
+                DataMapper::Query::Conditions::Comparison.new(:in, Heffalump.properties[:num_spots], [5])
+              )
+            ).should == [ @five ]
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should be_include(@two)
+          end
+
+          it 'should be able to search for objects not included in an array of values' do
+            Heffalump.all(:num_spots.not => [ 1, 3, 5, 7 ]).should_not be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..4).should be_include(@five)
+          end
+
+          it 'should be able to search for objects not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...5).should be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an inclusive range of values' do
+            Heffalump.all(:num_spots.not => 1..5).should_not be_include(@five)
+          end
+
+          it 'should not be able to search for values not included in an exclusive range of values' do
+            Heffalump.all(:num_spots.not => 1...6).should_not be_include(@five)
+          end
+        end
+
+        describe 'like' do
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color.like => '%ed').should be_include(@red)
+          end
+
+          it 'should not search for objects that do not match the value' do
+            Heffalump.all(:color.like => '%blak%').should_not be_include(@red)
+          end
+        end
+
+        describe 'regexp' do
+          before do
+            if (defined?(DataMapper::Adapters::SqliteAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqliteAdapter) ||
+                defined?(DataMapper::Adapters::SqlserverAdapter) && @adapter.kind_of?(DataMapper::Adapters::SqlserverAdapter))
+              pending 'delegate regexp matches to same system that the InMemory and YAML adapters use'
+            end
+          end
+
+          it 'should be able to search for objects that match value' do
+            Heffalump.all(:color => /ed/).should be_include(@red)
+          end
+
+          it 'should not be able to search for objects that do not match the value' do
+            Heffalump.all(:color => /blak/).should_not be_include(@red)
+          end
+
+          it 'should be able to do a negated search for objects that match value' do
+            Heffalump.all(:color.not => /blak/).should be_include(@red)
+          end
+
+          it 'should not be able to do a negated search for objects that do not match value' do
+            Heffalump.all(:color.not => /ed/).should_not be_include(@red)
+          end
+
+        end
+
+        describe 'gt' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gt => 1).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'gte' do
+          it 'should be able to search for objects with value greater than' do
+            Heffalump.all(:num_spots.gte => 1).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.gte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gte => 3).should_not be_include(@two)
+          end
+        end
+
+        describe 'lt' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lt => 3).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.gt => 2).should_not be_include(@two)
+          end
+        end
+
+        describe 'lte' do
+          it 'should be able to search for objects with value less than' do
+            Heffalump.all(:num_spots.lte => 3).should be_include(@two)
+          end
+
+          it 'should be able to search for objects with values equal to' do
+            Heffalump.all(:num_spots.lte => 2).should be_include(@two)
+          end
+
+          it 'should not find objects with a value less than' do
+            Heffalump.all(:num_spots.lte => 1).should_not be_include(@two)
+          end
+        end
+      end
+
+      describe 'limits' do
+        it 'should be able to limit the objects' do
+          Heffalump.all(:limit => 2).length.should == 2
+        end
+      end
+    end
+  else
+    it 'needs to support #read and #create to test query matching'
+  end
+end