couchbase-orm 0.0.1

data/lib/rails/generators/couchbase_orm/config/config_generator.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+#
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'rails/generators/couchbase_orm_generator'
+
+module CouchbaseOrm
+    module Generators
+        class ConfigGenerator < Rails::Generators::Base
+            desc 'Creates a Couchbase configuration file at config/couchbase.yml'
+            argument :database_name, :type => :string, :optional => true
+
+            def self.source_root
+                @_couchbase_source_root ||= File.expand_path('../templates', __FILE__)
+            end
+
+            def app_name
+                Rails::Application.subclasses.first.parent.to_s.underscore
+            end
+
+            def create_config_file
+                template 'couchbase.yml', File.join('config', 'couchbase.yml')
+            end
+
+        end
+    end
+end

data/lib/rails/generators/couchbase_orm/config/templates/couchbase.yml

@@ -0,0 +1,18 @@
+common: &common
+  hosts: localhost
+  password:
+
+development:
+  <<: *common
+  bucket: <%= database_name || 'default' %>
+
+test:
+  <<: *common
+  bucket: <%= database_name || app_name %>_test
+  password: for_test_bucket
+
+# set these environment variables on your production server
+production:
+  hosts: <%%= ENV['COUCHBASE_HOST'] || ENV['COUCHBASE_HOSTS'] %>
+  bucket: <%%= ENV['COUCHBASE_BUCKET'] %>
+  password: <%%= ENV['COUCHBASE_PASSWORD'] %>

data/lib/rails/generators/couchbase_orm_generator.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+#
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2012 Couchbase, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'rails/generators/named_base'
+require 'rails/generators/active_model'
+
+module CouchbaseOrm #:nodoc:
+    module Generators #:nodoc:
+
+        class Base < ::Rails::Generators::NamedBase #:nodoc:
+
+            def self.source_root
+                @_couchbase_source_root ||=
+                    File.expand_path("../#{base_name}/#{generator_name}/templates", __FILE__)
+            end
+
+            unless methods.include?(:module_namespacing)
+                def module_namespacing(&block)
+                    yield if block
+                end
+            end
+
+        end
+
+    end
+end

data/spec/associations_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+
+class Parent < CouchbaseOrm::Base
+    attribute :name
+end
+
+class Child < CouchbaseOrm::Base
+    attribute :name
+
+    belongs_to :parent, dependent: :destroy
+end
+
+
+describe CouchbaseOrm::Associations do
+    it "should work with dependent associations" do
+        parent = Parent.create!(name: 'joe')
+        child  = Child.create!(name: 'bob', parent_id: parent.id)
+
+        expect(parent.persisted?).to be(true)
+        expect(child.persisted?).to be(true)
+        id = parent.id
+
+        child.destroy
+        expect(child.destroyed?).to be(true)
+        expect(parent.destroyed?).to be(false)
+
+        # Ensure that parent has been destroyed
+        expect { Parent.find(id) }.to raise_error(Libcouchbase::Error::KeyNotFound)
+        expect(Parent.find_by_id(id)).to be(nil)
+
+        expect { parent.reload }.to raise_error(Libcouchbase::Error::KeyNotFound)
+
+        # Save will always return true unless the model is changed (won't touch the database)
+        parent.name = 'should fail'
+        expect { parent.save  }.to raise_error(Libcouchbase::Error::KeyNotFound)
+        expect { parent.save! }.to raise_error(Libcouchbase::Error::KeyNotFound)
+    end
+
+    it "should cache associations" do
+        parent = Parent.create!(name: 'joe')
+        child  = Child.create!(name: 'bob', parent_id: parent.id)
+
+        id = child.parent.__id__
+        expect(parent.__id__).not_to eq(child.parent.__id__)
+        expect(parent).to eq(child.parent)
+        expect(child.parent.__id__).to eq(id)
+
+        child.reload
+        expect(parent).to eq(child.parent)
+        expect(child.parent.__id__).not_to eq(id)
+
+        child.destroy
+    end
+
+    it "should ignore associations when delete is used" do
+        parent = Parent.create!(name: 'joe')
+        child  = Child.create!(name: 'bob', parent_id: parent.id)
+
+        id = child.id
+        child.delete
+
+        expect(Child.exists?(id)).to be(false)
+        expect(Parent.exists?(parent.id)).to be(true)
+
+        id = parent.id
+        parent.delete
+        expect(Parent.exists?(id)).to be(false)
+    end
+
+    describe Parent do
+        it_behaves_like "ActiveModel"
+    end
+
+    describe Child do
+        it_behaves_like "ActiveModel"
+    end
+end

data/spec/base_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+
+class BaseTest < CouchbaseOrm::Base
+    attribute :name, :job
+end
+
+class CompareTest < CouchbaseOrm::Base
+    attribute :age
+end
+
+
+
+describe CouchbaseOrm::Base do
+    it "should be comparable to other objects" do
+        base  = BaseTest.create!(name: 'joe')
+        base2 = BaseTest.create!(name: 'joe')
+
+        expect(base).to eq(base)
+        expect(base).to be(base)
+        expect(base).not_to eq(base2)
+
+        same_base = BaseTest.find(base.id)
+        expect(base).to eq(same_base)
+        expect(base).not_to be(same_base)
+        expect(base2).not_to eq(same_base)
+
+        base.delete
+        base2.delete
+    end
+
+    it "should load database responses" do
+        base = BaseTest.create!(name: 'joe')
+        resp = BaseTest.bucket.get(base.id, extended: true)
+
+        expect(resp.key).to eq(base.id)
+
+        base_loaded = BaseTest.new(resp)
+        expect(base_loaded).to     eq(base)
+        expect(base_loaded).not_to be(base)
+
+        base.destroy
+    end
+
+    it "should not load objects if there is a type mismatch" do
+        base = BaseTest.create!(name: 'joe')
+
+        expect { CompareTest.find_by_id(base.id) }.to raise_error(RuntimeError)
+
+        base.destroy
+    end
+
+    it "should support serialisation" do
+        base = BaseTest.create!(name: 'joe')
+
+        base_id = base.id
+        expect(base.to_json).to eq({name: 'joe', job: nil, id: base_id}.to_json)
+        expect(base.to_json(only: :name)).to eq({name: 'joe'}.to_json)
+
+        base.destroy
+    end
+
+    describe BaseTest do
+        it_behaves_like "ActiveModel"
+    end
+
+    describe CompareTest do
+        it_behaves_like "ActiveModel"
+    end
+end

data/spec/has_many_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+
+class ObjectRatingTest < CouchbaseOrm::Base
+    join :object_test, :rating_test
+    view :all
+end
+
+class RatingTest < CouchbaseOrm::Base
+    enum rating: [:awesome, :good, :okay, :bad], default: :okay
+    belongs_to :object_test
+
+    has_many :object_tests, through: :object_rating_test
+    view :all
+end
+
+class ObjectTest < CouchbaseOrm::Base
+    attribute :name, type: String
+    has_many :rating_tests, dependent: :destroy
+
+    view :all
+end
+
+
+describe CouchbaseOrm::HasMany do
+    before :all do
+        RatingTest.ensure_design_document!
+        ObjectTest.ensure_design_document!
+        ObjectRatingTest.ensure_design_document!
+    end
+
+    after :each do
+        ObjectTest.all.stream { |ob| ob.delete }
+        RatingTest.all.stream { |ob| ob.delete }
+        ObjectRatingTest.all.stream { |ob| ob.delete }
+    end
+
+    it "should return matching results" do
+        first = ObjectTest.create! name: :bob
+        second = ObjectTest.create! name: :jane
+
+        rate = RatingTest.create! rating: :awesome, object_test: first
+        RatingTest.create! rating: :bad, object_test: second
+        RatingTest.create! rating: :good, object_test: first
+
+        expect(rate.object_test_id).to eq(first.id)
+        expect(RatingTest.respond_to?(:find_by_object_test_id)).to be(true)
+        expect(first.respond_to?(:rating_tests)).to be(true)
+
+        docs = first.rating_tests.collect { |ob|
+            ob.rating
+        }
+
+        expect(docs).to eq([1, 2])
+
+        first.destroy
+        expect { RatingTest.find rate.id }.to raise_error(::Libcouchbase::Error::KeyNotFound)
+        expect(RatingTest.all.count).to be(1)
+    end
+
+    it "should work through a join model" do
+        first = ObjectTest.create! name: :bob
+        second = ObjectTest.create! name: :jane
+
+        rate1 = RatingTest.create! rating: :awesome, object_test: first
+        rate2 = RatingTest.create! rating: :bad, object_test: second
+        rate3 = RatingTest.create! rating: :good, object_test: first
+
+        ort = ObjectRatingTest.create! object_test: first, rating_test: rate1
+        ObjectRatingTest.create! object_test: second, rating_test: rate1
+
+        expect(ort.rating_test_id).to eq(rate1.id)
+        expect(rate1.respond_to?(:object_tests)).to be(true)
+        docs = rate1.object_tests.collect { |ob|
+            ob.name
+        }
+
+        expect(docs).to eq(['bob', 'jane'])
+    end
+end

data/spec/id_generator_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require 'couchbase-orm'
+require 'thread'
+
+class IdTestModel < CouchbaseOrm::Base; end
+
+describe CouchbaseOrm::IdGenerator do
+    it "should not generate ID clashes" do
+        model = IdTestModel.new
+
+        ids1 = []
+        thread1 = Thread.new do
+            (1..10000).each {
+                ids1 << CouchbaseOrm::IdGenerator.next(model)
+            }
+        end
+
+        ids2 = []
+        thread2 = Thread.new do
+            (1..10000).each {
+                ids2 << CouchbaseOrm::IdGenerator.next(model)
+            }
+        end
+
+        ids3 = []
+        thread3 = Thread.new do
+            (1..10000).each {
+                ids3 << CouchbaseOrm::IdGenerator.next(model)
+            }
+        end
+
+        ids4 = []
+        thread4 = Thread.new do
+            (1..10000).each {
+                ids4 << CouchbaseOrm::IdGenerator.next(model)
+            }
+        end
+
+        thread1.join
+        thread2.join
+        thread3.join
+        thread4.join
+
+        results = [ids1, ids2, ids3, ids4].flatten
+        expect(results.uniq).to eq(results)
+    end
+end

data/spec/index_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true, encoding: ASCII-8BIT
+
+require File.expand_path("../support", __FILE__)
+
+
+class IndexTest < CouchbaseOrm::Base
+    attribute :email
+    ensure_unique :email
+end
+
+class EnumTest < CouchbaseOrm::Base
+    enum visibility: [:group, :authority, :public], default: :authority
+end
+
+
+describe CouchbaseOrm::Index do
+    it "should prevent models being created if they should have unique keys" do
+        joe = IndexTest.create!(email: 'joe@aca.com')
+        expect { IndexTest.create!(email: 'joe@aca.com') }.to raise_error(CouchbaseOrm::Error::RecordInvalid)
+
+        joe.email = 'other@aca.com'
+        joe.save
+        other = IndexTest.new(email: 'joe@aca.com')
+        expect(other.save).to be(true)
+
+        expect { IndexTest.create!(email: 'joe@aca.com') }.to raise_error(CouchbaseOrm::Error::RecordInvalid)
+        expect { IndexTest.create!(email: 'other@aca.com') }.to raise_error(CouchbaseOrm::Error::RecordInvalid)
+
+        joe.destroy
+        other.destroy
+
+        again = IndexTest.new(email: 'joe@aca.com')
+        expect(again.save).to be(true)
+
+        again.destroy
+    end
+
+    it "should provide helper methods for looking up the model" do
+        joe = IndexTest.create!(email: 'joe@aca.com')
+
+        joe_again = IndexTest.find_by_email('joe@aca.com')
+        expect(joe).to eq(joe_again)
+
+        joe.destroy
+    end
+
+    it "should clean up itself if dangling keys are left" do
+        joe = IndexTest.create!(email: 'joe@aca.com')
+        joe.delete # no callbacks are executed
+
+        again = IndexTest.new(email: 'joe@aca.com')
+        expect(again.save).to be(true)
+
+        again.destroy
+    end
+
+    it "should work with enumerators" do
+        # Test symbol
+        enum = EnumTest.create!(visibility: :public)
+        expect(enum.visibility).to eq(3)
+        enum.destroy
+
+        # Test number
+        enum = EnumTest.create!(visibility: 2)
+        expect(enum.visibility).to eq(2)
+        enum.destroy
+
+        # Test default
+        enum = EnumTest.create!
+        expect(enum.visibility).to eq(2)
+        enum.destroy
+    end
+end