dm-rinda-adapter 0.1.0

data/spec/legacy/adapter_shared_spec.rb

@@ -0,0 +1,331 @@
+
+require 'rubygems'; require 'ruby-debug'; 
+
+share_examples_for 'An Adapter' do
+
+  def self.adapter_supports?(*methods)
+    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
+    
+
+    # 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 object with a nil value using required properties' do
+         #   r = Heffalump.all(:id.not => nil)
+         #   r.should be_include  @red
+         #   r.should be_include  @two
+         #   r.should be_include  @five 
+         #   r.length.should == 3
+         # end
+
+          #it 'should be able to search for objects not in an empty list (match all)' do
+           # r=Heffalump.all(:color.not => [])
+           # r.should be_include  @red
+           # r.should be_include  @two
+           # r.should be_include  @five 
+           # r.length.should == 3
+          #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::Sqlite3Adapter) && @adapter.kind_of?(DataMapper::Adapters::Sqlite3Adapter) ||
+                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

data/spec/legacy/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+$db = DataMapper::Mongo::Spec.database(:default)
+include DataMapper::Mongo

data/spec/lib/adapter_helpers.rb

@@ -0,0 +1,105 @@
+require "benchmark"
+
+module DataMapper::Spec
+  module AdapterHelpers
+    def self.current_adapters
+      @current_adapters ||= []
+    end
+
+    def supported_by(*adapters, &block)
+      adapters = get_adapters(*adapters)
+
+      PRIMARY.only(*adapters).each do |adapter, connection_uri|
+        # keep track of the current adapters
+        AdapterHelpers.current_adapters << adapters
+
+        describe("with #{adapter}") do
+
+          before :all do
+            # store these in instance vars for the shared adapter specs
+            @adapter    = DataMapper.setup(:default, connection_uri)
+            @repository = DataMapper.repository(@adapter.name)
+
+            # create all tables and constraints before each spec
+            if @repository.respond_to?(:auto_migrate!)
+              @repository.auto_migrate!
+            end
+          end
+
+          after :all do
+            # remove all tables and constraints after each spec
+            if DataMapper.respond_to?(:auto_migrate_down!, true)
+              DataMapper.send(:auto_migrate_down!, @repository.name)
+            end
+          end
+
+          # TODO: add destroy_model_storage and migrations code
+          # that removes the YAML file and remove this code
+          after :all do
+            if defined?(DataMapper::Adapters::YamlAdapter) && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+              descendants = DataMapper::Model.descendants.to_a
+              while model = descendants.shift
+                descendants.concat(model.descendants.to_a - [ model ])
+
+                model.default_scope.clear
+                model.all(:repository => @repository).destroy!
+              end
+            end
+          end
+
+          self.instance_eval(&block)
+        end
+
+        AdapterHelpers.current_adapters.pop
+      end
+    end
+
+    def with_alternate_adapter(&block)
+      adapters = AdapterHelpers.current_adapters.last
+
+      ALTERNATE.only(*adapters).each do |adapter, connection_uri|
+        describe("and #{adapter}") do
+
+          before :all do
+            @alternate_adapter    = DataMapper.setup(:alternate, connection_uri)
+            @alternate_repository = DataMapper.repository(@alternate_adapter.name)
+
+            # create all tables and constraints before each spec
+            if @alternate_repository.respond_to?(:auto_migrate!)
+              @alternate_repository.auto_migrate!
+            end
+          end
+
+          after :all do
+            # remove all tables and constraints after each spec
+            if DataMapper.respond_to?(:auto_migrate_down!, true)
+              DataMapper.send(:auto_migrate_down!, @alternate_repository.name)
+            end
+          end
+
+          # TODO: add destroy_model_storage and migrations code
+          # that removes the YAML file and remove this code
+          after :all do
+            if defined?(DataMapper::Adapters::YamlAdapter) && @alternate_adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+              descendants = DataMapper::Model.descendants.to_a
+              while model = descendants.shift
+                descendants.concat(model.descendants.to_a - [ model ])
+
+                model.default_scope.clear
+                model.all(:repository => @alternate_repository).destroy!
+              end
+            end
+          end
+
+          self.instance_eval(&block)
+        end
+      end
+    end
+
+    def get_adapters(*adapters)
+      adapters.map! { |adapter_name| adapter_name.to_s }
+      adapters = ADAPTERS if adapters.include?('all')
+      ADAPTERS & adapters
+    end
+  end
+end

data/spec/lib/collection_helpers.rb

@@ -0,0 +1,18 @@
+module DataMapper::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

data/spec/lib/counter_adapter.rb

@@ -0,0 +1,34 @@
+class CounterAdapter < DataMapper::Adapters::AbstractAdapter
+  instance_methods.each { |method| undef_method method unless %w[ __id__ __send__ send class dup object_id kind_of? instance_of? respond_to? equal? assert_kind_of should should_not instance_variable_set instance_variable_get extend ].include?(method.to_s) }
+
+  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/spec/lib/pending_helpers.rb

@@ -0,0 +1,46 @@
+module DataMapper::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

data/spec/lib/rspec_immediate_feedback_formatter.rb

@@ -0,0 +1,54 @@
+require 'spec/runner/formatter/base_text_formatter'
+
+# Code is based on standard SpecdocFormatter, but will print full error details as soon as they are found.
+# Successful or pending examples are written only as a dot in the output. Header is only printed if errors occur.
+#
+# To use it, add the following to your spec/spec.opts:
+#  --require
+#  lib/rspec_immediate_feedback_formatter.rb
+#  --format
+#  Spec::Runner::Formatter::ImmediateFeedbackFormatter
+
+module Spec
+  module Runner
+    module Formatter
+      class ImmediateFeedbackFormatter < BaseTextFormatter
+
+        def add_example_group(example_group)
+          super
+          @current_group = example_group.description
+        end
+
+        def example_failed(example, counter, failure)
+          if @current_group
+            output.puts
+            output.puts @current_group
+            @current_group = nil  # only print the group name once
+          end
+
+          message = if failure.expectation_not_met?
+            "- #{example.description} (FAILED - #{counter})"
+          else
+            "- #{example.description} (ERROR - #{counter})"
+          end
+
+          output.puts(red(message))
+          # output.puts(failure.expectation_not_met? ? red(message) : message)
+          dump_failure(counter, failure)  # dump stacktrace immediately
+          output.flush
+        end
+
+        def example_passed(*)
+          output.print green('.')
+          output.flush
+        end
+
+        def example_pending(*)
+          super
+          output.print yellow('*')
+          output.flush
+        end
+      end
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary