couchbase-orm 1.1.1 → 2.0.2

data/spec/type_nested_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path("../support", __FILE__)
+
+require "active_model"
+
+class SubTypeTest < CouchbaseOrm::NestedDocument
+    attribute :name, :string
+    attribute :tags, :array, type: :string
+    attribute :milestones, :array, type: :date
+    attribute :flags, :array, type: :boolean
+    attribute :things
+    attribute :child, :nested, type: SubTypeTest
+end
+
+class TypeNestedTest < CouchbaseOrm::Base
+    attribute :main, :nested, type: SubTypeTest
+    attribute :others, :array, type: SubTypeTest
+    attribute :flags, :array, type: :boolean
+end
+
+describe CouchbaseOrm::Types::Nested do
+    it "should be able to store and retrieve a nested object" do
+        obj = TypeNestedTest.new
+        obj.main = SubTypeTest.new
+        obj.main.name = "foo"
+        obj.main.tags = ["foo", "bar"]
+        obj.main.child = SubTypeTest.new(name: "bar")
+        obj.save!
+
+        obj = TypeNestedTest.find(obj.id)
+        expect(obj.main.name).to eq "foo"
+        expect(obj.main.tags).to eq ["foo", "bar"]
+        expect(obj.main.child.name).to eq "bar"
+    end
+
+    it "should be able to store and retrieve an array of nested objects" do
+        obj = TypeNestedTest.new
+        obj.others = [SubTypeTest.new, SubTypeTest.new]
+        obj.others[0].name = "foo"
+        obj.others[0].tags = ["foo", "bar"]
+        obj.others[1].name = "bar"
+        obj.others[1].tags = ["bar", "baz"]
+        obj.others[1].child = SubTypeTest.new(name: "baz")
+        obj.save!
+
+        obj = TypeNestedTest.find(obj.id)
+        expect(obj.others[0].name).to eq "foo"
+        expect(obj.others[0].tags).to eq ["foo", "bar"]
+        expect(obj.others[1].name).to eq "bar"
+        expect(obj.others[1].tags).to eq ["bar", "baz"]
+        expect(obj.others[1].child.name).to eq "baz"
+    end
+
+    it "should serialize to JSON" do
+        obj = TypeNestedTest.new
+        obj.others = [SubTypeTest.new, SubTypeTest.new]
+        obj.others[0].name = "foo"
+        obj.others[0].tags = ["foo", "bar"]
+        obj.others[1].name = "bar"
+        obj.others[1].tags = ["bar", "baz"]
+        obj.others[1].child = SubTypeTest.new(name: "baz")
+        obj.save!
+
+        obj = TypeNestedTest.find(obj.id)
+        expect(obj.send(:serialized_attributes)).to eq ({
+            "id" => obj.id,
+            "main" => nil,
+            "flags" => [],
+            "others" => [
+                {
+                    "name" => "foo",
+                    "tags" => ["foo", "bar"],
+                    "milestones" => [],
+                    "flags" => [],
+                    "things" => nil,
+                    "child" => nil
+                },
+                {
+                    "name" => "bar",
+                    "tags" => ["bar", "baz"],
+                    "milestones" => [],
+                    "flags" => [],
+                    "things" => nil,
+                    "child" => {
+                        "name" => "baz",
+                        "tags" => [],
+                        "milestones" => [],
+                        "flags" => [],
+                        "things" => nil,
+                        "child" => nil
+                    }
+                }
+            ]
+        })
+    end
+    
+    it "should not have a save method" do
+        expect(SubTypeTest.new).to_not respond_to(:save)
+    end
+
+    it "should not cast a list" do
+        expect{CouchbaseOrm::Types::Nested.new(type: SubTypeTest).cast([1,2,3])}.to raise_error(ArgumentError)
+    end
+    
+    it "should not serialize a list" do
+        expect{CouchbaseOrm::Types::Nested.new(type: SubTypeTest).serialize([1,2,3])}.to raise_error(ArgumentError)
+    end
+
+    it "should save a object with nested changes"  do
+        obj = TypeNestedTest.new
+        obj.main = SubTypeTest.new(name: "foo")
+        obj.others = [SubTypeTest.new(name: "foo"), SubTypeTest.new(name: "bar")]
+        obj.flags = [false, true]
+        obj.save!
+        obj.main.name = "bar"
+        obj.others[0].name = "bar"
+        obj.others[1].name = "baz"
+        obj.flags[0] = true
+
+        obj.save!
+        obj = TypeNestedTest.find(obj.id)
+        expect(obj.main.name).to eq "bar"
+        expect(obj.others[0].name).to eq "bar"
+        expect(obj.others[1].name).to eq "baz"
+        expect(obj.flags).to eq [true, true]
+    end
+
+    describe "Validations" do
+        class SubWithValidation < CouchbaseOrm::NestedDocument
+            attribute :id, :string
+            attribute :name
+            attribute :label
+            attribute :child, :nested, type: SubWithValidation
+            validates :name, presence: true
+            validates :child, nested: true
+        end
+
+        class WithValidationParent < CouchbaseOrm::Base
+            attribute :child, :nested, type: SubWithValidation
+            attribute :children, :array, type: SubWithValidation
+            validates :child, :children, nested: true
+        end
+        
+        it "should generate an id" do
+            expect(SubWithValidation.new.id).to be_present
+        end
+
+        it "should not regenerate the id after reloading parent" do
+            obj = WithValidationParent.new
+            obj.child = SubWithValidation.new(name: "foo")
+            obj.save!
+            expect(obj.child.id).to be_present
+            old_id = obj.child.id
+            obj.reload
+            expect(obj.child.id).to eq(old_id)
+        end
+
+        it "should not override the param id" do
+            expect(SubWithValidation.new(id: "foo").id).to eq "foo"
+        end
+
+        it "should validate the nested object" do
+            obj = WithValidationParent.new
+            obj.child = SubWithValidation.new
+            expect(obj).to_not be_valid
+            expect(obj.errors[:child]).to eq ["is invalid"]
+            expect(obj.child.errors[:name]).to eq ["can't be blank"]
+        end
+
+        it "should validate the nested objects in an array" do
+            obj = WithValidationParent.new
+            obj.children = [SubWithValidation.new(name: "foo"), SubWithValidation.new]
+            expect(obj).to_not be_valid
+            expect(obj.errors[:children]).to eq ["is invalid"]
+            expect(obj.children[1].errors[:name]).to eq ["can't be blank"]
+        end
+
+        it "should validate the nested in the nested object" do
+            obj = WithValidationParent.new
+            obj.child = SubWithValidation.new name: "foo", label: "parent"
+            obj.child.child = SubWithValidation.new label: "child"
+
+            expect(obj).to_not be_valid
+            expect(obj.child).to_not be_valid
+            expect(obj.child.child).to_not be_valid
+
+            expect(obj.errors[:child]).to eq ["is invalid"]
+            expect(obj.child.errors[:child]).to eq ["is invalid"]
+            expect(obj.child.child.errors[:name]).to eq ["can't be blank"]
+        end
+    end
+end

data/spec/type_spec.rb

@@ -0,0 +1,317 @@
+require File.expand_path("../support", __FILE__)
+require "timecop"
+require "active_model"
+require "couchbase-orm/types"
+
+class DateTimeWith3Decimal < CouchbaseOrm::Types::DateTime
+  def serialize(value)
+    value&.iso8601(3)
+  end
+end
+
+ActiveModel::Type.register(:datetime3decimal, DateTimeWith3Decimal)
+
+class TypeTest < CouchbaseOrm::Base
+    attribute :name, :string
+    attribute :age,  :integer
+    attribute :size, :float
+    attribute :renewal_date, :date
+    attribute :subscribed_at, :datetime
+    attribute :some_time, :timestamp
+    attribute :precision3_time, :datetime3decimal
+    attribute :precision6_time, :datetime, precision: 6
+
+    attribute :created_at, :datetime, precision: 6
+    attribute :updated_at, :datetime, precision: 6
+
+    attribute :active, :boolean
+
+    index :age, presence: false
+    index :renewal_date, presence: false
+    index :some_time, presence: false
+    index :precision3_time, presence: false
+end
+
+class N1qlTypeTest < CouchbaseOrm::Base
+    attribute :name, :string
+    attribute :age,  :integer
+    attribute :size, :float
+    attribute :renewal_date, :date
+    attribute :subscribed_at, :datetime
+    attribute :some_time, :timestamp
+    attribute :precision3_time, :datetime3decimal
+    attribute :active, :boolean
+
+    index_n1ql :name, validate: false
+    index_n1ql :age, validate: false
+    index_n1ql :size, validate: false
+    index_n1ql :active, validate: false
+    index_n1ql :renewal_date, validate: false
+    index_n1ql :some_time, validate: false
+    index_n1ql :subscribed_at, validate: false
+    index_n1ql :precision3_time, validate: false
+    n1ql :by_both_dates, emit_key: [:renewal_date, :subscribed_at], presence: false
+end
+
+TypeTest.ensure_design_document!
+N1qlTypeTest.ensure_design_document!
+
+describe CouchbaseOrm::Types::Timestamp do
+    it "should cast an integer to time" do
+        t = Time.at(Time.now.to_i)
+        expect(CouchbaseOrm::Types::Timestamp.new.cast(t.to_i)).to eq(t)
+    end
+    it "should cast an integer string to time" do
+        t = Time.at(Time.now.to_i)
+        expect(CouchbaseOrm::Types::Timestamp.new.cast(t.to_s)).to eq(t)
+    end
+end
+
+describe CouchbaseOrm::Types::Date do
+    it "should cast an string to date" do
+        d = Date.today
+        expect(CouchbaseOrm::Types::Date.new.cast(d.to_s)).to eq(d)
+    end
+
+    it "should serialize date to string" do
+        d = Date.today
+        expect(CouchbaseOrm::Types::Date.new.serialize(d)).to eq(d.to_s)
+    end
+
+    it "should get the type from the registry" do
+        expect(ActiveModel::Type.lookup(:date)).to eq(CouchbaseOrm::Types::Date.new)
+    end
+end
+
+describe CouchbaseOrm::Base do
+    before(:each) do
+        TypeTest.delete_all
+        N1qlTypeTest.delete_all
+    end
+
+    it "should be typed" do
+        expect(N1qlTypeTest.attribute_types["name"]).to be_a(ActiveModel::Type::String)
+    end
+
+    it "should be createable" do
+        t = TypeTest.create!
+        expect(t).to be_a(TypeTest)
+    end
+
+    it "should be able to set attributes" do
+        t = TypeTest.new
+        t.name = "joe"
+        t.age = 20
+        t.size = 1.5
+        t.renewal_date = Date.today
+        t.subscribed_at = Time.now
+        t.active = true
+        t.save!
+
+        expect(t.name).to eq("joe")
+        expect(t.age).to eq(20)
+        expect(t.size).to eq(1.5)
+        expect(t.renewal_date).to eq(Date.today)
+        expect(t.subscribed_at).to be_a(Time)
+        expect(t.active).to eq(true)
+    end
+
+    it "should be able to set attributes with a hash" do
+        t = TypeTest.new(name: "joe", age: 20, size: 1.5, renewal_date: Date.today, subscribed_at: Time.now, active: true)
+        t.save!
+
+        expect(t.name).to eq("joe")
+        expect(t.age).to eq(20)
+        expect(t.size).to eq(1.5)
+        expect(t.renewal_date).to eq(Date.today)
+        expect(t.subscribed_at).to be_a(Time)
+        expect(t.active).to eq(true)
+    end
+
+    it "should be able to be stored and retrieved" do
+        now = Time.now
+        t = TypeTest.create!(name: "joe", age: 20, size: 1.5, renewal_date: Date.today, subscribed_at: now, active: true)
+        t2 = TypeTest.find(t.id)
+
+        expect(t2.name).to eq("joe")
+        expect(t2.age).to eq(20)
+        expect(t2.size).to eq(1.5)
+        expect(t2.renewal_date).to eq(Date.today)
+        expect(t2.subscribed_at).to eq(now.utc.change(usec: 0))
+        expect(t2.active).to eq(true)
+    end
+
+    it "should be able to query by age" do
+        t = TypeTest.create!(age: 20)
+        _t2 = TypeTest.create!(age: 40)
+        expect(TypeTest.find_by_age(20)).to eq t
+    end
+
+    it "should be able to query by age and type cast" do
+        t = TypeTest.create!(age: "20")
+        expect(TypeTest.find_by_age(20)).to eq t
+        expect(TypeTest.find_by_age("20")).to eq t
+    end
+
+    it "should be able to query by date" do
+        t = TypeTest.create!(renewal_date: Date.today)
+        _t2 = TypeTest.create!(renewal_date: Date.today + 1)
+        expect(TypeTest.find_by_renewal_date(Date.today)).to eq t
+    end
+
+    it "should be able to query by date and type cast" do
+        t = TypeTest.create!(renewal_date: Date.today.to_s)
+        expect(TypeTest.find_by_renewal_date(Date.today)).to eq t
+        expect(TypeTest.find_by_renewal_date(Date.today.to_s)).to eq t
+    end
+
+    it "should be able to query by time" do
+        now = Time.now
+        t = TypeTest.create!(name: "t", some_time: now)
+        _t2 = TypeTest.create!(name: "t2", some_time: now + 1)
+        expect(TypeTest.find_by_some_time(now)).to eq t
+    end
+
+    it "should be able to query by time and type cast" do
+        now = Time.now
+        now_s = now.to_i.to_s
+        t = TypeTest.create!(some_time: now_s)
+        expect(TypeTest.find_by_some_time(now)).to eq t
+        expect(TypeTest.find_by_some_time(now_s)).to eq t
+    end
+
+    it "should be able to query by custom type" do
+        now = Time.now
+        t = TypeTest.create!(precision3_time: now)
+        _t2 = TypeTest.create!(precision3_time: now + 1)
+        expect(TypeTest.find_by_precision3_time(now)).to eq t
+    end
+
+    it "should be able to query by custom type and type cast" do
+        now = Time.now
+        now_s = now.utc.iso8601(3)
+        t = TypeTest.create!(precision3_time: now_s)
+        expect(TypeTest.find_by_precision3_time(now)).to eq t
+        expect(TypeTest.find_by_precision3_time(now_s)).to eq t
+    end
+
+    it "should be able to set attributes with a hash with indifferent access" do
+        t = TypeTest.new(ActiveSupport::HashWithIndifferentAccess.new(name: "joe", age: 20, size: 1.5, renewal_date: Date.today, subscribed_at: Time.now, active: true))
+        t.save!
+
+        expect(t.name).to eq("joe")
+        expect(t.age).to eq(20)
+        expect(t.size).to eq(1.5)
+        expect(t.renewal_date).to eq(Date.today)
+        expect(t.subscribed_at).to be_a(Time)
+        expect(t.active).to eq(true)
+    end
+
+    it "should be able to type cast attributes" do
+        t = TypeTest.new(name: "joe", age: "20", size: "1.5", renewal_date: Date.today.to_s, subscribed_at: Time.now.to_s, active: "true")
+        t.save!
+
+        expect(t.name).to eq("joe")
+        expect(t.age).to eq(20)
+        expect(t.size).to eq(1.5)
+        expect(t.renewal_date).to eq(Date.today)
+        expect(t.subscribed_at).to be_a(Time)
+        expect(t.active).to eq(true)
+    end
+
+    it "should be consistent with active record on failed cast" do
+        t = TypeTest.new(name: "joe", age: "joe", size: "joe", renewal_date: "joe", subscribed_at: "joe", active: "true")
+        t.save!
+
+        expect(t.age).to eq 0
+        expect(t.size).to eq 0.0
+        expect(t.renewal_date).to eq nil
+        expect(t.subscribed_at).to eq nil
+        expect(t.active).to eq true
+    end
+
+    it "should be able to query by name" do
+        t = N1qlTypeTest.create!(name: "joe")
+        _t2 = N1qlTypeTest.create!(name: "john")
+        expect(N1qlTypeTest.find_by_name("joe").to_a).to eq [t]
+    end
+
+    it "should be able to query by nil value" do
+        t = N1qlTypeTest.create!()
+        _t2 = N1qlTypeTest.create!(name: "john")
+        expect(N1qlTypeTest.find_by_name(nil).to_a).to eq [t]
+    end
+    
+    it "should be able to query by array value" do
+        t = N1qlTypeTest.create!(name: "laura")
+        t2 = N1qlTypeTest.create!(name: "joe")
+        _t3 = N1qlTypeTest.create!(name: "john")
+        expect(N1qlTypeTest.find_by_name(["laura", "joe"]).to_a).to match_array [t, t2]
+    end
+
+    it "should be able to query by integer" do
+        t = N1qlTypeTest.create!(age: 20)
+        t2 = N1qlTypeTest.create!(age: 20)
+        _t3 = N1qlTypeTest.create!(age: 40)
+        expect(N1qlTypeTest.find_by_age(20).to_a).to match_array [t, t2]
+    end
+
+    it "should be able to query by integer and type cast" do
+        t = N1qlTypeTest.create!(age: "20")
+        expect(N1qlTypeTest.find_by_age(20).to_a).to eq [t]
+        expect(N1qlTypeTest.find_by_age("20").to_a).to eq [t]
+    end
+
+    it "should be able to query by date" do
+        t = N1qlTypeTest.create!(renewal_date: Date.today)
+        _t2 = N1qlTypeTest.create!(renewal_date: Date.today + 1)
+        expect(N1qlTypeTest.find_by_renewal_date(Date.today).to_a).to eq [t]
+    end
+
+    it "should be able to query by datetime" do
+        now = Time.now
+        t = N1qlTypeTest.create!(subscribed_at: now)
+        _t2 = N1qlTypeTest.create!(subscribed_at: now + 1)
+        expect(N1qlTypeTest.find_by_subscribed_at(now).to_a).to eq [t]
+    end
+
+    it "should be able to query by timestamp" do
+        now = Time.now
+        t = N1qlTypeTest.create!(some_time: now)
+        _t2 = N1qlTypeTest.create!(some_time: now + 1)
+        expect(N1qlTypeTest.find_by_some_time(now).to_a).to eq [t]
+    end
+
+    it "should be able to query by custom type" do
+        now = Time.now
+        t = N1qlTypeTest.create!(precision3_time: now)
+        _t2 = N1qlTypeTest.create!(precision3_time: now + 1)
+        expect(N1qlTypeTest.find_by_precision3_time(now).to_a).to eq [t]
+    end
+
+    it "should be able to query by boolean" do
+        t = N1qlTypeTest.create!(active: true)
+        _t2 = N1qlTypeTest.create!(active: false)
+        expect(N1qlTypeTest.find_by_active(true).to_a).to eq [t]      
+    end
+
+    it "should be able to query by float" do
+        t = N1qlTypeTest.create!(size: 1.5)
+        _t2 = N1qlTypeTest.create!(size: 2.5)
+        expect(N1qlTypeTest.find_by_size(1.5).to_a).to eq [t]
+    end
+
+    it "should set datetime with precision" do
+        time = Time.at(1667499592.5170466123)
+        Timecop.freeze(time) do
+            test = TypeTest.create!(precision3_time: 1667499592.5170466123, some_time: 1667499592.5170466123, precision6_time: Time.now)
+
+            expect(test.created_at).to eq(time.floor(6))
+            expect(test.updated_at).to eq(time.floor(6))
+
+            expect(test.some_time).to eq(time.floor)
+            expect(test.precision3_time).to eq(time.floor(3))
+            expect(test.precision6_time).to eq(time.floor(6))
+        end
+    end
+end

data/spec/utilities/ignored_properties_spec.rb

@@ -0,0 +1,20 @@
+require 'couchbase-orm/utilities/ignored_properties'
+
+class DummyClass
+  extend CouchbaseOrm::IgnoredProperties
+end
+
+class DummyClass2
+  extend CouchbaseOrm::IgnoredProperties
+end
+
+RSpec.describe CouchbaseOrm::IgnoredProperties do
+
+  describe '#ignored_properties=' do
+    it 'does not mixup ignored properties between classes' do
+      DummyClass.ignored_properties = [:property1, :property2]
+      expect(DummyClass.ignored_properties).to eq(['property1', 'property2'])
+      expect(DummyClass2.ignored_properties).to be_empty
+    end
+  end
+end

data/spec/utilities/properties_always_exists_in_document_spec.rb

@@ -0,0 +1,24 @@
+require 'couchbase-orm/utilities/properties_always_exists_in_document'
+
+class DummyClass
+  extend CouchbaseOrm::PropertiesAlwaysExistsInDocument
+end
+
+class DummyClass2
+  extend CouchbaseOrm::PropertiesAlwaysExistsInDocument
+end
+
+RSpec.describe CouchbaseOrm::PropertiesAlwaysExistsInDocument do
+
+  describe '#properties_always_exists_in_document=' do
+    it 'Checks properties_always_exists_in_document value when initialize or not' do
+      DummyClass.properties_always_exists_in_document = true
+      expect(DummyClass.properties_always_exists_in_document).to be(true)
+      expect(DummyClass2.properties_always_exists_in_document).to be(false)
+    end
+
+    it 'raises error when a non boolean value is passed' do
+      expect { DummyClass.properties_always_exists_in_document = 'toto' }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/views_spec.rb

@@ -7,21 +7,41 @@ class ViewTest < CouchbaseOrm::Base
     attribute :name, type: String
     enum rating: [:awesome, :good, :okay, :bad], default: :okay
 
-    view :all
-    view :by_rating, emit_key: :rating
+    view :vall
 
     # This generates both:
-    # view :by_rating, emit_key: :rating    # same as above
+    # view :by_rating, emit_key: :rating
     # def self.find_by_rating(rating); end  # also provide this helper function
     index_view :rating
 end
 
 
 describe CouchbaseOrm::Views do
+    before(:each) do
+        ViewTest.delete_all
+    rescue Couchbase::Error::DesignDocumentNotFound
+        # ignore (FIXME: check before merge) mainly because if there is nothing in all we should not have an error
+    end
+
+    after(:each) do
+        ViewTest.delete_all
+    rescue Couchbase::Error::InternalServerFailure
+        # ignore (FIXME: check before merge)
+    rescue Couchbase::Error::DesignDocumentNotFound
+        # ignore (FIXME: check before merge) (7.1)
+    end
+
+    it "should not allow n1ql to override existing methods" do
+        expect { ViewTest.view :all }.to raise_error(ArgumentError)
+    end
+
     it "should save a new design document" do
         begin
-            ViewTest.bucket.delete_design_doc(ViewTest.design_document)
-        rescue Libcouchbase::Error::HttpResponseError
+            ViewTest.bucket.view_indexes.drop_design_document(ViewTest.design_document, :production)
+        rescue Couchbase::Error::InternalServerFailure
+            # ignore if design document does not exist
+        rescue Couchbase::Error::DesignDocumentNotFound
+            # ignore if design document does not exist (7.1)
         end
         expect(ViewTest.ensure_design_document!).to be(true)
     end
@@ -29,12 +49,16 @@ describe CouchbaseOrm::Views do
     it "should not re-save a design doc if nothing has changed" do
         expect(ViewTest.ensure_design_document!).to be(false)
     end
+    
+    it "should return an empty array when there is no objects" do
+        expect(ViewTest.vall).to eq([])
+    end
 
     it "should perform a map-reduce and return the view" do
         ViewTest.ensure_design_document!
-        mod = ViewTest.create! name: :bob, rating: :good
+        ViewTest.create! name: :bob, rating: :good
 
-        docs = ViewTest.all.collect { |ob|
+        docs = ViewTest.vall.collect { |ob|
             ob.destroy
             ob.name
         }
@@ -47,7 +71,7 @@ describe CouchbaseOrm::Views do
         ViewTest.create! name: :jane, rating: :awesome
         ViewTest.create! name: :greg, rating: :bad
 
-        docs = ViewTest.by_rating(descending: :true).collect { |ob|
+        docs = ViewTest.by_rating(order: :descending).collect { |ob|
             ob.destroy
             ob.name
         }
@@ -64,9 +88,6 @@ describe CouchbaseOrm::Views do
         docs = ViewTest.find_by_rating(1).collect { |ob|
             ob.name
         }
-        ViewTest.all.stream { |ob|
-            ob.destroy
-        }
 
         expect(Set.new(docs)).to eq(Set.new(['bob', 'jane']))
     end