plucky 0.6.3 → 0.8.0

data/script/test

@@ -0,0 +1,20 @@
+#!/bin/sh
+#/ Usage: test
+#/
+#/ Bootstrap and run all tests.
+#/
+#/ Examples:
+#/
+#/   # run all tests
+#/   test
+#/
+
+set -e
+cd $(dirname "$0")/..
+
+[ "$1" = "--help" -o "$1" = "-h" -o "$1" = "help" ] && {
+    grep '^#/' <"$0"| cut -c4-
+    exit 0
+}
+
+script/bootstrap && bundle exec rake

data/spec/functional/options_hash_spec.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+describe Plucky::OptionsHash do
+  subject { described_class.new }
+
+  describe "#[]=" do
+    it "changes order to sort" do
+      subject[:order] = "foo asc"
+      subject[:sort].should == {"foo" => 1}
+      subject[:order].should be_nil
+    end
+
+    it "changes sort(id) to sort(_id)" do
+      subject[:sort] = "id asc"
+      subject[:sort].should == {"_id" => 1}
+    end
+
+    it "changes select to fields" do
+      subject[:select] = [:foo]
+      subject[:projection].should == {:foo => 1}
+      subject[:select].should be_nil
+    end
+
+    it "changes offset to skip" do
+      subject[:offset] = 10
+      subject[:skip].should == 10
+      subject[:offset].should be_nil
+    end
+
+    it "changes id to _id" do
+      subject[:id] = :foo
+      subject[:_id].should == :foo
+      subject[:id].should be_nil
+    end
+
+    it "does not change the sort field" do
+      subject[:order] = :order.asc
+      subject[:sort].should == {"order" => 1}
+    end
+  end
+end

data/spec/helper.rb

@@ -11,14 +11,19 @@ require 'fileutils'
 require 'logger'
 require 'pp'
 
+if RUBY_ENGINE == "ruby" && RUBY_VERSION >= '2.3'
+  require 'byebug'
+end
+
 log_dir = File.expand_path('../../log', __FILE__)
 FileUtils.mkdir_p(log_dir)
 Log = Logger.new(File.join(log_dir, 'test.log'))
 
 LogBuddy.init :logger => Log
 
-connection = Mongo::MongoClient.new('127.0.0.1', 27017, :logger => Log)
-DB = connection.db('test')
+port = ENV.fetch "BOXEN_MONGODB_PORT", 27017
+connection = Mongo::Client.new(["127.0.0.1:#{port.to_i}"], :logger => Log)
+DB = connection.use('test').database
 
 RSpec.configure do |config|
   config.filter_run :focused => true
@@ -26,16 +31,19 @@ RSpec.configure do |config|
   config.alias_example_to :xit, :pending => true
   config.run_all_when_everything_filtered = true
 
+  config.expect_with(:rspec) { |c| c.syntax = :should }
+  config.mock_with(:rspec) { |c| c.syntax = :should }
+
   config.before(:suite) do
     DB.collections.reject { |collection|
       collection.name =~ /system\./
-    }.map(&:drop_indexes)
+    }.each { |collection| collection.indexes.drop_all}
   end
 
   config.before(:each) do
     DB.collections.reject { |collection|
       collection.name =~ /system\./
-    }.map(&:remove)
+    }.map(&:drop)
   end
 end
 

data/spec/plucky/criteria_hash_spec.rb

@@ -37,9 +37,9 @@ describe Plucky::CriteriaHash do
     end
 
     it "raises argument error if not array" do
-      expect { described_class.new.object_ids = {} }.to raise_error(ArgumentError)
-      expect { described_class.new.object_ids = nil }.to raise_error(ArgumentError)
-      expect { described_class.new.object_ids = 'foo' }.to raise_error(ArgumentError)
+      lambda { described_class.new.object_ids = {} }.should raise_error(ArgumentError)
+      lambda { described_class.new.object_ids = nil }.should raise_error(ArgumentError)
+      lambda { described_class.new.object_ids = 'foo' }.should raise_error(ArgumentError)
     end
   end
 
@@ -90,7 +90,7 @@ describe Plucky::CriteriaHash do
     it "uniques matching key values" do
       c1 = described_class.new(:foo => 'bar')
       c2 = described_class.new(:foo => 'bar')
-      c1.merge(c2).source.should eq(:foo => {:$in => %w[bar]})
+      c1.merge(c2).source.should eq(:foo => 'bar')
     end
 
     it "correctly merges arrays and non-arrays" do
@@ -147,6 +147,70 @@ describe Plucky::CriteriaHash do
       c1.merge(c2).should_not equal(c1)
       c1[:foo].should == 'bar'
     end
+
+    it "merges two hashes with the same key, but nil values as nil" do
+      c1 = described_class.new(:foo => nil)
+      c2 = described_class.new(:foo => nil)
+      c1.merge(c2).source.should == { :foo => nil }
+    end
+
+    it "merges two hashes with the same key, but false values as false" do
+      c1 = described_class.new(:foo => false)
+      c2 = described_class.new(:foo => false)
+      c1.merge(c2).source.should == { :foo => false }
+    end
+
+    it "merges two hashes with the same key, but different values with $in" do
+      c1 = described_class.new(:foo => false)
+      c2 = described_class.new(:foo => true)
+      c1.merge(c2).source.should == { :foo => { :'$in' => [false, true] } }
+    end
+
+    it "merges two hashes with different keys and different values properly" do
+      c1 = described_class.new(:foo => 1)
+      c2 = described_class.new(:bar => 2)
+      c1.merge(c2).source.should == { :foo => 1, :bar => 2 }
+    end
+
+    it "merges two sets" do
+      c1 = described_class.new(:foo => Set.new([1, 2]))
+      c2 = described_class.new(:foo => Set.new([2, 3]))
+      c1.merge(c2).source.should == { :foo => { :'$in' => [1,2,3] } }
+    end
+
+    context "given multiple $or clauses" do
+      before do
+        @c1 = described_class.new(:$or => [{:a => 1}, {:b => 2}])
+        @c2 = described_class.new(:$or => [{:a => 3}, {:b => 4}])
+        @c3 = described_class.new(:$or => [{:a => 4}, {:b => 4}])
+      end
+
+      it "merges two $ors into a compound $and" do
+        merged = @c1.merge(@c2)
+        merged[:$and].should == [
+          {:$or => [{:a => 1}, {:b => 2}]},
+          {:$or => [{:a => 3}, {:b => 4}]}
+        ]
+      end
+
+      it "merges an $and and a $or into a compound $and" do
+        merged = @c1.merge(@c2).merge(@c3)
+        merged[:$and].should == [
+          {:$or => [{:a => 1}, {:b => 2}]},
+          {:$or => [{:a => 3}, {:b => 4}]},
+          {:$or => [{:a => 4}, {:b => 4}]}
+        ]
+      end
+
+      it "merges an $or and an $and into a compound $and" do
+        merged = @c3.merge @c1.merge(@c2)
+        merged[:$and].should == [
+          {:$or => [{:a => 1}, {:b => 2}]},
+          {:$or => [{:a => 3}, {:b => 4}]},
+          {:$or => [{:a => 4}, {:b => 4}]}
+        ]
+      end
+    end
   end
 
   context "#merge!" do

data/spec/plucky/normalizers/criteria_hash_value_spec.rb

@@ -155,7 +155,7 @@ describe Plucky::Normalizers::CriteriaHashValue do
 
   context "nested clauses" do
     it "knows constant array of operators that take nested queries" do
-      described_class::NestingOperators.should == [:$or, :$and, :$nor]
+      described_class::NestingOperators.should == Set[:$or, :$and, :$nor]
     end
 
     described_class::NestingOperators.each do |operator|

data/spec/plucky/normalizers/fields_value_spec.rb

@@ -15,7 +15,7 @@ describe Plucky::Normalizers::FieldsValue do
   end
 
   it "works with array" do
-    subject.call(['one', 'two']).should eq(['one', 'two'])
+    subject.call(['one', 'two']).should eq({'one' => 1, 'two' => 1})
   end
 
   # Ruby 1.9.x was sending array [{:age => 20}], instead of hash.
@@ -24,15 +24,15 @@ describe Plucky::Normalizers::FieldsValue do
   end
 
   it "flattens multi-dimensional array" do
-    subject.call([[:one, :two]]).should eq([:one, :two])
+    subject.call([[:one, :two]]).should eq({:one => 1, :two => 1})
   end
 
   it "works with symbol" do
-    subject.call(:one).should eq([:one])
+    subject.call(:one).should eq({:one => 1})
   end
 
   it "works with array of symbols" do
-    subject.call([:one, :two]).should eq([:one, :two])
+    subject.call([:one, :two]).should eq({:one => 1, :two => 1})
   end
 
   it "works with hash" do
@@ -40,6 +40,6 @@ describe Plucky::Normalizers::FieldsValue do
   end
 
   it "converts comma separated list to array" do
-    subject.call('one, two').should eq(['one', 'two'])
+    subject.call('one, two').should eq({'one' => 1, 'two' => 1})
   end
 end

data/spec/plucky/normalizers/hash_key_spec.rb

@@ -0,0 +1,15 @@
+require 'helper'
+
+describe Plucky::Normalizers::HashKey do
+  subject {
+    described_class.new(:bacon => :sizzle)
+  }
+
+  it "changes defined fields" do
+    subject.call(:bacon).should eq(:sizzle)
+  end
+
+  it "does not change undefined fields" do
+    subject.call(:sausage).should eq(:sausage)
+  end
+end

data/spec/plucky/normalizers/options_hash_value_spec.rb

@@ -26,9 +26,9 @@ describe Plucky::Normalizers::OptionsHashValue do
   }
 
   it "raises exception if missing key normalizer" do
-    expect {
+    lambda {
       described_class.new
-    }.to raise_error(ArgumentError, "Missing required key :key_normalizer")
+    }.should raise_error(ArgumentError, "Missing required key :key_normalizer")
   end
 
   it "allows injecting a new value normalizer" do

data/spec/plucky/normalizers/sort_value_spec.rb

@@ -3,7 +3,7 @@ require 'plucky/normalizers/sort_value'
 
 describe Plucky::Normalizers::SortValue do
   let(:key_normalizer) {
-    lambda { |key| key == :id ? :_id : key.to_sym }
+    Plucky::Normalizers::HashKey.new({:id => :_id})
   }
 
   subject {
@@ -13,9 +13,9 @@ describe Plucky::Normalizers::SortValue do
   }
 
   it "raises exception if missing key normalizer" do
-    expect {
+    lambda {
       described_class.new
-    }.to raise_error(ArgumentError, "Missing required key :key_normalizer")
+    }.should raise_error(ArgumentError, "Missing required key :key_normalizer")
   end
 
   it "defaults to nil" do
@@ -31,64 +31,68 @@ describe Plucky::Normalizers::SortValue do
   end
 
   it "converts single ascending field (string)" do
-    subject.call('foo asc').should eq([['foo', 1]])
-    subject.call('foo ASC').should eq([['foo', 1]])
+    subject.call('foo asc').should eq({'foo' => 1})
+    subject.call('foo ASC').should eq({'foo' => 1})
   end
 
   it "converts single descending field (string)" do
-    subject.call('foo desc').should eq([['foo', -1]])
-    subject.call('foo DESC').should eq([['foo', -1]])
+    subject.call('foo desc').should eq({'foo' => -1})
+    subject.call('foo DESC').should eq({'foo' => -1})
   end
 
   it "converts multiple fields (string)" do
-    subject.call('foo desc, bar asc').should eq([['foo', -1], ['bar', 1]])
+    subject.call('foo desc, bar asc').should eq({'foo' => -1, 'bar' => 1})
   end
 
   it "converts multiple fields and default no direction to ascending (string)" do
-    subject.call('foo desc, bar, baz').should eq([['foo', -1], ['bar', 1], ['baz', 1]])
+    subject.call('foo desc, bar, baz').should eq({'foo' => -1, 'bar' => 1, 'baz' => 1})
   end
 
   it "converts symbol" do
-    subject.call(:name).should eq([['name', 1]])
+    subject.call(:name).should eq({'name' => 1})
   end
 
   it "converts operator" do
-    subject.call(:foo.desc).should eq([['foo', -1]])
+    subject.call(:foo.desc).should eq({'foo' => -1})
   end
 
   it "converts array of operators" do
-    subject.call([:foo.desc, :bar.asc]).should eq([['foo', -1], ['bar', 1]])
+    subject.call([:foo.desc, :bar.asc]).should eq({'foo' => -1, 'bar' => 1})
   end
 
   it "converts array of symbols" do
-    subject.call([:first_name, :last_name]).should eq([['first_name', 1], ['last_name', 1]])
+    subject.call([:first_name, :last_name]).should eq({'first_name' => 1, 'last_name' => 1})
   end
 
   it "works with array and one string element" do
-    subject.call(['foo, bar desc']).should eq([['foo', 1], ['bar', -1]])
+    subject.call(['foo, bar desc']).should eq({'foo' => 1, 'bar' => -1})
   end
 
   it "works with array of single array" do
-    subject.call([['foo', -1]]).should eq([['foo', -1]])
+    subject.call([['foo', -1]]).should eq({'foo' => -1})
   end
 
   it "works with array of multiple arrays" do
-    subject.call([['foo', -1], ['bar', 1]]).should eq([['foo', -1], ['bar', 1]])
+    subject.call([['foo', -1], ['bar', 1]]).should eq({'foo' => -1, 'bar' => 1})
   end
 
   it "compacts nil values in array" do
-    subject.call([nil, :foo.desc]).should eq([['foo', -1]])
+    subject.call([nil, :foo.desc]).should eq({'foo' => -1})
   end
 
   it "converts array with mix of values" do
-    subject.call([:foo.desc, 'bar']).should eq([['foo', -1], ['bar', 1]])
+    subject.call([:foo.desc, 'bar']).should eq({'foo' => -1, 'bar' => 1})
   end
 
   it "converts keys based on key normalizer" do
-    subject.call([:id.asc]).should eq([['_id', 1]])
+    subject.call([:id.asc]).should eq({'_id' => 1})
+  end
+
+  it "doesn't convert keys like :sort to :order via key normalizer" do
+    subject.call(:order.asc).should eq({'order' => 1})
   end
 
   it "converts string with $natural correctly" do
-    subject.call('$natural desc').should eq([['$natural', -1]])
+    subject.call('$natural desc').should eq({'$natural' => -1})
   end
 end

data/spec/plucky/options_hash_spec.rb

@@ -3,7 +3,7 @@ require 'helper'
 describe Plucky::OptionsHash do
   describe "#initialize_copy" do
     before do
-      @original = described_class.new(:fields => {:name => true}, :sort => :name, :limit => 10)
+      @original = described_class.new(:projection => {:name => true}, :sort => :name, :limit => 10)
       @cloned   = @original.clone
     end
 
@@ -12,7 +12,7 @@ describe Plucky::OptionsHash do
     end
 
     it "clones duplicable? values" do
-      @cloned[:fields].should_not equal(@original[:fields])
+      @cloned[:projection].should_not equal(@original[:projection])
       @cloned[:sort].should_not equal(@original[:sort])
     end
   end

data/spec/plucky/pagination/{decorator_spec.rb → collection_spec.rb}

@@ -1,15 +1,13 @@
 require 'helper'
 
-describe Plucky::Pagination::Decorator do
-  context "Object decorated with Decorator with paginator set" do
+describe Plucky::Pagination::Collection do
+  context "Object decorated with Collection with paginator set" do
     before do
       @object    = [1, 2, 3, 4]
       @object_id = @object.object_id
       @paginator = Plucky::Pagination::Paginator.new(20, 2, 10)
-      @object.extend(described_class)
-      @object.paginator(@paginator)
     end
-    subject { @object }
+    subject { Plucky::Pagination::Collection.new(@object, @paginator) }
 
     it "knows paginator" do
       subject.paginator.should == @paginator
@@ -28,5 +26,10 @@ describe Plucky::Pagination::Decorator do
       @object.size.should       == 4
       @object.select { |o| o > 2 }.should == [3, 4]
     end
+
+    it "delegates missing methods to the paginator" do
+      @paginator.should_receive(:blather_matter).with('hello', :xyz, 4)
+      subject.blather_matter('hello', :xyz, 4)
+    end
   end
 end

data/spec/plucky/query_spec.rb

@@ -2,13 +2,13 @@ require 'helper'
 
 describe Plucky::Query do
   before do
-    @chris      = BSON::OrderedHash['_id', 'chris', 'age', 26, 'name', 'Chris']
-    @steve      = BSON::OrderedHash['_id', 'steve', 'age', 29, 'name', 'Steve']
-    @john       = BSON::OrderedHash['_id', 'john',  'age', 28, 'name', 'John']
+    @chris      = Hash['_id', 'chris', 'age', 26, 'name', 'Chris']
+    @steve      = Hash['_id', 'steve', 'age', 29, 'name', 'Steve']
+    @john       = Hash['_id', 'john',  'age', 28, 'name', 'John']
     @collection = DB['users']
-    @collection.insert(@chris)
-    @collection.insert(@steve)
-    @collection.insert(@john)
+    @collection.insert_one(@chris)
+    @collection.insert_one(@steve)
+    @collection.insert_one(@john)
   end
 
   context "#initialize" do
@@ -57,7 +57,7 @@ describe Plucky::Query do
   context "#find_each" do
     it "returns a cursor" do
       cursor = described_class.new(@collection).find_each
-      cursor.should be_instance_of(Mongo::Cursor)
+      cursor.should be_instance_of(Enumerator)
     end
 
     it "works with and normalize criteria" do
@@ -78,8 +78,8 @@ describe Plucky::Query do
 
     it "is Ruby-like and returns a reset cursor if a block is given" do
       cursor = described_class.new(@collection).find_each {}
-      cursor.should be_instance_of(Mongo::Cursor)
-      cursor.next.should be_instance_of(BSON::OrderedHash)
+      cursor.should be_instance_of(Enumerator)
+      cursor.next.should be_kind_of(Hash)
     end
   end
 
@@ -128,7 +128,7 @@ describe Plucky::Query do
     end
 
     it "normalizes if using object id" do
-      id = @collection.insert(:name => 'Frank')
+      id = @collection.insert_one(:name => 'Frank').inserted_id
       @query.object_ids([:_id])
       doc = @query.find(id.to_s)
       doc['name'].should == 'Frank'
@@ -203,6 +203,27 @@ describe Plucky::Query do
     end
   end
 
+  context "#view" do
+    it 'returns a mongo::collection::view' do
+      described_class.new(@collection).view.should be_a(Mongo::Collection::View)
+    end
+
+    it 'converts criteria into the view' do
+      view = described_class.new(@collection).where(:name => "bob").view
+      view.filter.should == {"name" => "bob"}
+    end
+
+    it "converts read option symbol to a server selector" do
+      view = described_class.new(@collection, :read => :secondary_preferred).view
+      view.read.should be_a(Mongo::ServerSelector::SecondaryPreferred)
+    end
+
+    it "converts read option hash to a server selector" do
+      view = described_class.new(@collection, :read => {:mode =>:secondary_preferred}).view
+      view.read.should be_a(Mongo::ServerSelector::SecondaryPreferred)
+    end
+  end
+
   context "#all" do
     it "works with no arguments" do
       docs = described_class.new(@collection).all
@@ -279,6 +300,10 @@ describe Plucky::Query do
       query.count(:name => 'Steve')
       query[:name].should be_nil
     end
+
+    it 'counts the result set and not the enumerator' do
+      described_class.new(@collection).limit(1).count.should == 3
+    end
   end
 
   context "#size" do
@@ -290,8 +315,8 @@ describe Plucky::Query do
   context "#distinct" do
     before do
       # same age as John
-      @mark = BSON::OrderedHash['_id', 'mark', 'age', 28, 'name', 'Mark']
-      @collection.insert(@mark)
+      @mark = Hash['_id', 'mark', 'age', 28, 'name', 'Mark']
+      @collection.insert_one(@mark)
     end
 
     it "works with just a key" do
@@ -489,23 +514,23 @@ describe Plucky::Query do
     end
 
     it "works with symbol operators" do
-      subject.sort(:foo.asc, :bar.desc).options[:sort].should == [['foo', 1], ['bar', -1]]
+      subject.sort(:foo.asc, :bar.desc).options[:sort].should == {"foo" => 1, "bar" => -1}
     end
 
     it "works with string" do
-      subject.sort('foo, bar desc').options[:sort].should == [['foo', 1], ['bar', -1]]
+      subject.sort('foo, bar desc').options[:sort].should == {"foo" => 1, "bar" => -1}
     end
 
     it "works with just a symbol" do
-      subject.sort(:foo).options[:sort].should == [['foo', 1]]
+      subject.sort(:foo).options[:sort].should == {"foo" => 1}
     end
 
     it "works with symbol descending" do
-      subject.sort(:foo.desc).options[:sort].should == [['foo', -1]]
+      subject.sort(:foo.desc).options[:sort].should == {"foo" => -1}
     end
 
     it "works with multiple symbols" do
-      subject.sort(:foo, :bar).options[:sort].should == [['foo', 1], ['bar', 1]]
+      subject.sort(:foo, :bar).options[:sort].should == {"foo" => 1, "bar" => 1}
     end
 
     it "returns new instance of query" do
@@ -515,8 +540,8 @@ describe Plucky::Query do
     end
 
     it "is aliased to order" do
-      subject.order(:foo).options[:sort].should       == [['foo', 1]]
-      subject.order(:foo, :bar).options[:sort].should == [['foo', 1], ['bar', 1]]
+      subject.order(:foo).options[:sort].should       == {"foo" => 1}
+      subject.order(:foo, :bar).options[:sort].should == {"foo" => 1, "bar" => 1}
     end
   end
 
@@ -529,27 +554,27 @@ describe Plucky::Query do
     end
 
     it "does not error if no sort provided" do
-      expect {
+      lambda {
         subject.reverse
-      }.to_not raise_error
+      }.should_not raise_error
     end
 
     it "reverses the sort order" do
       subject.sort('foo asc, bar desc').
-        reverse.options[:sort].should == [['foo', -1], ['bar', 1]]
+        reverse.options[:sort].should == {"foo" => -1, "bar" => 1}
     end
 
     it "returns new instance of query" do
       sorted_query = subject.sort(:name)
       new_query = sorted_query.reverse
       new_query.should_not equal(sorted_query)
-      sorted_query[:sort].should == [['name', 1]]
+      sorted_query[:sort].should == {'name' => 1}
     end
   end
 
   context "#amend" do
     it "normalizes and update options" do
-      described_class.new(@collection).amend(:order => :age.desc).options[:sort].should == [['age', -1]]
+      described_class.new(@collection).amend(:order => :age.desc).options[:sort].should == {'age' => -1}
     end
 
     it "works with simple stuff" do
@@ -611,7 +636,7 @@ describe Plucky::Query do
 
   context "#empty?" do
     it "returns true if empty" do
-      @collection.remove
+      @collection.drop
       described_class.new(@collection).should be_empty
     end
 
@@ -672,7 +697,7 @@ describe Plucky::Query do
     it "returns a working enumerator" do
       query = described_class.new(@collection)
       query.each.methods.map(&:to_sym).include?(:group_by).should be(true)
-      query.each.next.should be_instance_of(BSON::OrderedHash)
+      query.each.next.should be_instance_of(BSON::Document)
     end
   end
 
@@ -737,8 +762,8 @@ describe Plucky::Query do
     end
 
     {
-      :fields     => ['foo'],
-      :sort       => [['foo', 1]],
+      :projection => {'foo' => 1},
+      :sort       => {'foo' => 1},
       :hint       => '',
       :skip       => 0,
       :limit      => 0,
@@ -754,14 +779,14 @@ describe Plucky::Query do
 
     it "knows select is an option and remove it from options" do
       query = described_class.new(@collection, :select => 'foo')
-      query.options[:fields].should == ['foo']
+      query.options[:projection].should == {'foo' => 1}
       query.criteria.keys.should_not include(:select)
       query.options.keys.should_not  include(:select)
     end
 
     it "knows order is an option and remove it from options" do
       query = described_class.new(@collection, :order => 'foo')
-      query.options[:sort].should == [['foo', 1]]
+      query.options[:sort].should == {'foo' => 1}
       query.criteria.keys.should_not include(:order)
       query.options.keys.should_not  include(:order)
     end
@@ -777,15 +802,15 @@ describe Plucky::Query do
       query = described_class.new(@collection, {
         :foo    => 'bar',
         :baz    => true,
-        :sort   => [['foo', 1]],
+        :sort   => {"foo" => 1},
         :fields => ['foo', 'baz'],
         :limit  => 10,
         :skip   => 10,
       })
       query.criteria.source.should eq(:foo => 'bar', :baz => true)
       query.options.source.should eq({
-        :sort   => [['foo', 1]],
-        :fields => ['foo', 'baz'],
+        :sort   => {"foo" => 1},
+        :projection => {'foo' => 1, 'baz' => 1},
         :limit  => 10,
         :skip   => 10,
       })
@@ -815,8 +840,14 @@ describe Plucky::Query do
 
     it "works" do
       explain = subject.where(:age.lt => 28).explain
-      explain['cursor'].should == 'BasicCursor'
-      explain['nscanned'].should == 3
+
+      if explain['cursor']
+        explain['cursor'].should == 'BasicCursor'
+        explain['nscanned'].should == 3
+      elsif explain['executionStats']
+        explain['executionStats']['executionSuccess'].should == true
+        explain['executionStats']['totalDocsExamined'].should == 3
+      end
     end
   end
 
@@ -838,5 +869,31 @@ describe Plucky::Query do
         result.should be_instance_of(@user_class)
       end
     end
+
+    it "works with block form of find_each" do
+      results = []
+      @query.find_each do |doc|
+        results << doc
+      end
+      results.each do |result|
+        result.should be_instance_of(@user_class)
+      end
+    end
+  end
+
+  describe "insert" do
+    before  { @query = described_class.new(@collection) }
+    subject { @query }
+
+    it "should be able to insert one doc" do
+      subject.insert({ foo: 'bar' })
+      subject.count({ foo: 'bar' }).should == 1
+    end
+
+    it "should be able to insert multiple" do
+      subject.insert([{ foo: 'bar' }, { baz: 'quxx' }])
+      subject.count({ foo: 'bar' }).should == 1
+      subject.count({ baz: 'quxx' }).should == 1
+    end
   end
 end