couchbase-orm 1.1.1 → 2.0.2

data/spec/relation_spec.rb

@@ -0,0 +1,430 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+class NestedRelationModel < CouchbaseOrm::NestedDocument
+  attribute :name, :string
+  attribute :age, :integer
+end
+
+class PathRelationModel < CouchbaseOrm::NestedDocument
+    attribute :pathelement, :nested, type: PathRelationModel
+    attribute :children, :array, type: NestedRelationModel
+end
+
+class RelationModel < CouchbaseOrm::Base
+    attribute :name, :string
+    attribute :last_name, :string
+    attribute :active, :boolean
+    attribute :age, :integer
+    attribute :children, :array, type: NestedRelationModel
+    attribute :pathelement, :nested, type: PathRelationModel
+    def self.adult
+        where(age: {_gte: 18})
+    end
+
+    def self.active
+        where(active: true)
+    end
+end
+
+describe CouchbaseOrm::Relation do
+    before(:each) do
+        RelationModel.delete_all
+        CouchbaseOrm.logger.debug "Cleaned before tests"
+    end
+
+    after(:all) do
+        CouchbaseOrm.logger.debug "Cleanup after all tests"
+        RelationModel.delete_all
+    end
+
+    it "should return a relation" do
+        expect(RelationModel.all).to be_a(CouchbaseOrm::Relation::CouchbaseOrm_Relation)
+    end
+
+    it "should query with conditions" do
+        RelationModel.create! name: :bob, active: true, age: 10
+        RelationModel.create! name: :alice, active: true, age: 20
+        RelationModel.create! name: :john, active: false, age: 30
+        expect(RelationModel.where(active: true).count).to eq(2)
+        expect(RelationModel.where(active: true).size).to eq(2)
+
+        expect(RelationModel.where(active: true).to_a.map(&:name)).to match_array(%w[bob alice])
+        expect(RelationModel.where(active: true).where(age: 10).to_a.map(&:name)).to match_array(%w[bob])
+    end
+
+    it "should query with merged conditions" do
+        RelationModel.create! name: :bob, active: true, age: 10
+        RelationModel.create! name: :bob, active: false, age: 10
+        RelationModel.create! name: :alice, active: true, age: 20
+        RelationModel.create! name: :john, active: false, age: 30
+
+        expect(RelationModel.where(active: true).where(name: 'bob').count).to eq(1)
+    end
+
+    it "should find_by conditions" do
+        RelationModel.create! name: :bob, active: true, age: 10
+        m = RelationModel.create! name: :bob, active: false, age: 10
+        RelationModel.create! name: :alice, active: true, age: 20
+        RelationModel.create! name: :alice, active: false, age: 20
+
+        expect(RelationModel.where(name: 'bob').find_by(active: false)).to eq(m)
+        expect(RelationModel.find_by(name: 'bob', active: false)).to eq(m)
+    end
+
+    it "should count without loading models" do
+        RelationModel.create! name: :bob, active: true, age: 10
+        RelationModel.create! name: :alice, active: false, age: 20
+
+        expect(RelationModel).not_to receive(:find)
+
+        expect(RelationModel.where(active: true).count).to eq(1)
+    end
+
+    it "Should delete_all" do
+        RelationModel.create!
+        RelationModel.create!
+        RelationModel.delete_all
+        expect(RelationModel.ids).to match_array([])
+    end
+
+    it "Should delete_all with conditions" do
+        RelationModel.create!
+        jane = RelationModel.create! name: "Jane"
+        RelationModel.where(name: nil).delete_all
+        expect(RelationModel.ids).to match_array([jane.id])
+    end
+
+    it "Should query ids" do
+        expect(RelationModel.ids).to match_array([])
+        m1 = RelationModel.create!
+        m2 = RelationModel.create!
+        expect(RelationModel.ids).to match_array([m1.id, m2.id])
+    end
+
+    it "Should query ids with conditions" do
+        m1 = RelationModel.create!(active: true, name: "Jane")
+        _m2 = RelationModel.create!(active: false, name: "Bob" )
+        _m3 = RelationModel.create!(active: false, name: "Jane")
+        expect(RelationModel.where(active: true, name: "Jane").ids).to match_array([m1.id])
+    end
+
+    it "Should query ids with conditions and limit" do
+        RelationModel.create!(active: true, name: "Jane", age: 2)
+        RelationModel.create!(active: false, name: "Bob", age: 3)
+        m = RelationModel.create!(active: true, name: "Jane", age: 1)
+        RelationModel.create!(active: false, name: "Jane", age: 0)
+
+        expect(RelationModel.where(active: true, name: "Jane").order(:age).limit(1).ids).to match_array([m.id])
+        expect(RelationModel.limit(1).where(active: true, name: "Jane").order(:age).ids).to match_array([m.id])
+    end
+
+    it "Should query ids with order" do
+        m1 = RelationModel.create!(age: 10, name: 'b')
+        m2 = RelationModel.create!(age: 20, name: 'a')
+        expect(RelationModel.order(age: :desc).ids).to match_array([m2.id, m1.id])
+        expect(RelationModel.order(age: :asc).ids).to match_array([m1.id, m2.id])
+        expect(RelationModel.order(name: :desc).ids).to match_array([m1.id, m2.id])
+        expect(RelationModel.order(name: :asc).ids).to match_array([m2.id, m1.id])
+        expect(RelationModel.order(:name).ids).to match_array([m2.id, m1.id])
+        expect(RelationModel.order(:age).ids).to match_array([m1.id, m2.id])
+    end
+
+    it "Should query with list order" do
+        m1 = RelationModel.create!(age: 20, name: 'b')
+        m2 = RelationModel.create!(age: 5, name: 'a')
+        m3 = RelationModel.create!(age: 20, name: 'a')
+        expect(RelationModel.order(:age, :name).ids).to match_array([m2.id, m3.id, m1.id])
+    end
+
+    it "Should query with chained order" do
+        m1 = RelationModel.create!(age: 10, name: 'b')
+        m2 = RelationModel.create!(age: 20, name: 'a')
+        m3 = RelationModel.create!(age: 20, name: 'c')
+        expect(RelationModel.order(age: :desc).order(name: :asc).ids).to match_array([m2.id, m3.id, m1.id])
+    end
+
+    it "Should query with order chained with list" do
+        m1 = RelationModel.create!(age: 20, name: 'b')
+        m2 = RelationModel.create!(age: 5, name: 'a')
+        m3 = RelationModel.create!(age: 20, name: 'a', last_name: 'c')
+        m4 = RelationModel.create!(age: 20, name: 'a', last_name: 'a')
+        expect(RelationModel.order(:age, :name).order(:last_name).ids).to match_array([m2.id, m4.id, m3.id, m1.id])
+    end
+
+    it "Should query all" do
+        m1 = RelationModel.create!(active: true)
+        m2 = RelationModel.create!(active: false)
+        expect(RelationModel.all).to match_array([m1, m2])
+    end
+
+    it "should query all with condition and order"  do
+        m1 = RelationModel.create!(active: true, age: 10)
+        m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.where(active: true).order(age: :desc).all.to_a).to eq([m2, m1])
+        expect(RelationModel.all.where(active: true).order(age: :asc).to_a).to eq([m1, m2])
+    end
+
+    it "should query by id" do
+        m1 = RelationModel.create!(active: true, age: 10)
+        m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.where(id: [m1.id, m2.id])).to match_array([m1, m2])
+    end
+
+    it "should query first" do
+        _m1 = RelationModel.create!(active: true, age: 10)
+        m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.where(active: true).order(age: :desc).first).to eq m2
+    end
+
+    it "should query array first" do
+        _m1 = RelationModel.create!(active: true, age: 10)
+        m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.where(active: true).order(age: :desc)[0]).to eq m2
+    end
+
+    it "should query last" do
+        _m1 = RelationModel.create!(active: true, age: 10)
+        m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.where(active: true).order(age: :asc).last).to eq m2
+    end
+
+    it "should return a relation when using not" do
+        expect(RelationModel.not(active: true)).to be_a(CouchbaseOrm::Relation::CouchbaseOrm_Relation)
+        expect(RelationModel.all.not(active: true)).to be_a(CouchbaseOrm::Relation::CouchbaseOrm_Relation)
+    end
+
+    it "should have a to_ary method" do
+        expect(RelationModel.not(active: true)).to respond_to(:to_ary)
+        expect(RelationModel.all.not(active: true)).to respond_to(:to_ary)
+    end
+
+    it "should have a each method" do
+        expect(RelationModel.not(active: true)).to respond_to(:each)
+        expect(RelationModel.all.not(active: true)).to respond_to(:each)
+    end
+
+    it "should pluck one element" do
+        _m1 = RelationModel.create!(active: true, age: 10)
+        _m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.order(:age).pluck(:age)).to match_array([10, 20, 30])
+    end
+
+    it "should find one element" do
+        _m1 = RelationModel.create!(active: true, age: 10)
+        m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.all.find do |m|
+            m.age == 20
+        end).to eq m2
+    end
+
+    it "should pluck several elements" do
+        _m1 = RelationModel.create!(active: true, age: 10)
+        _m2 = RelationModel.create!(active: true, age: 20)
+        _m3 = RelationModel.create!(active: false, age: 30)
+        expect(RelationModel.order(:age).pluck(:age, :active)).to match_array([[10, true], [20, true], [30, false]])
+    end
+
+    it "should query true boolean" do
+        m1 = RelationModel.create!(active: true)
+        _m2 = RelationModel.create!(active: false)
+        _m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.where(active: true)).to match_array([m1])
+    end
+
+    it "should not query true boolean" do
+        _m1 = RelationModel.create!(active: true)
+        m2 = RelationModel.create!(active: false)
+        _m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.not(active: true)).to match_array([m2]) # keep ActiveRecord compatibility by not returning _m3 
+    end
+
+    it "should query false boolean" do
+        _m1 = RelationModel.create!(active: true)
+        m2 = RelationModel.create!(active: false)
+        _m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.where(active: false)).to match_array([m2])
+    end
+
+    it "should not query false boolean" do
+        m1 = RelationModel.create!(active: true)
+        _m2 = RelationModel.create!(active: false)
+        _m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.not(active: false)).to match_array([m1]) # keep ActiveRecord compatibility by not returning _m3 
+    end
+
+    it "should query nil boolean" do
+        _m1 = RelationModel.create!(active: true)
+        _m2 = RelationModel.create!(active: false)
+        m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.where(active: nil)).to match_array([m3])
+    end
+
+    it "should not query nil boolean" do
+        m1 = RelationModel.create!(active: true)
+        m2 = RelationModel.create!(active: false)
+        _m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.not(active: nil)).to match_array([m1, m2])
+    end
+
+    it "should query nil and false boolean" do
+        _m1 = RelationModel.create!(active: true)
+        m2 = RelationModel.create!(active: false)
+        m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.where(active: [false, nil])).to match_array([m2, m3])
+    end
+
+    it "should not query nil and false boolean" do
+        m1 = RelationModel.create!(active: true)
+        _m2 = RelationModel.create!(active: false)
+        _m3 = RelationModel.create!(active: nil)
+        expect(RelationModel.not(active: [false, nil])).to match_array([m1])
+    end
+
+    it "should query by string" do
+        m1 = RelationModel.create!(age: 20, active: true)
+        m2 = RelationModel.create!(age: 10, active: false)
+        m3 = RelationModel.create!(age: 20, active: false)
+
+        expect(RelationModel.where("active = true").count).to eq(1)
+        expect(RelationModel.where("active = true")).to match_array([m1])
+        expect(RelationModel.where("active = false")).to match_array([m2, m3])
+        expect(RelationModel.where(age: 20).where("active = false")).to match_array([m3])
+        expect(RelationModel.where("active = false").where(age: 20)).to match_array([m3])
+    end
+
+    it "is empty" do
+        expect(RelationModel.empty?).to eq(true)
+    end
+
+    it "is not empty with a created model" do
+        RelationModel.create!(active: true)
+        expect(RelationModel.empty?).to eq(false)
+    end
+
+    describe "operators" do
+        it "should query by gte and lte" do
+            _m1 = RelationModel.create!(age: 10)
+            m2 = RelationModel.create!(age: 20)
+            m3 = RelationModel.create!(age: 30)
+            _m4 = RelationModel.create!(age: 40)
+            expect(RelationModel.where(age: {_lte: 30, _gt:10})).to match_array([m2, m3])
+        end
+    end
+
+    describe "update_all" do
+        it "should update matching documents" do
+            m1 = RelationModel.create!(age: 10)
+            m2 = RelationModel.create!(age: 20)
+            m3 = RelationModel.create!(age: 30)
+            m4 = RelationModel.create!(age: 40)
+            RelationModel.where(age: {_lte: 30, _gt:10}).update_all(age: 50)
+            expect(m1.reload.age).to eq(10)
+            expect(m2.reload.age).to eq(50)
+            expect(m3.reload.age).to eq(50)
+            expect(m4.reload.age).to eq(40)
+        end
+
+        it "should update nested attributes with a for clause (when hash style)" do
+            m1 = RelationModel.create!(age: 10, children: [NestedRelationModel.new(age: 10, name: "Tom"), NestedRelationModel.new(age: 20, name: "Jerry")])
+            m2 = RelationModel.create!(age: 20, children: [NestedRelationModel.new(age: 15, name: "Tom"), NestedRelationModel.new(age: 20, name: "Jerry")])
+            m3 = RelationModel.create!(age: 20, children: [NestedRelationModel.new(age: 10, name: "Tom"), NestedRelationModel.new(age: 20, name: "Jerry")])
+            
+            RelationModel.where(age: 20).update_all(child: {age: 50, _for: :children, _when: {child: {name: "Tom"}}})
+            
+            expect(m1.reload.children.map(&:age)).to eq([10, 20])
+            expect(m2.reload.children.map(&:age)).to eq([50, 20])
+            expect(m3.reload.children.map(&:age)).to eq([50, 20])
+        end
+
+        it "should update nested attributes with a for clause (when path style)" do
+            m1 = RelationModel.create!(age: 10, children: [NestedRelationModel.new(age: 10, name: "Tom"), NestedRelationModel.new(age: 20, name: "Jerry")])
+            m2 = RelationModel.create!(age: 20, children: [NestedRelationModel.new(age: 15, name: "Tom"), NestedRelationModel.new(age: 20, name: "Jerry")])
+            m3 = RelationModel.create!(age: 20, children: [NestedRelationModel.new(age: 10, name: "Tom"), NestedRelationModel.new(age: 20, name: "Jerry")])
+            
+            RelationModel.where(age: 20).update_all(child: {age: 50, _for: :children, _when: {'child.name': "Tom"}})
+            
+            expect(m1.reload.children.map(&:age)).to eq([10, 20])
+            expect(m2.reload.children.map(&:age)).to eq([50, 20])
+            expect(m3.reload.children.map(&:age)).to eq([50, 20])
+        end
+
+        it "should update nested attributes with a path in a for clause" do
+            m1 = RelationModel.create!(
+                pathelement: PathRelationModel.new(
+                    pathelement: PathRelationModel.new(
+                        children: [NestedRelationModel.new(age: 10, name: "Tom"), NestedRelationModel.new(age: 20, name: "Jerry")]
+                    )
+                )
+            )
+
+            RelationModel.update_all(child: {age: 50, _for: 'pathelement.pathelement.children', _when: {'child.name': "Tom"}})
+
+            expect(m1.reload.pathelement.pathelement.children.map(&:age)).to eq([50, 20])
+        end
+    end
+
+    describe "scopes" do
+        it "should return block value" do
+            RelationModel.create!(active: true)
+            RelationModel.create!(active: false)
+            count = RelationModel.active.scoping do
+                RelationModel.count
+            end
+            expect(count).to eq 1
+        end
+        
+        it "should chain scopes" do
+            _m1 = RelationModel.create!(age: 10, active: true)
+            _m2 = RelationModel.create!(age: 20, active: false)
+            m3 = RelationModel.create!(age: 30, active: true)
+            m4 = RelationModel.create!(age: 40, active: true)
+
+            expect(RelationModel.all.adult.all.active.all).to match_array([m3, m4])
+            expect(RelationModel.where(active: true).adult).to match_array([m3, m4])
+        end
+
+        it "should be scoped only in current thread" do
+            m1 = RelationModel.create!(active: true)
+            m2 = RelationModel.create!(active: false)
+            RelationModel.active.scoping do
+                expect(RelationModel.all).to match_array([m1])
+                Thread.start do
+                    expect(RelationModel.all).to match_array([m1, m2])
+                end.join
+            end
+        end
+
+        it "should propagate error" do
+            expect{RelationModel.active.scoping do
+                raise "error"
+            end}.to raise_error(RuntimeError)
+        end
+
+        it "should not keep scope in case of error" do
+            _m1 = RelationModel.create!(age: 10, active: true)
+            _m2 = RelationModel.create!(age: 10, active: false)
+            _m3 = RelationModel.create!(age: 30, active: true)
+            _m3 = RelationModel.create!(age: 30, active: false)
+            RelationModel.active.scoping do
+                expect(RelationModel.count).to eq 2
+                begin
+                    RelationModel.adult.scoping do
+                        raise "error"
+                    end
+                rescue RuntimeError                    
+                end
+                expect(RelationModel.count).to eq 2
+            end
+        end
+    end
+end
+

data/spec/support.rb

@@ -1,16 +1,24 @@
 # frozen_string_literal: true, encoding: ASCII-8BIT
-
-
-if ENV['TRAVIS_TEST']
-    require 'libcouchbase'
-    Libcouchbase::Defaults.username = 'tester'
-    Libcouchbase::Defaults.password = 'password123'
-end
-
+require 'simplecov'
 require 'couchbase-orm'
 require 'minitest/assertions'
 require 'active_model/lint'
+require 'pry'
+require 'pry-stack_explorer'
+
+SimpleCov.start do
+    add_group 'Core', [/lib\/couchbase-orm\/(?!(proxies|utilities))/, 'lib/couchbase-orm.rb']
+    add_group 'Proxies', 'lib/couchbase-orm/proxies'
+    add_group 'Utilities', 'lib/couchbase-orm/utilities'
+    add_group 'Specs', 'spec'
+    minimum_coverage 94
+end
 
+if ENV["COUCHBASE_FLUSH"]
+    CouchbaseOrm.logger.warn "Flushing Couchbase bucket '#{CouchbaseOrm::Connection.bucket.name}'"
+    CouchbaseOrm::Connection.cluster.buckets.flush_bucket(CouchbaseOrm::Connection.bucket.name)
+    raise "BucketFlushed"
+end
 
 shared_examples_for "ActiveModel" do
     include Minitest::Assertions

data/spec/type_array_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path("../support", __FILE__)
+
+require "active_model"
+
+class TypeArrayTest < CouchbaseOrm::Base
+    attribute :name
+    attribute :tags, :array, type: :string
+    attribute :milestones, :array, type: :date
+    attribute :flags, :array, type: :boolean
+    attribute :things
+end
+
+describe CouchbaseOrm::Base do
+    it "should be able to store and retrieve an array of strings" do
+        obj = TypeArrayTest.new
+        obj.tags = ["foo", "bar"]
+        obj.save!
+
+        obj = TypeArrayTest.find(obj.id)
+        expect(obj.tags).to eq ["foo", "bar"]
+    end
+
+    it "should be able to store and retrieve an array of date" do
+        dates = [Date.today, Date.today + 1]
+        obj = TypeArrayTest.new
+        obj.milestones = dates
+        obj.save!
+
+        obj = TypeArrayTest.find(obj.id)
+        expect(obj.milestones).to eq dates
+    end
+
+    it "should be able to store and retrieve an array of boolean" do
+        flags = [true, false]
+        obj = TypeArrayTest.new
+        obj.flags = flags
+        obj.save!
+
+        obj = TypeArrayTest.find(obj.id)
+        expect(obj.flags).to eq flags
+    end
+
+    it "should be able to store and retrieve an array of basic objects" do
+        things = [1, "1234", {"key" => 4}]
+        obj = TypeArrayTest.new
+        obj.things = things
+        obj.save!
+
+        obj = TypeArrayTest.find(obj.id)
+        expect(obj.things).to eq things
+    end
+end

data/spec/type_encrypted_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("../support", __FILE__)
+
+require 'active_model'
+require 'base64'
+
+class SubTypeEncryptedTest < CouchbaseOrm::NestedDocument
+    attribute :name, :string
+    attribute :secret, :encrypted
+    attribute :secret2, :encrypted
+end
+
+class TypeEncryptedTest < CouchbaseOrm::Base
+    attribute :main, :nested, type: SubTypeEncryptedTest
+    attribute :others, :array, type: SubTypeEncryptedTest
+    attribute :secret, :encrypted
+    attribute :secret2, :encrypted
+end
+
+class SpecificAlgoTest < CouchbaseOrm::Base
+    attribute :secret, :encrypted, alg: "3DES"
+end
+
+describe CouchbaseOrm::Types::Encrypted do
+    # Generated with SecureRandom.bytes(256)
+    let(:the_secret) { "\x17`\x1F\xEE\el\xE0\x9F<\x94\xFE\x8A.\x1A\x92\xB9\xC3@\x86\x9Cp\xBEl\x86\x0E\x8CJ\tB\x97*U)\x96\x06\xA3\xE9\x84\xA6xW%\xDCT\x8C^\xEA\t\xC7\xD8\xFC\xF1\xD3\xD3\xE2\xEA\x89\xCBuUs\xB3\xFF'W>\xDE\x9CP\xA9\xDE%\xA2\xDE\x11\xFD\b\x9C\xD4\x87J,\x91\x02f\x16R\xDE\x908\x05\x1C\xF9\xDF{\x0F\xB3e\xB2\xB2\x96\xD7\xCC\x16As\xD3I\x02w\xE0\x8FL\xC6S\xEFP\xAC\x15\e^\xC4!\x15\"KF1\x17\x06\xA0N\x00\x18\xBA\x87\xEA?H\xD4<\xB5\xBCV\xB50\fc\xC9F\"\xF0B\eg%\x8E\x88\xD0\x9Bc\xE4\x93\t\x98\xC8\x87\xCB4]\xD9K\xA3\xDF\x13Q\xC0T\xCA\x91;\b\x9Cp\xE0\x7FR h\xDA\xB7\xD5\x869\f\xCA\x80\x802\x19\x19\xDD\x9DO\xAE}\xCA\eX\xA3\xA8\xBE\xE1\xBCW0g\x19@5n\r\xD8\xF3\x05\x7F4\x9CI\x1F3\xC0\xBDQJyG\v\xED!s\xD5\xD0&\xC1\x1A\xBC\x17\xFD\x9Cd\xB5\xAF\xB6U\x8A" }
+    let(:base64_secret) { Base64.strict_encode64(the_secret) }
+
+    it "prefix attribute on serialization" do
+        obj = TypeEncryptedTest.new(secret: base64_secret, secret2: "a secret")
+        expect_serialized_secret(obj)
+    end
+
+    it "prefix attribute on nested objects" do
+        obj = TypeEncryptedTest.new(main: SubTypeEncryptedTest.new(secret: base64_secret, secret2: "a secret"))
+        expect_serialized_secret(obj.main)
+    end
+
+    it "prefix attribute on array objects" do
+        obj = TypeEncryptedTest.new(others: [SubTypeEncryptedTest.new(secret: base64_secret, secret2: "a secret")])
+        expect_serialized_secret(obj.others.first)
+    end
+
+    def expect_serialized_secret(obj)
+        expect(obj.send(:serialized_attributes)["encrypted$secret"]).to eq({alg:"CB_MOBILE_CUSTOM", ciphertext: base64_secret})
+        expect(obj.send(:serialized_attributes)).to_not have_key "secret"
+        expect(obj.send(:serialized_attributes)["encrypted$secret2"]).to eq({alg:"CB_MOBILE_CUSTOM", ciphertext: "a secret"})
+        expect(obj.send(:serialized_attributes)).to_not have_key "secret2"
+        expect(JSON.parse(obj.to_json)["secret"]).to eq base64_secret
+        expect(obj.as_json["secret"]).to eq base64_secret
+        expect(obj.as_json["secret2"]).to eq "a secret"
+    end
+
+    it "prefix with custom algo" do
+        obj = SpecificAlgoTest.new(secret: base64_secret)
+        expect(obj.send(:serialized_attributes)["encrypted$secret"]).to eq({alg:"3DES", ciphertext: base64_secret})
+        expect(obj.send(:serialized_attributes)).to_not include "secret"
+    end
+
+    it "decode encrypted attribute at reload" do
+        obj = TypeEncryptedTest.create!(
+            secret: base64_secret,
+        )
+        obj.save!
+        obj.reload
+        expect(obj.secret).to eq base64_secret
+    end
+
+    it "decode nested encrypted attribute at reload" do
+        obj = TypeEncryptedTest.create!(
+            main: SubTypeEncryptedTest.new(secret: base64_secret),
+        )
+        obj.save!
+        obj.reload
+        expect(obj.main.secret).to eq base64_secret
+    end
+
+    it "decode array encrypted attribute at reload" do
+        obj = TypeEncryptedTest.create!(
+            others: [SubTypeEncryptedTest.new(secret: base64_secret)]
+        )
+        obj.save!
+        obj.reload
+        expect(obj.others.first.secret).to eq base64_secret
+    end
+
+    it "decode encrypted attribute at load" do
+        obj = TypeEncryptedTest.create!(
+            secret: base64_secret,
+        )
+        obj.save!
+        obj = TypeEncryptedTest.find(obj.id)
+        expect(obj.secret).to eq base64_secret
+    end
+
+    it "decode nested encrypted attribute at load" do
+        obj = TypeEncryptedTest.create!(
+            main: SubTypeEncryptedTest.new(secret: base64_secret),
+        )
+        obj.save!
+        obj = TypeEncryptedTest.find(obj.id)
+
+        expect(obj.main.secret).to eq base64_secret
+    end
+
+    it "decode array encrypted attribute at load" do
+        obj = TypeEncryptedTest.create!(
+            others: [SubTypeEncryptedTest.new(secret: base64_secret)]
+        )
+        obj.save!
+        obj = TypeEncryptedTest.find(obj.id)
+
+        expect(obj.others.first.secret).to eq base64_secret
+    end
+end