mongoid_monkey 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56af6b17c89f409a9fa4995c2bcdf09bead1960b
-  data.tar.gz: f62b1170ba699b56cbd3eb9ea08019b447fbb176
+  metadata.gz: 713cd432161aff92379202903badf76643f5c345
+  data.tar.gz: 2a6da7db3fd0fdb03a8828bd761fd93dac98500b
 SHA512:
-  metadata.gz: e78fc8da08082c3fd0b123614ee7c296d0aebf133523ebe5acf088ec9f9fb84951bac88a867dfa9fcc4af90b51e8d9138ce86094ce58f097ed3a708db41fe8de
-  data.tar.gz: cc43215fe1cf22059156da5a002ebac8815aeeaf4997f8a053d48dcf1ceac97df04def42acdd666081ca33eecd4488594b6c5c58e6ac8df0f7af1401075a642e
+  metadata.gz: 417de743fe275b6dc78d88eec28ef8120505972e08e5096810f973cf862d9d2df9d150eb308f81c50041643fd4290fe90eae133ef47099a529a0c345cd6b6ca0
+  data.tar.gz: 3cbddb3acdd988d96c61a1ed1557057895520288cee81f29fce9ad657bb4e973bae50174ca4f3c0c9fe5db8d6a82ed8b909f8a3f929539e054724834bb250852

data/lib/patches/db_commands.rb

@@ -20,8 +20,7 @@ module Moped
   class Indexes
 
     def [](key)
-      result = database.command(listIndexes: collection_name)
-      result["cursor"]["firstBatch"].detect do |index|
+      list_indexes_command.detect do |index|
         (index['name'] == key) || (index['key'] == normalize_keys(key))
       end
     end
@@ -32,8 +31,16 @@ module Moped
       database.command(createIndexes: collection_name, indexes: [spec])
     end
 
+    def each(&block)
+      list_indexes_command.each(&block)
+    end
+
     protected
 
+    def list_indexes_command
+      database.command(listIndexes: collection_name)["cursor"]["firstBatch"]
+    end
+
     def normalize_keys(spec)
       return false if spec.is_a?(String)
       spec.reduce({}) do |transformed, (key, value)|

data/lib/version.rb

@@ -1,3 +1,3 @@
 module MongoidMonkey
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/spec/unit/db_commands_spec.rb

@@ -84,6 +84,11 @@ if defined?(Moped)
         it "creates an index with no options" do
           indexes.create name: 1
           indexes[name: 1].should_not eq nil
+          keys = []
+          indexes.each do |idx|
+            keys << idx['key']
+          end
+          keys.should eq([{"_id" => 1}, {"name" => 1}])
         end
       end
 
@@ -113,9 +118,12 @@ if defined?(Moped)
     describe "#drop" do
 
       context "when provided a key" do
+        before { session.drop }
 
         it "drops the index" do
-          indexes.create name: 1
+          indexes.create(name: 1)["numIndexesAfter"].should eq 2
+          indexes.drop(name: 1).should eq true
+          indexes.create({name: 1}, {unique: true})["numIndexesAfter"].should eq 2
           indexes.drop(name: 1).should eq true
         end
       end
@@ -132,4 +140,947 @@ if defined?(Moped)
       end
     end
   end
+
+  class Person
+    include Mongoid::Document
+
+    index age: 1
+    index addresses: 1
+    index dob: 1
+    index name: 1
+    index title: 1
+    index({ ssn: 1 }, { unique: true })
+  end
+
+  if defined?(Mongoid::Indexes)
+
+    describe Mongoid::Indexes do
+
+      describe ".included" do
+
+        let(:klass) do
+          Class.new do
+            include Mongoid::Indexes
+          end
+        end
+
+        it "adds an index_options accessor" do
+          klass.should respond_to(:index_options)
+        end
+
+        it "defaults index_options to empty hash" do
+          klass.index_options.should eq({})
+        end
+      end
+
+      describe ".remove_indexes" do
+
+        context "when no database specific options exist" do
+
+          let(:klass) do
+            Person
+          end
+
+          let(:collection) do
+            klass.collection
+          end
+
+          before do
+            klass.create_indexes
+            klass.remove_indexes
+          end
+
+          it "removes the indexes" do
+            collection.indexes.reject{ |doc| doc["name"] == "_id_" }.should be_empty
+          end
+        end
+
+        context "when database specific options exist" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              store_in collection: "test_db_remove"
+              index({ test: 1 }, { database: "mia_2" })
+              index({ name: 1 }, { background: true })
+            end
+          end
+
+          before do
+            klass.create_indexes
+            klass.remove_indexes
+          end
+
+          let(:indexes) do
+            klass.with(database: "mia_2").collection.indexes
+          end
+
+          it "creates the indexes" do
+            indexes.reject{ |doc| doc["name"] == "_id_" }.should be_empty
+          end
+        end
+      end
+
+      describe ".create_indexes" do
+
+        context "when no database options are specified" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              store_in collection: "test_class"
+              index({ _type: 1 }, { unique: false, background: true })
+            end
+          end
+
+          before do
+            klass.create_indexes
+          end
+
+          it "creates the indexes" do
+            klass.collection.indexes[_type: 1].should_not be_nil
+          end
+        end
+
+        context "when database options are specified" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              store_in collection: "test_db_indexes"
+              index({ _type: 1 }, { database: "mia_1" })
+            end
+          end
+
+          before do
+            klass.create_indexes
+          end
+
+          let(:indexes) do
+            klass.with(database: "mia_1").collection.indexes
+          end
+
+          it "creates the indexes" do
+            indexes[_type: 1].should_not be_nil
+          end
+        end
+      end
+
+      describe ".add_indexes" do
+
+        context "when indexes have not been added" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              def self.hereditary?
+                true
+              end
+            end
+          end
+
+          before do
+            klass.add_indexes
+          end
+
+          it "adds the _type index" do
+            klass.index_options[_type: 1].should eq(
+                                                     { unique: false, background: true }
+                                                 )
+          end
+        end
+      end
+
+      describe ".index" do
+
+        let(:klass) do
+          Class.new do
+            include Mongoid::Document
+            field :a, as: :authentication_token
+          end
+        end
+
+        context "when indexing a field that is aliased" do
+
+          before do
+            klass.index({ authentication_token: 1 }, { unique: true })
+          end
+
+          let(:options) do
+            klass.index_options[a: 1]
+          end
+
+          it "sets the index with unique options" do
+            options.should eq(unique: true)
+          end
+        end
+
+        context "when providing unique options" do
+
+          before do
+            klass.index({ name: 1 }, { unique: true })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1]
+          end
+
+          it "sets the index with unique options" do
+            options.should eq(unique: true)
+          end
+        end
+
+        context "when providing a drop_dups option" do
+
+          before do
+            klass.index({ name: 1 }, { drop_dups: true })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1]
+          end
+
+          it "sets the index with dropDups options" do
+            options.should eq(dropDups: true)
+          end
+        end
+
+        context "when providing a sparse option" do
+
+          before do
+            klass.index({ name: 1 }, { sparse: true })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1]
+          end
+
+          it "sets the index with sparse options" do
+            options.should eq(sparse: true)
+          end
+        end
+
+        context "when providing a name option" do
+
+          before do
+            klass.index({ name: 1 }, { name: "index_name" })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1]
+          end
+
+          it "sets the index with name options" do
+            options.should eq(name: "index_name")
+          end
+        end
+
+        context "when providing database options" do
+
+          before do
+            klass.index({ name: 1 }, { database: "mongoid_index_alt" })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1]
+          end
+
+          it "sets the index with background options" do
+            options.should eq(database: "mongoid_index_alt")
+          end
+        end
+
+        context "when providing a background option" do
+
+          before do
+            klass.index({ name: 1 }, { background: true })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1]
+          end
+
+          it "sets the index with background options" do
+            options.should eq(background: true)
+          end
+        end
+
+        context "when providing a compound index" do
+
+          before do
+            klass.index({ name: 1, title: -1 })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1, title: -1]
+          end
+
+          it "sets the compound key index" do
+            options.should be_empty
+          end
+        end
+
+        context "when providing a geospacial index" do
+
+          before do
+            klass.index({ location: "2d" }, { min: -200, max: 200, bits: 32 })
+          end
+
+          let(:options) do
+            klass.index_options[location: "2d"]
+          end
+
+          it "sets the geospacial index" do
+            options.should eq({ min: -200, max: 200, bits: 32 })
+          end
+        end
+
+        context "when providing a geo haystack index" do
+
+          before do
+            klass.index({ location: "geoHaystack" }, { min: -200, max: 200, bucket_size: 0.5 })
+          end
+
+          let(:options) do
+            klass.index_options[location: "geoHaystack"]
+          end
+
+          it "sets the geo haystack index" do
+            options.should eq({ min: -200, max: 200, bucketSize: 0.5 })
+          end
+        end
+
+        context "when providing a Spherical Geospatial index" do
+
+          before do
+            klass.index({ location: "2dsphere" })
+          end
+
+          let(:options) do
+            klass.index_options[location: "2dsphere"]
+          end
+
+          it "sets the spherical geospatial index" do
+            options.should be_empty
+          end
+        end
+
+        context "when providing a hashed index" do
+
+          before do
+            klass.index({ a: "hashed" })
+          end
+
+          let(:options) do
+            klass.index_options[a: "hashed"]
+          end
+
+          it "sets the hashed index" do
+            options.should be_empty
+          end
+        end
+
+        context "when providing a text index" do
+
+          before do
+            klass.index({ content: "text" })
+          end
+
+          let(:options) do
+            klass.index_options[content: "text"]
+          end
+
+          it "sets the text index" do
+            options.should be_empty
+          end
+        end
+
+        context "when providing a compound text index" do
+
+          before do
+            klass.index({ content: "text", title: "text" }, { weights: { content: 1, title: 2 } })
+          end
+
+          let(:options) do
+            klass.index_options[content: "text", title: "text"]
+          end
+
+          it "sets the compound text index" do
+            options.should eq(weights: { content: 1, title: 2 })
+          end
+        end
+
+        context "when providing an expire_after_seconds option" do
+
+          before do
+            klass.index({ name: 1 }, { expire_after_seconds: 3600 })
+          end
+
+          let(:options) do
+            klass.index_options[name: 1]
+          end
+
+          it "sets the index with sparse options" do
+            options.should eq(expireAfterSeconds: 3600)
+          end
+        end
+
+        context "when providing an invalid option" do
+
+          it "raises an error" do
+            expect {
+              klass.index({ name: 1 }, { invalid: true })
+            }.to raise_error(Mongoid::Errors::InvalidIndex)
+          end
+        end
+
+        context "when providing an invalid spec" do
+
+          context "when the spec is not a hash" do
+
+            it "raises an error" do
+              expect {
+                klass.index(:name)
+              }.to raise_error(Mongoid::Errors::InvalidIndex)
+            end
+          end
+
+          context "when the spec key is invalid" do
+
+            it "raises an error" do
+              expect {
+                klass.index({ name: "something" })
+              }.to raise_error(Mongoid::Errors::InvalidIndex)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  if defined?(Mongoid::Indexable)
+
+    describe Mongoid::Indexable do
+
+      describe ".included" do
+
+        let(:klass) do
+          Class.new do
+            include Mongoid::Indexable
+          end
+        end
+
+        it "adds an index_specifications accessor" do
+          expect(klass).to respond_to(:index_specifications)
+        end
+
+        it "defaults index_specifications to empty array" do
+          expect(klass.index_specifications).to be_empty
+        end
+      end
+
+      describe ".remove_indexes" do
+
+        context "when no database specific options exist" do
+
+          let(:klass) do
+            Person
+          end
+
+          let(:collection) do
+            klass.collection
+          end
+
+          before do
+            klass.create_indexes
+            klass.remove_indexes
+          end
+
+          it "removes the indexes" do
+            expect(collection.indexes.reject{ |doc| doc["name"] == "_id_" }).to be_empty
+          end
+        end
+
+        context "when database specific options exist" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              store_in collection: "test_db_remove"
+              index({ test: 1 }, { database: "mia_2" })
+              index({ name: 1 }, { background: true })
+            end
+          end
+
+          before do
+            klass.create_indexes
+            klass.remove_indexes
+          end
+
+          let(:indexes) do
+            klass.with(database: "mia_2").collection.indexes
+          end
+
+          it "creates the indexes" do
+            expect(indexes.reject{ |doc| doc["name"] == "_id_" }).to be_empty
+          end
+        end
+      end
+
+      describe ".create_indexes" do
+
+        context "when no database options are specified" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              store_in collection: "test_class"
+              index({ _type: 1 }, unique: false, background: true)
+            end
+          end
+
+          before do
+            klass.create_indexes
+          end
+
+          it "creates the indexes" do
+            expect(klass.collection.indexes[_type: 1]).to_not be_nil
+          end
+        end
+
+        context "when database options are specified" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              store_in collection: "test_db_indexes"
+              index({ _type: 1 }, { database: "mia_1" })
+            end
+          end
+
+          before do
+            klass.create_indexes
+          end
+
+          let(:indexes) do
+            klass.with(database: "mia_1").collection.indexes
+          end
+
+          it "creates the indexes" do
+            expect(indexes[_type: 1]).to_not be_nil
+          end
+        end
+      end
+
+      describe ".add_indexes" do
+
+        context "when indexes have not been added" do
+
+          let(:klass) do
+            Class.new do
+              include Mongoid::Document
+              def self.hereditary?
+                true
+              end
+            end
+          end
+
+          before do
+            klass.add_indexes
+          end
+
+          let(:spec) do
+            klass.index_specification(_type: 1)
+          end
+
+          it "adds the _type index" do
+            expect(spec.options).to eq(unique: false, background: true)
+          end
+        end
+      end
+
+      describe ".index" do
+
+        let(:klass) do
+          Class.new do
+            include Mongoid::Document
+            field :a, as: :authentication_token
+          end
+        end
+
+        context "when indexing a field that is aliased" do
+
+          before do
+            klass.index({ authentication_token: 1 }, unique: true)
+          end
+
+          let(:options) do
+            klass.index_specification(a: 1).options
+          end
+
+          it "sets the index with unique options" do
+            expect(options).to eq(unique: true)
+          end
+        end
+
+        context "when providing unique options" do
+
+          before do
+            klass.index({ name: 1 }, unique: true)
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1).options
+          end
+
+          it "sets the index with unique options" do
+            expect(options).to eq(unique: true)
+          end
+        end
+
+        context "when providing a drop_dups option" do
+
+          before do
+            klass.index({ name: 1 }, drop_dups: true)
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1).options
+          end
+
+          it "sets the index with dropDups options" do
+            expect(options).to eq(dropDups: true)
+          end
+        end
+
+        context "when providing a sparse option" do
+
+          before do
+            klass.index({ name: 1 }, sparse: true)
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1).options
+          end
+
+          it "sets the index with sparse options" do
+            expect(options).to eq(sparse: true)
+          end
+        end
+
+        context "when providing a name option" do
+
+          before do
+            klass.index({ name: 1 }, name: "index_name")
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1).options
+          end
+
+          it "sets the index with name options" do
+            expect(options).to eq(name: "index_name")
+          end
+        end
+
+        context "when providing database options" do
+
+          before do
+            klass.index({ name: 1 }, database: "mongoid_index_alt")
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1).options
+          end
+
+          it "sets the index with background options" do
+            expect(options).to eq(database: "mongoid_index_alt")
+          end
+        end
+
+        context "when providing a background option" do
+
+          before do
+            klass.index({ name: 1 }, background: true)
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1).options
+          end
+
+          it "sets the index with background options" do
+            expect(options).to eq(background: true)
+          end
+        end
+
+        context "when providing a compound index" do
+
+          before do
+            klass.index({ name: 1, title: -1 })
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1, title: -1).options
+          end
+
+          it "sets the compound key index" do
+            expect(options).to be_empty
+          end
+        end
+
+        context "when providing multiple inverse compound indexes" do
+
+          before do
+            klass.index({ name: 1, title: -1 })
+            klass.index({ title: -1, name: 1 })
+          end
+
+          let(:first_spec) do
+            klass.index_specification(name: 1, title: -1)
+          end
+
+          let(:second_spec) do
+            klass.index_specification(title: -1, name: 1)
+          end
+
+          it "does not overwrite the index options" do
+            expect(first_spec).to_not eq(second_spec)
+          end
+        end
+
+        context "when providing multiple compound indexes with different order" do
+
+          before do
+            klass.index({ name: 1, title: -1 })
+            klass.index({ name: 1, title: 1 })
+          end
+
+          let(:first_spec) do
+            klass.index_specification(name: 1, title: -1)
+          end
+
+          let(:second_spec) do
+            klass.index_specification(name: 1, title: 1)
+          end
+
+          it "does not overwrite the index options" do
+            expect(first_spec).to_not eq(second_spec)
+          end
+        end
+
+        context "when providing a geospacial index" do
+
+          before do
+            klass.index({ location: "2d" }, { min: -200, max: 200, bits: 32 })
+          end
+
+          let(:options) do
+            klass.index_specification(location: "2d").options
+          end
+
+          it "sets the geospacial index" do
+            expect(options).to eq({ min: -200, max: 200, bits: 32 })
+          end
+        end
+
+        context "when providing a geo haystack index" do
+
+          before do
+            klass.index({ location: "geoHaystack" }, { min: -200, max: 200, bucket_size: 0.5 })
+          end
+
+          let(:options) do
+            klass.index_specification(location: "geoHaystack").options
+          end
+
+          it "sets the geo haystack index" do
+            expect(options).to eq({ min: -200, max: 200, bucketSize: 0.5 })
+          end
+        end
+
+        context "when providing a Spherical Geospatial index" do
+
+          before do
+            klass.index({ location: "2dsphere" })
+          end
+
+          let(:options) do
+            klass.index_specification(location: "2dsphere").options
+          end
+
+          it "sets the spherical geospatial index" do
+            expect(options).to be_empty
+          end
+        end
+
+        context "when providing a text index" do
+
+          context "when the index is a single field" do
+
+            before do
+              klass.index({ description: "text" })
+            end
+
+            let(:options) do
+              klass.index_specification(description: "text").options
+            end
+
+            it "allows the set of the text index" do
+              expect(options).to be_empty
+            end
+          end
+
+          context "when the index is multiple fields" do
+
+            before do
+              klass.index({ description: "text", name: "text" })
+            end
+
+            let(:options) do
+              klass.index_specification(description: "text", name: "text").options
+            end
+
+            it "allows the set of the text index" do
+              expect(options).to be_empty
+            end
+          end
+
+          context "when the index is all string fields" do
+
+            before do
+              klass.index({ "$**" => "text" })
+            end
+
+            let(:options) do
+              klass.index_specification(:"$**" => "text").options
+            end
+
+            it "allows the set of the text index" do
+              expect(options).to be_empty
+            end
+          end
+
+          context "when providing a default language" do
+
+            before do
+              klass.index({ description: "text" }, default_language: "english")
+            end
+
+            let(:options) do
+              klass.index_specification(description: "text").options
+            end
+
+            it "allows the set of the text index" do
+              expect(options).to eq(default_language: "english")
+            end
+          end
+
+          context "when providing a name" do
+
+            before do
+              klass.index({ description: "text" }, name: "text_index")
+            end
+
+            let(:options) do
+              klass.index_specification(description: "text").options
+            end
+
+            it "allows the set of the text index" do
+              expect(options).to eq(name: "text_index")
+            end
+          end
+        end
+
+        context "when providing a hashed index" do
+
+          before do
+            klass.index({ a: "hashed" })
+          end
+
+          let(:options) do
+            klass.index_specification(a: "hashed").options
+          end
+
+          it "sets the hashed index" do
+            expect(options).to be_empty
+          end
+        end
+
+        context "when providing a text index" do
+
+          before do
+            klass.index({ content: "text" })
+          end
+
+          let(:options) do
+            klass.index_specification(content: "text").options
+          end
+
+          it "sets the text index" do
+            expect(options).to be_empty
+          end
+        end
+
+        context "when providing a compound text index" do
+
+          before do
+            klass.index({ content: "text", title: "text" }, { weights: { content: 1, title: 2 } })
+          end
+
+          let(:options) do
+            klass.index_specification(content: "text", title: "text").options
+          end
+
+          it "sets the compound text index" do
+            expect(options).to eq(weights: { content: 1, title: 2 })
+          end
+        end
+
+        context "when providing an expire_after_seconds option" do
+
+          before do
+            klass.index({ name: 1 }, { expire_after_seconds: 3600 })
+          end
+
+          let(:options) do
+            klass.index_specification(name: 1).options
+          end
+
+          it "sets the index with sparse options" do
+            expect(options).to eq(expireAfterSeconds: 3600)
+          end
+        end
+
+        context "when providing an invalid option" do
+
+          it "raises an error" do
+            expect {
+              klass.index({ name: 1 }, { invalid: true })
+            }.to raise_error(Mongoid::Errors::InvalidIndex)
+          end
+        end
+
+        context "when providing an invalid spec" do
+
+          context "when the spec is not a hash" do
+
+            it "raises an error" do
+              expect {
+                klass.index(:name)
+              }.to raise_error(Mongoid::Errors::InvalidIndex)
+            end
+          end
+
+          context "when the spec key is invalid" do
+
+            it "raises an error" do
+              expect {
+                klass.index({ name: "something" })
+              }.to raise_error(Mongoid::Errors::InvalidIndex)
+            end
+          end
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_monkey
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - johnnyshields