monga 0.0.1

data/monga.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "monga"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Petr Yanovich"]
+  spec.email         = ["fl00r@yandex.ru"]
+  spec.description   = %q{MongoDB Ruby Evented Driver on EventMachine}
+  spec.summary       = %q{MongoDB Ruby Evented Driver on EventMachine}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "eventmachine"
+  spec.add_dependency "bson"
+  spec.add_dependency "bson_ext"
+end

data/spec/helpers/mongodb.rb

@@ -0,0 +1,59 @@
+module Mongodb
+  MONGOD_PATH = "mongod"
+
+  class Instance
+    def initialize(opts)
+      @opts = opts
+      @cmd = [MONGOD_PATH]
+      opts.each do |k,v|
+        @cmd << "--#{k}"
+        @cmd << v.to_s
+      end
+      clean_lock
+      shtdwn
+      start
+    end
+
+    def clean_lock
+      lock = @opts[:dbpath] + "/mongod.lock"
+      File.rm(lock)
+    rescue
+      # ok
+    end
+
+    def shtdwn
+      system "#{@cmd * ' '} --shutdown"
+    end
+
+    def start
+      return @pid if @pid
+      @pid = spawn(*@cmd, out: "/dev/null")
+      sleep(1)
+    end
+
+    def stop
+      return unless @pid
+      Process.kill("SIGINT", @pid)
+      Process.waitpid(@pid)
+      @pid = nil
+    end
+  end
+
+  class ReplicaSet
+    def initialize(ports, opts={})
+      opts[:replSet] ||= "rs1"
+      opts[:dbpath] ||= "/tmp/mongodb/rs0"
+      @instances = {}
+      ports.each.with_index do |prt, i|
+        dbpath = opts[:dbpath] + "-#{i}"
+        o = opts.merge({ port: prt[:port], dbpath: dbpath })
+        @instances[prt[:port]] = Instance.new(o)
+      end
+    end
+
+    def primary
+      pr = RS_CLIENT.primary
+      @instances[pr.aquire_connection.port] if pr
+    end
+  end
+end

data/spec/helpers/truncate.rb

@@ -0,0 +1,15 @@
+module Helpers
+  module Truncate
+    def teardown
+      EM.run do
+        RS_COLLECTION.safe_delete.callback do
+          RS_COLLECTION.drop_indexes.callback do
+            COLLECTION.safe_delete.callback do |res|
+              COLLECTION.drop_indexes.callback{ EM.stop }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/monga/collection_spec.rb

@@ -0,0 +1,448 @@
+require 'spec_helper'
+
+describe Monga::Collection do
+  include Helpers::Truncate
+
+  describe "queries" do
+    before do
+      EM.run do
+        req = COLLECTION.safe_insert([
+          { author: "Madonna", title: "Burning Up" },
+          { author: "Madonna", title: "Freezing" },
+          { author: "Madonna", title: "Untitled Track 1" },
+          { author: "Madonna", title: "Untitled Track 2" },
+          { author: "Madonna", title: "Untitled Track 3" },
+          { author: "Madonna", title: "Untitled Track 4" },
+          { author: "Madonna", title: "Untitled Track 5" },
+          { author: "Radiohead", title: "Karma Police" },
+        ])
+        req.callback{ EM.stop }
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should find all" do
+      EM.run do
+        req = COLLECTION.find
+        req.callback do |data|
+          data.size.must_equal 8
+          data.first.tap{|d| d.delete "_id" }.must_equal({ "author" => "Madonna", "title" => "Burning Up" })
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should findOne aka first" do
+      EM.run do
+        req = COLLECTION.first
+        req.callback do |data|
+          data.tap{|d| d.delete "_id" }.must_equal({ "author" => "Madonna", "title" => "Burning Up" })
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should find limit" do
+      EM.run do
+        req = COLLECTION.find.limit(2)
+        req.callback do |data|
+          data.size.must_equal 2
+          data.first.tap{|d| d.delete "_id" }.must_equal({ "author" => "Madonna", "title" => "Burning Up" })
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should find skip" do
+      EM.run do
+        req = COLLECTION.find.limit(3).skip(2)
+        req.callback do |data|
+          data.size.must_equal 3
+          data.first.tap{|d| d.delete "_id" }.must_equal({ "author" => "Madonna", "title" => "Untitled Track 1" })
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should find with batch_size" do
+      EM.run do
+        cursor = COLLECTION.find.batch_size(2).cursor
+        req = cursor.send(:next_batch)
+        req.callback do |batch|
+          batch.size.must_equal 2
+          batch.first.tap{|d| d.delete "_id" }.must_equal({ "author" => "Madonna", "title" => "Burning Up" })
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should return next document" do
+      EM.run do
+        cursor = COLLECTION.find.batch_size(2).cursor
+        req = cursor.next_document
+        req.callback do |doc|
+          doc.tap{|d| d.delete "_id" }.must_equal({ "author" => "Madonna", "title" => "Burning Up" })
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should find with skip limit and query" do
+      EM.run do
+        req = COLLECTION.find(author: "Madonna").limit(10).skip(2)
+        req.callback do |data|
+          data.size.must_equal 5
+          data.first.tap{|d| d.delete "_id" }.must_equal({ "author" => "Madonna", "title" => "Untitled Track 1" })
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should return nothing" do
+      EM.run do
+        req = COLLECTION.find(author: "Bjork")
+        req.callback do |data|
+          data.size.must_equal 0
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should return specific fields" do
+      EM.run do
+        req = COLLECTION.find({author: "Madonna"}, { author: 1 })
+        req.callback do |data|
+          data.size.must_equal 7
+          p data.map(&:keys).flatten.uniq.must_equal(["_id", "author"])
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+  end
+
+  describe "tailable cursor" do
+    before do
+      EM.run do
+        CAPPED_COLLECTION = DB["cappedCollection"]
+        req = DB.create_collection("cappedCollection", capped: true, size: 10*1024)
+        req.callback do
+          CAPPED_COLLECTION.safe_insert([
+            {title: "Doc 1"},
+            {title: "Doc 2"},
+            {title: "Doc 3"},
+          ]).callback do
+            EM.stop
+          end
+        end
+        req.errback{ |err| p err;  EM.stop }
+      end
+    end
+
+    after do
+      EM.run do
+        DB.drop_collection("cappedCollection").callback do
+          EM.stop
+        end
+      end
+    end
+
+    it "should return tailable cursor" do
+      EM.run do
+        cursor = CAPPED_COLLECTION.find.cursor(tailable_cursor: true)
+        cursor.each_doc{ p "do nothing" }
+        cursor.callback do
+          req = CAPPED_COLLECTION.safe_insert({ title: "Last One" })
+          req.callback do
+            cursor.next_document.callback do |doc|
+              doc["title"].must_equal "Last One"
+              cursor.kill
+              CAPPED_COLLECTION.safe_insert({ title: "The Very Last One" }).callback do
+                cursor.next_document.errback do |err|
+                  err.class.must_equal Monga::Exceptions::CursorIsClosed
+                  EM.stop
+                end
+              end
+            end
+          end
+          req.errback{ |err| p ["err", err]}
+        end
+        cursor.errback{ |err| p ["err", err ]}
+      end
+    end
+  end
+
+  describe "fetch many data" do
+    before do
+      MANY = 1000
+      EM.run do
+        req = COLLECTION.safe_insert(
+          MANY.times.map{ |i| { row: (i+1).to_s } }
+        )
+        req.callback{ EM.stop }
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should fetch em all and count" do
+      EM.run do
+        req = COLLECTION.find
+        req.callback do |docs|
+          docs.size.must_equal MANY
+          COLLECTION.count.callback do |c|
+            c.must_equal MANY
+            EM.stop
+          end
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+  end
+
+  describe "insert" do
+    it "should single insert" do
+      EM.run do
+        COLLECTION.insert(todo: "shopping")
+        EM.add_timer(0.05) do
+          req = COLLECTION.first
+          req.callback do |resp|
+            resp["todo"].must_equal "shopping"
+            EM.stop
+          end
+          req.errback{ |err| raise err }
+        end
+      end
+    end
+
+    it "should safe_insert" do
+      EM.run do
+        req = COLLECTION.safe_insert(todo: "shopping")
+        req.callback do
+          req = COLLECTION.first
+          req.callback do |resp|
+            resp["todo"].must_equal "shopping"
+            EM.stop
+          end
+          req.errback{ |err| raise err }
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should batch insert" do
+      EM.run do
+        req = COLLECTION.safe_insert([{todo: "shopping"}, {todo: "walking"}, {todo: "dinner with Scarlett"}])
+        req.callback do
+          req = COLLECTION.find
+          req.callback do |resp|
+            resp.size.must_equal 3
+            resp.map{|r| r["todo"]}.must_equal ["shopping", "walking", "dinner with Scarlett"]
+            EM.stop
+          end
+          req.errback{ |err| raise err }
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should fail on uniq index" do
+      EM.run do
+        COLLECTION.ensure_index({book_id: 1}, {unique: true})
+        req = COLLECTION.safe_insert([{book_id: 1, title: "Bible"}, {book_id: 1, title: "Lord of the Ring"}, {book_id: 2, title: "War and Piece"}, {book_id: 3, title: "Harry Potter"}])
+        req.callback do
+          fail "It should never happen"
+        end
+        req.errback do |err|
+          err.class.must_equal Monga::Exceptions::QueryFailure
+          COLLECTION.count.callback do |n|
+            n.must_equal 1
+            EM.stop
+          end
+        end
+      end
+    end
+
+    it "should continue to insert if error happend" do
+      EM.run do
+        COLLECTION.ensure_index({book_id: 1}, {unique: true})
+        req = COLLECTION.safe_insert([{book_id: 1, title: "Bible"}, {book_id: 1, title: "Lord of the Ring"}, {book_id: 2, title: "War and Piece"}, {book_id: 3, title: "Harry Potter"}], {continue_on_error: true})
+        req.callback do |res|
+          fail "It should never happen"
+        end
+        req.errback do |err|
+          COLLECTION.count.callback do |n|
+            n.must_equal 3
+            EM.stop
+          end
+        end
+      end
+    end
+  end
+
+  describe "indexes" do
+    it "should create an index" do
+      EM.run do
+        COLLECTION.ensure_index(artist: 1)
+        req = COLLECTION.get_indexes
+        req.callback do |indexes|
+          indexes.any?{ |ind| ind["ns"] == "#{DB.name}.#{COLLECTION.name}" && ind["key"] == {"artist" => 1}}.must_equal true
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should drop an index" do
+      EM.run do
+        COLLECTION.ensure_index(artist: 1)
+        req = COLLECTION.drop_index(artist: 1)
+        req.callback do |resp|
+          req = COLLECTION.get_indexes
+          req.callback do |indexes|
+            indexes.any?{ |ind| ind["ns"] == "#{DB.name}.#{COLLECTION.name}" && ind["key"] == {"artist" => 1}}.must_equal false
+            EM.stop
+          end
+          req.errback{ |err| raise err }
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should create unique index" do
+      EM.run do
+        COLLECTION.ensure_index({artist: 1}, {unique: 1})
+        req = COLLECTION.get_indexes
+        req.callback do |indexes|
+          indexes.any?{ |ind| ind["ns"] == "#{DB.name}.#{COLLECTION.name}" && ind["key"] == {"artist" => 1} && ind["unique"] == true}.must_equal true
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    # Why somebody needs to do safe_ensure_index?
+    it "should not fail on safe_ensure_index" do
+      EM.run do
+        req = COLLECTION.safe_ensure_index({artist: 1}, {unique: 1})
+        req.callback do |res|
+          req.callback{ |res| EM.stop }
+          req.errback{ |err| raise err }
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+  end
+
+  describe "update" do
+    before do
+      EM.run do
+        COLLECTION.safe_insert([
+          { artist: "Madonna", title: "Burning Up", status: "Out of Order" },
+          { artist: "Madonna", title: "Freezing", status: "Out of Order" }
+        ]).callback{ EM.stop }
+      end
+    end
+
+    it "should update exist item (first matching)" do
+      EM.run do
+        req = COLLECTION.safe_update({artist: "Madonna"}, {artist: "Madonna", status: "Available"})
+        req.callback do |res|
+          COLLECTION.find.callback do |docs|
+            d = docs.first
+            d.delete("_id")
+            d.must_equal({"artist" => "Madonna", "status" => "Available"})
+            docs.last["status"].must_equal "Out of Order"
+            EM.stop
+          end
+        end
+      end
+    end
+
+    it "should update exist item (all matching, multi_update)" do
+      EM.run do
+        req = COLLECTION.safe_update({artist: "Madonna"}, {"$set" => { status: "Available"}}, {multi_update: true})
+        req.callback do |res|
+          COLLECTION.find.callback do |docs|
+            docs.map{|d| [d["artist"], d["status"]]}.must_equal([["Madonna", "Available"], ["Madonna", "Available"]])
+            EM.stop
+          end
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+
+    it "should do nothing on update non existing item" do
+      EM.run do
+        req = COLLECTION.safe_update({artist: "Madonna2"}, {status: "Available"})
+        req.callback do |res|
+          req = COLLECTION.find(artist: "Madonna2").callback do |docs|
+            docs.size.must_equal 0
+            EM.stop
+          end
+        end
+        req.errback do |err|
+          raise err
+        end
+      end
+    end
+
+    it "should create non existing item (upsert)" do
+      EM.run do
+        req = COLLECTION.safe_update({artist: "Madonna2"}, {"$set" => {status: "Available"}}, {upsert: true})
+        req.callback do |res|
+          req = COLLECTION.find(artist: "Madonna2").callback do |docs|
+            docs.size.must_equal 1
+            docs.first["artist"].must_equal("Madonna2")
+            docs.first["status"].must_equal("Available")
+            EM.stop
+          end
+        end
+        req.errback do |err|
+          raise err
+        end
+      end
+    end
+  end
+
+  describe "DELETE OP" do
+    before do
+      EM.run do
+        COLLECTION.safe_insert([
+          { artist: "Madonna", title: "Burning Up", status: "Out of Order" },
+          { artist: "Madonna", title: "Freezing", status: "Out of Order" }
+        ]).callback{ EM.stop }
+      end
+    end
+
+    it "should delete all docs" do
+      EM.run do
+        COLLECTION.safe_delete(artist: "Madonna").callback do
+          COLLECTION.count.callback do |n|
+            n.must_equal 0
+            EM.stop
+          end
+        end
+      end
+    end
+
+    it "should delete first matching" do
+      EM.run do
+        COLLECTION.safe_delete({artist: "Madonna"}, {single_remove: true}).callback do
+          COLLECTION.find.callback do |docs|
+            docs.size.must_equal 1
+            docs.first["title"].must_equal "Freezing"
+            EM.stop
+          end
+        end
+      end
+    end
+  end
+end

data/spec/monga/connection_pool_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Monga::ConnectionPool do
+  # include Helpers::Truncate
+  before do
+    INSTANCE.start
+    EM.run do
+      @client = Monga::Client.new(pool_size: 2)
+      @db = @client["dbTest"]
+      @collection = @db["testCollection"]
+      EM.stop
+    end
+  end
+
+  it "should aquire connections correctly" do
+    EM.run do
+      conns = []
+      req = @collection.safe_insert(artist: "Madonna")
+      EM.next_tick do
+        100.times do
+          conns << @client.aquire_connection
+        end
+        conns.uniq.size.must_equal 1
+        req.callback do
+          100.times{ conns << @client.aquire_connection }
+          conns.uniq.size.must_equal 2
+          EM.stop
+        end
+        req.errback{ |err| raise err }
+      end
+    end
+  end
+
+  it "should aquire connections correctly when there are waiting responses on each connection" do
+    EM.run do
+      conns = []
+      @client.connection_pool.connections.each(&:connected?)
+      EM.next_tick do
+        @collection.safe_insert(artist: "Madonna")
+        @collection.safe_insert(artist: "Madonna")
+        100.times do
+          conns << @client.aquire_connection
+        end
+        conns.uniq.size.must_equal 2
+        @client.connection_pool.connections.all?{|c| c.responses.size == 1}.must_equal true
+        EM.stop
+      end
+    end
+  end
+end

data/spec/monga/connection_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Monga::Connection do
+  describe "One instance" do
+    it "should try to connect to stopped instance then instance is started and connection became connected" do
+      EM.run do
+        INSTANCE.stop
+        connection = Monga::Client.new( host: "localhost", port: 27017 )
+        EM.next_tick do
+          connection.connected?.must_equal false
+          INSTANCE.start
+          EM.add_timer(0.5) do
+            connection.connected?.must_equal true
+            EM.stop
+          end
+        end
+      end
+    end
+
+    it "should retrieve connection after restarting of EventMacine" do
+      INSTANCE.start
+      connection = nil
+      EM.run do
+        connection = Monga::Client.new( host: "localhost", port: 27017 )
+        EM.next_tick do 
+          connection.connected?.must_equal true
+          EM.stop
+        end
+      end
+      connection.connected?.must_equal false
+      EM.run do
+        # Somebody tries to send data
+        # Driver should automatically reconnect
+        connection["dbTest"].get_last_error
+        EM.add_timer(0.1) do
+          connection.connected?.must_equal true
+          EM.next_tick{ EM.stop }
+        end
+      end
+    end
+
+    it "should receive errback while trying to fetch data from stopped mongo" do
+      EM.run do
+        connection = Monga::Client.new( host: "localhost", port: 27017 )
+        INSTANCE.stop
+        req = connection["dbTest"].get_last_error
+        req.callback{ |r| puts "never executed" }
+        req.errback do |err| 
+          err.class.must_equal Monga::Exceptions::LostConnection
+          EM.stop
+        end
+      end
+      INSTANCE.start
+    end
+  end
+
+  describe "Replica Set connection" do
+    # TODO
+  end
+
+  describe  "Master Slave connection" do
+    # TODO
+  end
+end