pwnash-mongo_mapper 0.7.5 → 0.7.6

data/test/unit/test_keys.rb

@@ -1,216 +0,0 @@
-require 'test_helper'
-
-class Address
-  include MongoMapper::EmbeddedDocument
-
-  key :address, String
-  key :city,    String
-  key :state,   String
-  key :zip,     Integer
-end
-
-class FooType < Struct.new(:bar)
-  def self.to_mongo(value)
-    'to_mongo'
-  end
-
-  def self.from_mongo(value)
-    'from_mongo'
-  end
-end
-
-class KeyTest < Test::Unit::TestCase
-  include MongoMapper::Plugins::Keys
-
-  context ".key?(:symbol)" do
-    should "be true if document has key" do
-      Address.key?(:city).should be_true
-    end
-
-    should "be false if document does not have key" do
-      Address.key?(:foo).should be_false
-    end
-  end
-
-  context ".key?('string')" do
-    should "be true if document has key" do
-      Address.key?('city').should be_true
-    end
-
-    should "be false if document does not have key" do
-      Address.key?('foo').should be_false
-    end
-  end
-
-  context ".new (from database)" do
-    setup do
-      @klass = Doc do
-        key :user, Hash
-
-        def user=(user)
-          super(:id => user.id, :name => user.name)
-        end
-      end
-
-      user_class = Struct.new(:id, :name)
-      @klass.create(:user => user_class.new(1, 'John Nunemaker'))
-    end
-
-    should "use []= for keys instead of public writer" do
-      assert_nothing_raised do
-        doc = @klass.first
-        doc.user['id'].should   == 1
-        doc.user['name'].should == 'John Nunemaker'
-      end
-    end
-  end
-
-  context "Initializing a new key" do
-    should "allow setting the name" do
-      Key.new(:foo, String).name.should == 'foo'
-    end
-
-    should "allow setting the type" do
-      Key.new(:foo, Integer).type.should be(Integer)
-    end
-
-    should "allow setting options" do
-      Key.new(:foo, Integer, :required => true).options[:required].should be(true)
-    end
-
-    should "default options to {}" do
-      Key.new(:foo, Integer, nil).options.should == {}
-    end
-
-    should "symbolize option keys" do
-      Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
-    end
-
-    should "work with just name" do
-      key = Key.new(:foo)
-      key.name.should == 'foo'
-    end
-
-    should "work with name and type" do
-      key = Key.new(:foo, String)
-      key.name.should == 'foo'
-      key.type.should == String
-    end
-
-    should "work with name, type, and options" do
-      key = Key.new(:foo, String, :required => true)
-      key.name.should == 'foo'
-      key.type.should == String
-      key.options[:required].should be_true
-    end
-
-    should "work with name and options" do
-      key = Key.new(:foo, :required => true)
-      key.name.should == 'foo'
-      key.options[:required].should be_true
-    end
-  end
-
-  context "A key" do
-    should "be equal to another key with same name and type" do
-      Key.new(:name, String).should == Key.new(:name, String)
-    end
-
-    should "not be equal to another key with different name" do
-      Key.new(:name, String).should_not == Key.new(:foo, String)
-    end
-
-    should "not be equal to another key with different type" do
-      Key.new(:name, String).should_not == Key.new(:name, Integer)
-    end
-
-    should "know if it is a embedded_document" do
-      Key.new(:name, EDoc()).embeddable?.should be_true
-    end
-
-    should "know if it is not a embedded_document" do
-      Key.new(:name, String).embeddable?.should be_false
-    end
-
-    should "know if it is a number" do
-      Key.new(:age, Integer).number?.should be_true
-      Key.new(:age, Float).number?.should be_true
-    end
-
-    should "know if it is not a number" do
-      Key.new(:age, String).number?.should be_false
-    end
-  end
-
-  context "setting a value with a custom type" do
-    should "correctly typecast" do
-      key = Key.new(:foo, FooType)
-      key.set("something").should == 'to_mongo'
-    end
-
-    should "correctly typecast if object of that type is given" do
-      key = Key.new(:foo, FooType)
-      key.set(FooType.new('something')).should == 'to_mongo'
-    end
-  end
-
-  context "getting a value with a custom type" do
-    should "use #from_mongo to convert back to custom type" do
-      key = Key.new(:foo, FooType)
-      key.get('something').should == 'from_mongo'
-    end
-  end
-
-  context "getting a value" do
-    should "work with a type" do
-      key = Key.new(:foo, String)
-      key.get('bar').should == 'bar'
-    end
-
-    should "work without type" do
-      key = Key.new(:foo)
-      key.get([1, '2']).should == [1, '2']
-      key.get(false).should == false
-      key.get({}).should == {}
-    end
-
-    context "for a embedded_document" do
-      should "default to nil" do
-        key = Key.new(:foo, Address)
-        key.get(nil).should be_nil
-      end
-
-      should "return instance if instance" do
-        address = Address.new(:city => 'South Bend', :state => 'IN', :zip => 46544)
-        key = Key.new(:foo, Address)
-        key.get(address).should == address
-      end
-    end
-  end
-
-  context "getting a value with a default set" do
-    setup do
-      @key = Key.new(:foo, String, :default => 'baz')
-    end
-
-    should "return default value if value nil" do
-      @key.get(nil).should == 'baz'
-    end
-
-    should "return value if not blank" do
-      @key.get('foobar').should == 'foobar'
-    end
-
-    should "work with Boolean type and false value" do
-      Key.new(:active, Boolean, :default => false).get(nil).should be_false
-    end
-
-    should "work with Boolean type and true value" do
-      Key.new(:active, Boolean, :default => true).get(nil).should be_true
-    end
-
-    should "work with procs" do
-       Key.new(:foo, String, :default => lambda { return 'hello world' }).get(nil).should == "hello world"
-    end
-  end
-end # KeyTest

data/test/unit/test_mongo_mapper.rb

@@ -1,118 +0,0 @@
-require 'test_helper'
-
-class Address; end
-
-class MongoMapperTest < Test::Unit::TestCase
-  should "be able to write and read connection" do
-    conn = Mongo::Connection.new
-    MongoMapper.connection = conn
-    MongoMapper.connection.should == conn
-  end
-
-  should "default connection to new mongo ruby driver" do
-    MongoMapper.connection = nil
-    MongoMapper.connection.should be_instance_of(Mongo::Connection)
-  end
-
-  should "be able to write and read default database" do
-    MongoMapper.database = 'test'
-    MongoMapper.database.should be_instance_of(Mongo::DB)
-    MongoMapper.database.name.should == 'test'
-  end
-
-  should "have document not found error" do
-    lambda {
-      MongoMapper::DocumentNotFound
-    }.should_not raise_error
-  end
-
-  should "be able to read/write config" do
-    config = {
-      'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'},
-      'production'  => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test-prod'}
-    }
-    MongoMapper.config = config
-    MongoMapper.config.should == config
-  end
-
-  context "connecting to environment from config" do
-    should "work without authentication" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
-      }
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, {})
-      MongoMapper.expects(:database=).with('test')
-      Mongo::DB.any_instance.expects(:authenticate).never
-      MongoMapper.connect('development')
-    end
-
-    should "work without authentication using uri" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
-      }
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, {})
-      MongoMapper.expects(:database=).with('test')
-      Mongo::DB.any_instance.expects(:authenticate).never
-      MongoMapper.connect('development')
-    end
-
-    should "work with options" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test'}
-      }
-      connection, logger = mock('connection'), mock('logger')
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, :logger => logger)
-      MongoMapper.connect('development', :logger => logger)
-    end
-
-    should "work with options using uri" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mongodb://127.0.0.1:27017/test'}
-      }
-      connection, logger = mock('connection'), mock('logger')
-      Mongo::Connection.expects(:new).with('127.0.0.1', 27017, :logger => logger)
-      MongoMapper.connect('development', :logger => logger)
-    end
-
-    should "work with authentication" do
-      MongoMapper.config = {
-        'development' => {'host' => '127.0.0.1', 'port' => 27017, 'database' => 'test', 'username' => 'john', 'password' => 'secret'}
-      }
-      Mongo::DB.any_instance.expects(:authenticate).with('john', 'secret')
-      MongoMapper.connect('development')
-    end
-
-    should "work with authentication using uri" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mongodb://john:secret@127.0.0.1:27017/test'}
-      }
-      Mongo::DB.any_instance.expects(:authenticate).with('john', 'secret')
-      MongoMapper.connect('development')
-    end
-
-    should "raise error for invalid scheme" do
-      MongoMapper.config = {
-        'development' => {'uri' => 'mysql://127.0.0.1:5336/foo'}
-      }
-      assert_raises(MongoMapper::InvalidScheme) { MongoMapper.connect('development') }
-    end
-  end
-
-  context "setup" do
-    should "work as shortcut for setting config, environment and options" do
-      config, logger = mock('config'), mock('logger')
-      MongoMapper.expects(:config=).with(config)
-      MongoMapper.expects(:connect).with('development', :logger => logger)
-      MongoMapper.expects(:handle_passenger_forking).never
-      MongoMapper.setup(config, 'development', :logger => logger)
-    end
-
-    should "handle passenger if option present" do
-      config, logger = mock('config'), mock('logger')
-      MongoMapper.expects(:config=).with(config)
-      MongoMapper.expects(:connect).with('development', :logger => logger)
-      MongoMapper.expects(:handle_passenger_forking)
-      MongoMapper.setup(config, 'development', :logger => logger, :passenger => true)
-    end
-  end
-end

data/test/unit/test_pagination.rb

@@ -1,160 +0,0 @@
-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
-
-  context "Pagination proxy" do
-    include MongoMapper::Plugins::Pagination
-
-    should "respond_to? correctly on proxy readers" do
-      proxy = Proxy.new(25, 10, 4)
-      proxy.respond_to?(:subject).should be_true
-      proxy.respond_to?(:total_entries).should be_true
-      proxy.respond_to?(:per_page).should be_true
-      proxy.respond_to?(:current_page).should be_true
-      proxy.respond_to?(:limit).should be_true
-      proxy.respond_to?(:total_pages).should be_true
-      proxy.respond_to?(:out_of_bounds?).should be_true
-      proxy.respond_to?(:previous_page).should be_true
-      proxy.respond_to?(:next_page).should be_true
-      proxy.respond_to?(:skip).should be_true
-      proxy.respond_to?(:offset).should be_true
-
-      # make sure it doesnt respond true to everything
-      proxy.respond_to?(:blahblahblah).should be_false
-    end
-
-    should "respond_to? correctly on proxy writers" do
-      proxy = Proxy.new(25, 10, 4)
-      proxy.respond_to?(:subject=).should be_true
-    end
-
-    should "should have accessors for subject" do
-      subject = [1,2,3,4,5]
-      collection = Proxy.new(25, 2)
-      collection.subject = subject
-      collection.subject.should == subject
-    end
-
-    should "delegate any methods not defined to the subject" do
-      subject = [1,2,3,4,5]
-      collection = Proxy.new(25, 2, 10)
-      collection.subject = subject
-      collection.size.should == 5
-      collection.each_with_index do |value, i|
-        value.should == subject[i]
-      end
-      collection[0..2].should == [1,2,3]
-      collection.class.should == Array
-    end
-
-    should "should respond_to? correctly for methods defined on the subject" do
-      subject = [1,2,3,4,5]
-      def subject.blahblah
-        "BLAHBLAH"
-      end
-      collection = Proxy.new(25, 2, 10)
-      collection.subject = subject
-      collection.respond_to?(:blahblah).should be_true
-    end
-
-    should "return correct value for total_entries" do
-      Proxy.new(25, 2, 10).total_entries.should == 25
-      Proxy.new('25', 2, 10).total_entries.should == 25
-    end
-
-    should "return correct value for per_page" do
-      Proxy.new(25, 2, 10).per_page.should == 10
-      Proxy.new(25, 2, '10').per_page.should == 10
-    end
-
-    should "alias limit to per_page" do
-      Proxy.new(100, 1, 300).limit.should == 300
-    end
-
-    should "set per_page to 25 if nil or blank" do
-      Proxy.new(25, 2).per_page.should == 25
-      Proxy.new(25, 2, '').per_page.should == 25
-    end
-
-    should "return correct value for current_page" do
-      Proxy.new(25, 2, 10).current_page.should == 2
-      Proxy.new(25, '2', 10).current_page.should == 2
-    end
-
-    should "not allow value less than 1 for current page" do
-      Proxy.new(25, -1).current_page.should == 1
-    end
-
-    should "automatically calculate total_pages from total_entries and per page" do
-      Proxy.new(25, 2, 10).total_pages.should == 3
-    end
-
-    should "know how many records to skip" do
-      Proxy.new(25, 2, 10).skip.should == 10
-    end
-
-    should "alias offset to skip" do
-      Proxy.new(25, 2, 10).offset.should == 10
-    end
-
-    should "return true for === Array" do
-      collection = Proxy.new(25, 2, 10)
-      collection.subject = [1, 2]
-      collection.should === Array
-    end
-
-    context "previous_page" do
-      should "be nil if current page 1" do
-        Proxy.new(25, 1, 10).previous_page.should be_nil
-      end
-
-      should "be one less than current page if current is > 1" do
-        Proxy.new(25, 2, 10).previous_page.should == 1
-      end
-    end
-
-    context "next_page" do
-      should "be nil if current page is last page" do
-        Proxy.new(25, 3, 10).next_page.should be_nil
-      end
-
-      should "work for any page that is not last" do
-        Proxy.new(25, 1, 10).next_page.should == 2
-        Proxy.new(25, 2, 10).next_page.should == 3
-      end
-    end
-
-    context "previous_page" do
-      should "be nil if current page is first page" do
-        Proxy.new(25, 1, 10).previous_page.should be_nil
-      end
-
-      should "work for any page other than first" do
-        Proxy.new(25, 2, 10).previous_page.should == 1
-        Proxy.new(25, 3, 10).previous_page.should == 2
-      end
-    end
-
-    context "out_of_bounds?" do
-      should "be true if current_page is greater than total_pages" do
-        Proxy.new(25, 10, 4).out_of_bounds?.should be_true
-      end
-
-      should "be false if current_page is less than total_pages" do
-        Proxy.new(25, 10, 1).out_of_bounds?.should be_false
-        Proxy.new(25, 2, 10).out_of_bounds?.should be_false
-      end
-
-      should "be false if current_page is equal to total_pages" do
-        Proxy.new(25, 3, 10).out_of_bounds?.should be_false
-      end
-    end
-  end
-end