couchbase-orm 1.1.1 → 2.0.2

data/spec/n1ql_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require File.expand_path("../support", __FILE__)
+
+class N1QLTest < CouchbaseOrm::Base
+    attribute :name, type: String
+    attribute :lastname, type: String
+    enum rating: [:awesome, :good, :okay, :bad], default: :okay
+
+    n1ql :by_custom_rating, emit_key: [:rating], query_fn: proc { |bucket, _values, options|
+        cluster.query("SELECT raw meta().id FROM `#{bucket.name}` WHERE type = 'n1_ql_test' AND rating IN [1, 2] ORDER BY name ASC", options)
+    }
+    n1ql :by_name, emit_key: [:name]
+    n1ql :by_lastname, emit_key: [:lastname]
+    n1ql :by_rating_emit, emit_key: :rating
+
+    n1ql :by_custom_rating_values, emit_key: [:rating], query_fn: proc { |bucket, values, options|
+        cluster.query("SELECT raw meta().id FROM `#{bucket.name}` where type = 'n1_ql_test' AND rating IN #{quote(values[0])} ORDER BY name ASC", options)
+    }
+    n1ql :by_rating_reverse, emit_key: :rating, custom_order: "name DESC"
+    n1ql :by_rating_without_docs, emit_key: :rating, include_docs: false
+
+    # This generates both:
+    # view :by_rating, emit_key: :rating
+    # def self.find_by_rating(rating); end  # also provide this helper function
+    index_n1ql :rating
+end
+
+describe CouchbaseOrm::N1ql do
+    before(:each) do
+        N1QLTest.delete_all
+    end
+    
+    it "should not allow n1ql to override existing methods" do
+        expect { N1QLTest.n1ql :all }.to raise_error(ArgumentError)
+    end
+
+    it "should perform a query and return the n1ql" do
+        N1QLTest.create! name: :bob
+        docs = N1QLTest.all.collect { |ob|
+            ob.name
+        }
+        expect(docs).to eq(%w[bob])
+    end
+
+    it "should query by non-nil value" do
+        _anonymous = N1QLTest.create!
+        bob = N1QLTest.create! name: :bob
+
+        expect(N1QLTest.by_name(key: 'bob').to_a).to eq [bob]
+    end
+
+    it "should query by nil value" do
+        anonymous = N1QLTest.create! lastname: "Anonymous"
+        anonymous_no_property = N1QLTest.create! lastname: "Anonymous without name property"
+
+        CouchbaseOrm::Connection.bucket.default_collection.mutate_in(anonymous_no_property.id, [
+            Couchbase::MutateInSpec.remove("name"),
+        ])
+
+        anonymous_no_property.reload
+
+        _bob = N1QLTest.create! name: :bob
+
+        expect(N1QLTest.by_name(key: nil).to_a).to match_array [anonymous, anonymous_no_property]
+    end
+
+    it "should query all when key is not set" do
+        anonymous = N1QLTest.create!
+        bob = N1QLTest.create! name: :bob
+
+        expect(N1QLTest.by_name.to_a).to eq [anonymous, bob]
+    end
+
+
+    it "should work with other keys" do
+        N1QLTest.create! name: :bob, rating: :good
+        N1QLTest.create! name: :jane, rating: :awesome
+        N1QLTest.create! name: :greg, rating: :bad
+
+        docs = N1QLTest.by_name(descending: true).collect { |ob|
+            ob.name
+        }
+        expect(docs).to eq(%w[jane greg bob])
+
+        docs = N1QLTest.by_rating(descending: true).collect { |ob|
+            ob.rating
+        }
+        expect(docs).to eq([4, 2, 1])
+    end
+
+    it "should return matching results" do
+        N1QLTest.create! name: :bob, rating: :awesome
+        N1QLTest.create! name: :jane, rating: :awesome
+        N1QLTest.create! name: :greg, rating: :bad
+        N1QLTest.create! name: :mel, rating: :good
+
+        docs = N1QLTest.find_by_rating(1).collect { |ob|
+            ob.name
+        }
+
+        expect(Set.new(docs)).to eq(Set.new(%w[bob jane]))
+
+        docs = N1QLTest.by_custom_rating().collect { |ob|
+            ob.name
+        }
+
+        expect(Set.new(docs)).to eq(Set.new(%w[bob jane mel]))
+    end
+
+    it "should return matching results with reverse order" do
+        N1QLTest.create! name: :bob, rating: :awesome
+        N1QLTest.create! name: :jane, rating: :awesome
+        N1QLTest.create! name: :greg, rating: :bad
+        N1QLTest.create! name: :mel, rating: :good
+
+        docs = N1QLTest.by_rating_reverse(key: 1).collect { |ob|
+            ob.name
+        }
+
+        expect(docs).to eq(%w[jane bob])
+    end
+
+    it "should return matching results without full documents" do
+        inst_bob = N1QLTest.create! name: :bob, rating: :awesome
+        inst_jane = N1QLTest.create! name: :jane, rating: :awesome
+        N1QLTest.create! name: :greg, rating: :bad
+        N1QLTest.create! name: :mel, rating: :good
+
+        docs = N1QLTest.by_rating_without_docs(key: 1)
+
+        expect(Set.new(docs)).to eq(Set.new([inst_bob.id, inst_jane.id]))
+    end
+
+    it "should return matching results with nil usage" do
+        N1QLTest.create! name: :bob, lastname: nil
+        N1QLTest.create! name: :jane, lastname: "dupond"
+
+        docs = N1QLTest.by_lastname(key: [nil]).collect { |ob|
+            ob.name
+        }
+        expect(docs).to eq(%w[bob])
+    end
+
+    it "should allow storing quoting chars" do
+        special_name = "O'Leary & Sons \"The best\" \\ between backslash \\"
+        t = N1QLTest.create! name: special_name, rating: :awesome
+        expect(N1QLTest.find(t.id).name).to eq(special_name)
+        expect(N1QLTest.by_name(key: special_name).to_a.first).to eq(t)
+        expect(N1QLTest.where(name: special_name).to_a.first).to eq(t)
+    end
+    it "should return matching results with custom n1ql query" do
+        N1QLTest.create! name: :bob, rating: :awesome
+        N1QLTest.create! name: :jane, rating: :awesome
+        N1QLTest.create! name: :greg, rating: :bad
+        N1QLTest.create! name: :mel, rating: :good
+
+
+        docs = N1QLTest.by_custom_rating().collect { |ob|
+            ob.name
+        }
+
+        expect(Set.new(docs)).to eq(Set.new(%w[bob jane mel]))
+
+        docs = N1QLTest.by_custom_rating_values(key: [[1, 2]]).collect { |ob|
+            ob.name
+        }
+
+        expect(Set.new(docs)).to eq(Set.new(%w[bob jane mel]))
+    end
+
+    it "should log the default scan_consistency when n1ql query is executed" do
+        allow(CouchbaseOrm.logger).to receive(:debug)
+        N1QLTest.by_rating_reverse()
+        expect(CouchbaseOrm.logger).to have_received(:debug).at_least(:once).with("N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=\"n1_ql_test\"  order by name DESC  return 0 rows with scan_consistency : #{described_class::DEFAULT_SCAN_CONSISTENCY}")
+    end
+
+    it "should log the set scan_consistency when n1ql query is executed with a specific scan_consistency" do
+        allow(CouchbaseOrm.logger).to receive(:debug)
+        default_n1ql_config = CouchbaseOrm::N1ql.config
+        CouchbaseOrm::N1ql.config({ scan_consistency: :not_bounded })
+        N1QLTest.by_rating_reverse()
+        expect(CouchbaseOrm.logger).to have_received(:debug).at_least(:once).with("N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=\"n1_ql_test\"  order by name DESC  return 0 rows with scan_consistency : not_bounded")
+
+        CouchbaseOrm::N1ql.config(default_n1ql_config)
+        N1QLTest.by_rating_reverse()
+        expect(CouchbaseOrm.logger).to have_received(:debug).at_least(:once).with("N1QL query: select raw meta().id from `#{CouchbaseOrm::Connection.bucket.name}` where type=\"n1_ql_test\"  order by name DESC  return 0 rows with scan_consistency : #{described_class::DEFAULT_SCAN_CONSISTENCY}")
+    end
+
+    after(:all) do
+        N1QLTest.delete_all
+    end
+end

data/spec/persistence_spec.rb

@@ -2,9 +2,12 @@
 
 require File.expand_path("../support", __FILE__)
 
+require "action_controller"
 
 class BasicModel < CouchbaseOrm::Base
-    attribute :name, :address, :age
+    attribute :name
+    attribute :address
+    attribute :age
 end
 
 class ModelWithDefaults < CouchbaseOrm::Base
@@ -14,7 +17,9 @@ class ModelWithDefaults < CouchbaseOrm::Base
 end
 
 class ModelWithCallbacks < CouchbaseOrm::Base
-    attribute :name, :address, :age
+    attribute :name
+    attribute :address
+    attribute :age
 
     before_create :update_name
     before_save   :set_address
@@ -32,7 +37,8 @@ class ModelWithCallbacks < CouchbaseOrm::Base
 end
 
 class ModelWithValidations < CouchbaseOrm::Base
-    attribute :name, :address, type: String
+    attribute :name, type: String
+    attribute :address, type: String
     attribute :age, type: :Integer
 
     validates :name, presence: true
@@ -205,11 +211,8 @@ describe CouchbaseOrm::Persistence do
         expect(model.save!).to be(model)
 
         # coercion will fail here
-        begin
-            model.age = 'a23'
-            expect(false).to be(true)
-        rescue ArgumentError => e
-        end
+        model.age = "a23"
+        expect{ model.save! }.to raise_error(CouchbaseOrm::Error::RecordInvalid)
 
         model.destroy
     end
@@ -228,12 +231,24 @@ describe CouchbaseOrm::Persistence do
 
         model.reload
         expect(model.changed?).to be(false)
-        expect(model.id).to be(id)
+        expect(model.id).to eq(id)
 
         model.destroy
         expect(model.destroyed?).to be(true)
     end
 
+    it "should update with action controler parameters" do
+        model = BasicModel.create!
+        params = ActionController::Parameters.new({
+              name: 'Francesco',
+              age:  22,
+              foo: 'bar'
+          })
+        model.update!(params.permit(:name, :age))
+        model.reload
+        expect(model.age).to eq(22)
+    end
+
     it "should update attributes" do
         model = BasicModel.new
 
@@ -254,6 +269,31 @@ describe CouchbaseOrm::Persistence do
         expect(model.destroyed?).to be(true)
     end
 
+    it "should not allow to update unkown attributes" do
+        model = BasicModel.new
+        
+        expect{ model.update_attributes({
+            name: 'bob',
+            age: 34,
+            foo: 'bar'
+        }) }.to raise_error(ActiveModel::UnknownAttributeError) 
+    end
+
+    it "should not allow to create with unkown attributes" do
+        expect{ BasicModel.create({
+            name: 'bob',
+            age: 34,
+            foo: 'bar'
+        }) }.to raise_error(ActiveModel::UnknownAttributeError) 
+    end
+
+    it "should not allow to update with unkown attributes" do
+        model = BasicModel.create!(name: 'bob', age: 34)
+        expect{ model.update({
+            foo: 'bar'
+        }) }.to raise_error(ActiveModel::UnknownAttributeError) 
+    end
+
     describe BasicModel do
         it_behaves_like "ActiveModel"
     end

data/spec/relation_nested_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+class NestedModel < CouchbaseOrm::NestedDocument
+    attribute :name, :string
+    attribute :size, :integer
+    attribute :child, :nested, type: NestedModel
+end
+
+class RelationParentModel < CouchbaseOrm::Base
+    attribute :name, :string
+    attribute :sub, :nested, type: NestedModel
+    attribute :subs, :array, type: NestedModel
+end
+
+describe CouchbaseOrm::Relation do
+    before(:each) do
+        RelationParentModel.delete_all
+        CouchbaseOrm.logger.debug "Cleaned before tests"
+    end
+
+    after(:all) do
+        CouchbaseOrm.logger.debug "Cleanup after all tests"
+        RelationParentModel.delete_all
+    end
+
+    it "should query on nested array attribute" do
+        RelationParentModel.create(name: "parent_without_subs")
+        parent = RelationParentModel.create(name: "parent")
+        parent.subs = [
+            NestedModel.new(name: "sub2"),
+            NestedModel.new(name: "sub3")
+        ]
+        parent.save!
+
+        expect(RelationParentModel.where(subs: {name: 'sub2'}).first).to eq parent
+        expect(RelationParentModel.where(subs: {name: ['sub3', 'subX']}).first).to eq parent
+    end
+
+    it "should query on nested array with multiple attributes" do
+        RelationParentModel.create(name: "parent_without_subs")
+        parent = RelationParentModel.create(name: "parent")
+        parent.subs = [
+          NestedModel.new(name: "sub2", size: 2),
+          NestedModel.new(name: "sub3", size: 3)
+        ]
+        parent.save!
+
+        expect(RelationParentModel.where(subs: {name: 'sub2', size: 2}).first).to eq parent
+        expect(RelationParentModel.where(subs: {name: 'sub2', size: 3}).first).to eq nil
+    end
+
+    it "should query by gte function" do
+        parent = RelationParentModel.create(name: "parent")
+        parent.subs = [
+            NestedModel.new(name: "sub2", size: 2),
+            NestedModel.new(name: "sub3", size: 3),
+            NestedModel.new(name: "sub4", size: 4)
+        ]
+        parent.save!
+        expect(RelationParentModel.where(subs: {size: {_gte: 3, _lt: 4}}).first).to eq parent
+    end
+
+    it "should query by nested attribute" do
+        RelationParentModel.create(name: "parent_without_sub")
+        parent = RelationParentModel.create(name: "parent")
+        parent.sub = NestedModel.new(name: "sub")
+        parent.save!
+        expect(RelationParentModel.where('sub.name': 'sub').first).to eq parent
+        expect(RelationParentModel.where(sub: {name: 'sub'}).first).to eq parent
+        expect(RelationParentModel.where(sub: {name: ['sub', 'subX']}).first).to eq parent
+        expect(RelationParentModel.where(sub: {name: ['subX']}).first).to be_nil
+
+    end
+
+    it "should query by grand child attribute" do
+        RelationParentModel.create(name: "parent_without_sub")
+        parent = RelationParentModel.create(name: "parent")
+        parent.sub = NestedModel.new(name: "sub", child: NestedModel.new(name: "child"))
+        parent.save!
+
+        expect(RelationParentModel.where(sub: {child: {name: 'child'}}).first).to eq parent
+        expect(RelationParentModel.where(sub: {child: {name: ['child', 'childX']}}).first).to eq parent
+        expect(RelationParentModel.where(sub: {child: {name: ['childX']}}).first).to be_nil
+    end
+end
+