lookout-mongo_mapper 0.11.3

data/test/unit/test_pagination.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase
+  should "default per_page to 25" do
+    Doc().per_page.should == 25
+  end
+
+  should "allow overriding per_page" do
+    Doc() { def self.per_page; 1 end }.per_page.should == 1
+  end
+end

data/test/unit/test_plugins.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+class PluginsTest < Test::Unit::TestCase
+  should "default plugins to empty array" do
+    Class.new { extend MongoMapper::Plugins }.plugins.should == []
+  end
+
+  context "a plugin" do
+    module MyConcern
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :from_concern
+      end
+
+      module ClassMethods
+        def class_foo
+          'class_foo'
+        end
+      end
+
+      def instance_foo
+        'instance_foo'
+      end
+    end
+
+    setup do
+      @document = Class.new do
+        extend MongoMapper::Plugins
+        plugin MyConcern
+      end
+    end
+
+    should "include instance methods" do
+      @document.new.instance_foo.should == 'instance_foo'
+    end
+
+    should "extend class methods" do
+      @document.class_foo.should == 'class_foo'
+    end
+
+    should "pass model to configure" do
+      @document.new.should respond_to(:from_concern)
+    end
+
+    should "add plugin to plugins" do
+      @document.plugins.should include(MyConcern)
+    end
+
+    context "Document" do
+      setup do
+        MongoMapper::Document.plugins.delete(MyConcern)
+      end
+
+      should 'allow plugins on Document' do
+        MongoMapper::Document.plugin(MyConcern)
+        Doc().should respond_to(:class_foo)
+        Doc().new.should respond_to(:instance_foo)
+      end
+
+      should 'add plugins to classes that include Document before they are added' do
+        article = Doc()
+        MongoMapper::Document.plugin(MyConcern)
+        article.should respond_to(:class_foo)
+        article.new.should respond_to(:instance_foo)
+      end
+    end
+
+    context "EmbeddedDocument" do
+      setup do
+        MongoMapper::EmbeddedDocument.plugins.delete(MyConcern)
+      end
+
+      should 'allow plugins on EmbeddedDocument' do
+        MongoMapper::EmbeddedDocument.plugin(MyConcern)
+        article = EDoc()
+        article.should respond_to(:class_foo)
+        article.new.should respond_to(:instance_foo)
+      end
+
+      should 'add plugins to classes that include EmbeddedDocument before they are added' do
+        article = EDoc()
+        MongoMapper::EmbeddedDocument.plugin(MyConcern)
+        article.should respond_to(:class_foo)
+        article.new.should respond_to(:instance_foo)
+      end
+    end
+  end
+end

data/test/unit/test_rails.rb

@@ -0,0 +1,183 @@
+require 'test_helper'
+
+class TestRails < Test::Unit::TestCase
+  context "Document" do
+    setup do
+      @klass = Doc('Post') do
+        key :foo, String
+      end
+    end
+
+    context "Class methods" do
+      should "alias has_many to many" do
+        @klass.should respond_to(:has_many)
+      end
+
+      should 'pass on block given in has_many' do
+        @klass.class_eval do
+          has_many :posts do
+            def foo_bars; true; end
+          end
+        end
+
+        @klass.new.posts.should respond_to(:foo_bars)
+      end
+
+      should "alias has_one to one" do
+        @klass.should respond_to(:has_one)
+      end
+
+      should "have column names" do
+        @klass.column_names.sort.should == ['_id', 'foo']
+      end
+    end
+
+    context "Instance methods" do
+      setup do
+        @klass.class_eval do
+          def bar=(value)
+            write_attribute(:foo, value)
+          end
+
+          def bar_before_type_cast
+            read_attribute_before_type_cast(:foo)
+          end
+
+          def bar
+            read_attribute(:foo)
+          end
+        end
+      end
+
+      should "alias new_record? to new?" do
+        @klass.new.should be_new_record
+      end
+
+      should "be able to read key with read_attribute" do
+        @klass.new(:foo => 'Bar').bar.should == 'Bar'
+      end
+
+      should "be able to read key before type cast with read_attribute_before_type_cast" do
+        @klass.new(:foo => 21).bar_before_type_cast.should == 21
+        @klass.new(:foo => 21).bar.should == '21'
+      end
+
+      should "be able to write key with write_attribute" do
+        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
+      end
+
+      context '#to_param' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_param.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.create.tap do |doc|
+            doc.to_param.should == doc.id.to_s
+          end
+        end
+      end
+
+      context '#to_key' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_key.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.create.tap do |doc|
+            doc.to_key.should == [doc.id]
+          end
+        end
+      end
+    end
+  end
+
+  context "EmbeddedDocument" do
+    setup do
+      @klass = EDoc('Post') { key :foo, String }
+    end
+
+    context "Class methods" do
+      should "alias has_many to many" do
+        @klass.should respond_to(:has_many)
+      end
+
+      should "alias has_one to one" do
+        @klass.should respond_to(:has_one)
+      end
+
+      should "have column names" do
+        @klass.column_names.sort.should == ['_id', 'foo']
+      end
+    end
+
+    context "Instance methods" do
+      setup do
+        @klass.class_eval do
+          def bar=(value)
+            write_attribute(:foo, value)
+          end
+
+          def bar_before_type_cast
+            read_attribute_before_type_cast(:foo)
+          end
+
+          def bar
+            read_attribute(:foo)
+          end
+        end
+      end
+
+      should "alias new_record? to new?" do
+        @klass.new.should be_new_record
+      end
+
+      should "be able to read key with read_attribute" do
+        @klass.new(:foo => 'Bar').bar.should == 'Bar'
+      end
+
+      should "be able to read key before type cast with read_attribute_before_type_cast" do
+        @klass.new(:foo => 21).bar_before_type_cast.should == 21
+        @klass.new(:foo => 21).bar.should == '21'
+      end
+
+      should "be able to write key with write_attribute" do
+        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
+      end
+
+      context '#to_param' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_param.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.new.tap do |doc|
+            doc.expects(:persisted?).returns(true)
+            doc.to_param.should == doc.id.to_s
+          end
+        end
+      end
+
+      context '#to_key' do
+        should "be nil if not persisted" do
+          @klass.new.tap do |doc|
+            doc.to_key.should be_nil
+          end
+        end
+
+        should "array representation of id if persisted" do
+          @klass.new.tap do |doc|
+            doc.expects(:persisted?).returns(true)
+            doc.to_key.should == [doc.id]
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/test_rails_compatibility.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  class Item
+    include MongoMapper::EmbeddedDocument
+    key :for_all, String
+  end
+
+  class FirstItem < Item
+    key :first_only, String
+    many :second_items
+  end
+
+  class SecondItem < Item
+    key :second_only, String
+  end
+
+  context "EmbeddedDocument" do
+    should "alias many to has_many" do
+      FirstItem.should respond_to(:has_many)
+    end
+
+    should "alias one to has_one" do
+      FirstItem.should respond_to(:has_one)
+    end
+
+    should "have column names" do
+      Item.column_names.sort.should == ['_id', '_type', 'for_all']
+      FirstItem.column_names.sort.should == ['_id', '_type', 'first_only', 'for_all']
+      SecondItem.column_names.sort.should == ['_id', '_type', 'for_all', 'second_only']
+    end
+
+    should "alias new to new_record?" do
+      instance = Item.new
+      instance.new_record?.should == instance.new?
+    end
+  end
+end

data/test/unit/test_rails_reflect_on_association.rb

@@ -0,0 +1,118 @@
+require 'test_helper'
+
+module ReflectOnAssociationTestModels
+  class Tree
+    include MongoMapper::Document
+    many :birds, :class_name => "ReflectOnAssociationTestModels::Bird"
+  end
+
+  class Bird
+    include MongoMapper::Document
+    belongs_to :tree, :class_name => "ReflectOnAssociationTestModels::Tree"
+  end
+
+  class Book
+    include MongoMapper::Document
+    many :authors, :class_name => "ReflectOnAssociationTestModels::Author", :in => :author_ids
+  end
+
+  class Author
+    include MongoMapper::Document
+  end
+
+  class Employee
+    include MongoMapper::Document
+    one :desk, :class_name => "ReflectOnAssociationTestModels::Desk"
+  end
+
+  class Desk
+    include MongoMapper::Document
+    belongs_to :employee, :class_name => "ReflectOnAssociationTestModels::Employee"
+  end
+
+  class Order
+    include MongoMapper::Document
+    many :line_items, :class_name => "ReflectOnAssociationTestModels::LineItem"
+  end
+
+  class LineItem
+    include MongoMapper::EmbeddedDocument
+  end
+
+  class Body
+    include MongoMapper::Document
+    one :heart, :class_name => "ReflectOnAssociationTestModels::Heart"
+  end
+
+  class Heart
+    include MongoMapper::EmbeddedDocument
+  end
+end
+
+class ReflectOnAssociationTest < Test::Unit::TestCase
+  context "one-to-many association" do
+    should "return :has_many association for Tree#birds" do
+      association = ReflectOnAssociationTestModels::Tree.reflect_on_association(:birds)
+      association.klass.should == ReflectOnAssociationTestModels::Bird
+      association.macro.should == :has_many
+      association.name.should == :birds
+      association.options.should == {}
+    end
+
+    should "return :belongs_to association for Bird#tree" do
+      association = ReflectOnAssociationTestModels::Bird.reflect_on_association(:tree)
+      association.klass.should == ReflectOnAssociationTestModels::Tree
+      association.macro.should == :belongs_to
+      association.name.should == :tree
+      association.options.should == {}
+    end
+  end
+
+  context "many-to-many association" do
+    should "return :has_many association for Book#authors" do
+      association = ReflectOnAssociationTestModels::Book.reflect_on_association(:authors)
+      association.klass.should == ReflectOnAssociationTestModels::Author
+      association.macro.should == :has_many
+      association.name.should == :authors
+      association.options.should == {}
+    end
+  end
+
+  context "one-to-one association" do
+    should "return :has_one association for Employee#desk" do
+      association = ReflectOnAssociationTestModels::Employee.reflect_on_association(:desk)
+      association.klass.should == ReflectOnAssociationTestModels::Desk
+      association.macro.should == :has_one
+      association.name.should == :desk
+      association.options.should == {}
+    end
+
+    should "return :belongs_to association for Desk#employee" do
+      association = ReflectOnAssociationTestModels::Desk.reflect_on_association(:employee)
+      association.klass.should == ReflectOnAssociationTestModels::Employee
+      association.macro.should == :belongs_to
+      association.name.should == :employee
+      association.options.should == {}
+    end
+  end
+
+  context "embeds one" do
+    should "return :has_one association for Body#heart" do
+      association = ReflectOnAssociationTestModels::Body.reflect_on_association(:heart)
+      association.klass.should == ReflectOnAssociationTestModels::Heart
+      association.macro.should == :has_one
+      association.name.should == :heart
+      association.options.should == {}
+    end
+  end
+
+  context "embeds many" do
+    should "return :has_many association for Order#line_items" do
+      association = ReflectOnAssociationTestModels::Order.reflect_on_association(:line_items)
+      association.klass.should == ReflectOnAssociationTestModels::LineItem
+      association.macro.should == :has_many
+      association.name.should == :line_items
+      association.options.should == {}
+    end
+  end
+end

data/test/unit/test_railtie.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+require "rails"
+require 'mongo_mapper/railtie'
+
+class TestRailtie < Test::Unit::TestCase
+
+  def expect_descendants(expectation)
+    # Keep expectation a string so we don't accidentally load in a class
+    Railtie::Parent.descendants.map(&:to_s).sort.should == expectation.sort
+  end
+
+  def run_initializer(mod, name)
+    initializer = mod.initializers.detect do |i|
+      i.name == name
+    end
+
+    if initializer.nil?
+      raise 'Initializer not found'
+    end
+
+    initializer.block.arity == -1 ? initializer.run : initializer.run(FakeRails)
+    # mongo_mapper.prepare_dispatcher takes a Rails app as its one arg,
+    # set_clear_dependencies_hook takes no args
+  end
+
+  def load_autoloaded_class
+    Railtie::Autoloaded.presence
+  end
+
+  class FakeRails
+    def self.config
+      return Class.new { def cache_classes ; false ; end }.new
+    end
+  end
+
+  context "Railtie" do
+    include Rails::Application::Bootstrap
+
+    setup do
+      require 'support/railtie'
+      require 'support/railtie/parent'
+      require 'support/railtie/not_autoloaded'
+
+      ActiveSupport::Dependencies.autoload_paths << File.join(File.dirname(__FILE__), '..', 'support')
+
+      # These initializers don't actually run anything, they just register cleanup and prepare hooks
+      run_initializer Rails::Application::Bootstrap, :set_clear_dependencies_hook
+      run_initializer MongoMapper::Railtie, 'mongo_mapper.prepare_dispatcher'
+    end
+
+    should "not clear ActiveSupport::DescendantsTracker" do
+      expect_descendants %w( Railtie::NotAutoloaded )
+      load_autoloaded_class
+      expect_descendants %w( Railtie::NotAutoloaded Railtie::Autoloaded )
+
+      ActionDispatch::Reloader.cleanup! # cleanup 'last request'
+
+      expect_descendants %w( Railtie::NotAutoloaded )
+      load_autoloaded_class
+      expect_descendants %w( Railtie::NotAutoloaded Railtie::Autoloaded )
+
+      ActionDispatch::Reloader.prepare! # prepare 'next request'
+      expect_descendants %w( Railtie::NotAutoloaded Railtie::Autoloaded )
+    end
+  end
+end