datamapper-dm-core 0.9.11

data/spec/lib/logging_helper.rb

@@ -0,0 +1,18 @@
+module LoggingHelper
+  def logger
+    class << DataMapper.logger
+      attr_writer :log
+    end
+
+    old_log = DataMapper.logger.log
+
+    begin
+      StringIO.new('') do |io|
+        DataMapper.logger.log = io
+        yield io
+      end
+    ensure
+      DataMapper.logger.log = old_log
+    end
+  end
+end

data/spec/lib/mock_adapter.rb

@@ -0,0 +1,27 @@
+module DataMapper
+  module Adapters
+    class MockAdapter < DataMapper::Adapters::DataObjectsAdapter
+
+      def create(resources)
+        1
+      end
+
+      def exists?(storage_name)
+        true
+      end
+
+    end
+  end
+end
+
+module DataObjects
+  module Mock
+
+    def self.logger
+    end
+
+    def self.logger=(value)
+    end
+
+  end
+end

data/spec/lib/model_loader.rb

@@ -0,0 +1,100 @@
+# ---
+# Overview
+# ========
+# ModelLoader is a method for loading methods models for specs in a way
+# that will ensure that each spec will be an a pristine state when run.
+#
+# The problem is that if a spec needs to modify a model, the modifications
+# should not carry over to the next spec. As such, all models are
+# destroyed at the end of the spec and reloaded at the start.
+#
+# The second problem is that DataMapper::Resource keeps track
+# of every class that it is included in. This is used for automigration.
+# A number of specs run automigrate, and we don't want all the classes
+# that were defined in other specs to be migrated as well.
+#
+# Usage
+# =====
+#
+# Sets the specified model metaphors to be loaded before each spec and
+# destroyed after each spec in the current example group. This method
+# can be used in a describe block or in a before block.
+#
+# ==== Parameters
+# *metaphor<Symbol>:: The name of the metaphor to load (this is just the filename of
+#               file in specs/models)
+#
+# ==== Example
+#
+# describe "DataMapper::Associations" do
+#
+#   load_models_for_metaphor :zoo, :blog
+#
+#   it "should be awesome" do
+#     Zoo.new.should be_awesome
+#   end
+# end
+module ModelLoader
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_eval { include InstanceMethods }
+    # base.before(:each) { load_models(:global) }
+    base.after(:each)  { unload_models }
+  end
+
+  module ClassMethods
+
+    def load_models_for_metaphor(*metaphors)
+      before(:each) { load_models_for_metaphor(*metaphors) }
+    end
+
+  end
+
+  module InstanceMethods
+
+    def load_models_for_metaphor(*metaphors)
+      files = metaphors.map { |m| DataMapper.root / "spec" / "models" / "#{m}.rb" }
+
+      klasses = object_space_classes.dup
+      files.each { |file| load file }
+      loaded_models.concat(object_space_classes - klasses)
+    end
+
+    def unload_models
+      while model = loaded_models.pop
+        remove_model(model)
+      end
+    end
+
+    def loaded_models
+      @loaded_models ||= []
+    end
+
+  private
+
+    def object_space_classes
+      klasses = []
+      ObjectSpace.each_object(Class) {|o| klasses << o}
+      klasses
+    end
+
+    def remove_model(klass)
+      DataMapper::Resource.descendants.delete(klass)
+      # Check to see if the model is living inside a module
+      klass_name = klass.to_s
+      if klass_name.index("::")
+        mod = klass_name.match(/(\S+)::/)[1]
+        child_class = klass_name.match(/\S+::(\S+)/)[1]
+
+        Object.const_get(mod).module_eval { remove_const child_class }
+      else
+        Object.module_eval { remove_const klass.to_s }
+      end
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(ModelLoader)
+end

data/spec/lib/publicize_methods.rb

@@ -0,0 +1,28 @@
+class Class
+  def publicize_methods
+    klass = class << self; self; end
+
+    saved_private_class_methods      = klass.private_instance_methods
+    saved_protected_class_methods    = klass.protected_instance_methods
+    saved_private_instance_methods   = self.private_instance_methods
+    saved_protected_instance_methods = self.protected_instance_methods
+
+    self.class_eval do
+      klass.send(:public, *saved_private_class_methods)
+      klass.send(:public, *saved_protected_class_methods)
+      public(*saved_private_instance_methods)
+      public(*saved_protected_instance_methods)
+    end
+
+    begin
+      yield
+    ensure
+      self.class_eval do
+        klass.send(:private, *saved_private_class_methods)
+        klass.send(:protected, *saved_protected_class_methods)
+        private(*saved_private_instance_methods)
+        protected(*saved_protected_instance_methods)
+      end
+    end
+  end
+end

data/spec/models/content.rb

@@ -0,0 +1,16 @@
+module Content
+  class Dialect
+    include DataMapper::Resource
+
+    property :id,   Serial
+    property :name, String
+    property :code, String
+  end
+
+  class Locale
+    include DataMapper::Resource
+
+    property :id,   Serial
+    property :name, String
+  end
+end

data/spec/models/vehicles.rb

@@ -0,0 +1,34 @@
+# ==========================
+# Used for Association specs
+# ---
+# These models will probably
+# end up removed. So, I wouldn't
+# use this metaphor
+class Vehicle
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+
+  class << self
+    attr_accessor :mock_relationship
+  end
+end
+
+class Manufacturer
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+
+  class << self
+    attr_accessor :mock_relationship
+  end
+end
+
+class Supplier
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :name, String
+end

data/spec/models/zoo.rb

@@ -0,0 +1,48 @@
+class Zoo
+  include DataMapper::Resource
+
+  property :id,           Serial
+  property :name,         String
+  property :description,  Text
+  property :inception,    DateTime
+  property :open,         Boolean,  :default => false
+  property :size,         Integer
+  property :mission,      Text, :writer => :protected
+
+  has n, :animals
+
+  def to_s
+    name
+  end
+end
+
+class Species
+  include DataMapper::Resource
+
+  property :id,             Serial
+  property :name,           String
+  property :classification, String, :reader => :private
+
+  has n, :animals
+end
+
+class Animal
+  include DataMapper::Resource
+
+  property :id,   Serial
+  property :name, String
+
+  belongs_to :zoo
+  belongs_to :species
+  belongs_to :keeper
+end
+
+class Employee
+  include DataMapper::Resource
+
+  property :name, String, :key => true
+end
+
+class Keeper < Employee
+  has n, :animals
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--loadby random
+--format progress

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+require 'pathname'
+require 'rubygems'
+
+gem 'rspec', '~>1.2'
+require 'spec'
+
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+require SPEC_ROOT.parent + 'lib/dm-core'
+
+# Load the various helpers for the spec suite
+Dir[(DataMapper.root / 'spec' / 'lib' / '*.rb').to_s].each do |file|
+  require file
+end
+
+# setup mock adapters
+DataMapper.setup(:default2, "sqlite3::memory:")
+
+[ :mock, :legacy, :west_coast, :east_coast ].each do |repository_name|
+  DataMapper.setup(repository_name, "mock://localhost/#{repository_name}")
+end
+
+# These environment variables will override the default connection string:
+#   MYSQL_SPEC_URI
+#   POSTGRES_SPEC_URI
+#   SQLITE3_SPEC_URI
+#
+# For example, in the bash shell, you might use:
+#   export MYSQL_SPEC_URI="mysql://localhost/dm_core_test?socket=/opt/local/var/run/mysql5/mysqld.sock"
+#
+def setup_adapter(name, default_uri)
+  begin
+    adapter = DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
+
+    if name.to_s == ENV['ADAPTER']
+      Object.const_set('ADAPTER', ENV['ADAPTER'].to_sym)
+      DataMapper::Repository.adapters[:default] = adapter
+    end
+
+    true
+  rescue Exception => e
+    if name.to_s == ENV['ADAPTER']
+      Object.const_set('ADAPTER', nil)
+      warn "Could not load #{name} adapter: #{e}"
+    end
+    false
+  end
+end
+
+ENV['ADAPTER'] ||= 'sqlite3'
+
+HAS_SQLITE3  = setup_adapter(:sqlite3,  'sqlite3::memory:')
+HAS_MYSQL    = setup_adapter(:mysql,    'mysql://localhost/dm_core_test')
+HAS_POSTGRES = setup_adapter(:postgres, 'postgres://postgres@localhost/dm_core_test')
+
+DataMapper::Logger.new(nil, :debug)
+
+# ----------------------------------------------------------------------
+# --- Do not declare new models unless absolutely necessary. Instead ---
+# --- pick a metaphor and use those models. If you do need new       ---
+# --- models, define them according to the metaphor being used.      ---
+# ----------------------------------------------------------------------
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    # load_models_for_metaphor :vehicles
+  end
+end
+
+# ----------------------------------------------------------------------
+# --- All these models are going to be removed. Don't use them!!!    ---
+# ----------------------------------------------------------------------
+
+class Article
+  include DataMapper::Resource
+
+  property :id,         Serial
+  property :blog_id,    Integer
+  property :created_at, DateTime
+  property :author,     String
+  property :title,      String
+end
+
+class Comment
+  include DataMapper::Resource
+
+  property :id,         Serial # blah
+end
+
+class NormalClass
+  # should not include DataMapper::Resource
+end

data/spec/unit/adapters/abstract_adapter_spec.rb

@@ -0,0 +1,133 @@
+require 'monitor'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'adapters', 'adapter_shared_spec'))
+
+describe DataMapper::Adapters::AbstractAdapter do
+
+  before do
+    @adapter = DataMapper::Adapters::AbstractAdapter.new(:default, 'mock_uri_string')
+  end
+
+  it_should_behave_like 'a DataMapper Adapter'
+
+  describe "when handling transactions" do
+    before :each do
+      @transaction = DataMapper::Transaction.new(@adapter)
+    end
+    it "should be able to push and pop transactions on the current stack" do
+      @adapter.current_transaction.should == nil
+      @adapter.within_transaction?.should == false
+      @adapter.push_transaction(@transaction)
+      @adapter.current_transaction.should == @transaction
+      @adapter.within_transaction?.should == true
+      @adapter.push_transaction(@transaction)
+      @adapter.current_transaction.should == @transaction
+      @adapter.within_transaction?.should == true
+      @adapter.pop_transaction
+      @adapter.current_transaction.should == @transaction
+      @adapter.within_transaction?.should == true
+      @adapter.pop_transaction
+      @adapter.current_transaction.should == nil
+      @adapter.within_transaction?.should == false
+    end
+    it "should let each Thread have its own transaction stack" do
+      lock = Monitor.new
+      transaction2 = DataMapper::Transaction.new(@adapter)
+      @adapter.within_transaction?.should == false
+      @adapter.current_transaction.should == nil
+      @adapter.push_transaction(transaction2)
+      @adapter.within_transaction?.should == true
+      @adapter.current_transaction.should == transaction2
+      lock.synchronize do
+        Thread.new do
+          @adapter.within_transaction?.should == false
+          @adapter.current_transaction.should == nil
+          @adapter.push_transaction(@transaction)
+          @adapter.within_transaction?.should == true
+          @adapter.current_transaction.should == @transaction
+          lock.synchronize do
+            @adapter.within_transaction?.should == true
+            @adapter.current_transaction.should == @transaction
+            @adapter.pop_transaction
+            @adapter.within_transaction?.should == false
+            @adapter.current_transaction.should == nil
+          end
+        end
+        @adapter.within_transaction?.should == true
+        @adapter.current_transaction.should == transaction2
+        @adapter.pop_transaction
+        @adapter.within_transaction?.should == false
+        @adapter.current_transaction.should == nil
+      end
+    end
+  end
+
+  it "should raise NotImplementedError when #create is called" do
+    lambda { @adapter.create([ :resource ]) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #read_many is called" do
+    lambda { @adapter.read_many(:query) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #read_one is called" do
+    lambda { @adapter.read_one(:query) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #update is called" do
+    lambda { @adapter.update(:attributes, :query) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #delete is called" do
+    lambda { @adapter.delete(:query) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #upgrade_model_storage is called" do
+    lambda { @adapter.upgrade_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #storage_exists? is called" do
+    lambda { @adapter.storage_exists?("hehu") }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #create_model_storage is called" do
+    lambda { @adapter.create_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #destroy_model_storage is called" do
+    lambda { @adapter.destroy_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #alter_model_storage is called" do
+    lambda { @adapter.alter_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #create_property_storage is called" do
+    lambda { @adapter.create_property_storage(:repository, :property) }
+  end
+
+  it "should raise NotImplementedError when #destroy_property_storage is called" do
+    lambda { @adapter.destroy_property_storage(:repository, :property) }
+  end
+
+  it "should raise NotImplementedError when #alter_property_storage is called" do
+    lambda { @adapter.alter_property_storage(:repository, :property) }
+  end
+
+  it "should raise NotImplementedError when #transaction_primitive is called" do
+    lambda { @adapter.transaction_primitive }.should raise_error(NotImplementedError)
+  end
+
+  it "should clean out dead threads from @transactions" do
+    @adapter.instance_eval do @transactions end.size.should == 0
+    t = Thread.new do
+      @adapter.push_transaction("plur")
+    end
+    while t.alive?
+      sleep 0.1
+    end
+    @adapter.instance_eval do @transactions end.size.should == 1
+    @adapter.push_transaction("ploj")
+    @adapter.instance_eval do @transactions end.size.should == 1
+  end
+end