rmodel 0.4.0.dev → 1.0.0

data/spec/rmodel/mongo/repository_spec.rb

@@ -1,50 +1,29 @@
-RSpec.describe Rmodel::Mongo::Repository do
-  it_behaves_like 'repository crud' do
-    include_context 'clean mongo database'
+RSpec.describe 'Repository with MongoDB' do
+  include_context 'clean mongo database'
 
-    before do
-      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
-    end
+  shared_examples 'definitions' do
+    let(:source) { Rmodel::Mongo::Source.new(mongo_session, :things) }
+    let(:mapper_klass) { Rmodel::Mongo::Mapper }
+  end
 
-    let(:factory) { Rmodel::Mongo::SimpleFactory.new(Thing, :name) }
-    subject { ThingRepository.new(mongo_session, :things, factory) }
+  it_behaves_like 'repository crud' do
+    include_context 'definitions'
     let(:unique_constraint_error) { Mongo::Error::OperationFailure }
-
-    def insert_record(id, columns)
-      record = columns.dup
-      record['_id'] = id
-      mongo_session[:things].insert_one(record)
-    end
   end
 
   it_behaves_like 'sugarable repository' do
-    include_context 'clean mongo database'
-
-    before do
-      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
-    end
-
-    subject do
-      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name)
-      ThingRepository.new(mongo_session, :things, factory)
-    end
+    include_context 'definitions'
   end
 
   it_behaves_like 'timestampable repository' do
-    include_context 'clean mongo database'
-
-    before do
-      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
-    end
+    include_context 'definitions'
+  end
 
-    let(:repo_w_timestamps) do
-      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name, :created_at, :updated_at)
-      ThingRepository.new(mongo_session, :things, factory)
-    end
+  it_behaves_like 'initialization' do
+    include_context 'definitions'
+  end
 
-    let(:repo_wo_timestamps) do
-      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name)
-      ThingRepository.new(mongo_session, :things, factory)
-    end
+  it_behaves_like 'scopable repository' do
+    include_context 'definitions'
   end
 end

data/spec/rmodel/mongo/source_spec.rb

@@ -0,0 +1,113 @@
+RSpec.describe Rmodel::Mongo::Source do
+  include_context 'clean mongo database'
+
+  subject { Rmodel::Mongo::Source.new(mongo_session, :things) }
+
+  describe '#initialize(connection, collection)'
+
+  describe 'find(id)' do
+    context 'when an existent id is given' do
+      before do
+        mongo_session[:things].insert_one('_id' => 1, 'name' => 'chair')
+      end
+
+      it 'returns the doc' do
+        doc = subject.find(1)
+        expect(doc['name']).to eq 'chair'
+      end
+    end
+
+    context 'when a non-existent id is given' do
+      it 'returns nil' do
+        expect(subject.find(1)).to be_nil
+      end
+    end
+  end
+
+  describe 'insert(doc)' do
+    context 'when the _id is not set' do
+      let(:inserted_id) { subject.insert('name' => 'chair') }
+
+      it 'returns the new _id' do
+        expect(inserted_id).not_to be_nil
+      end
+
+      it 'saves the doc' do
+        found = mongo_session[:things].find('_id' => inserted_id).first
+        expect(found['name']).to eq 'chair'
+      end
+    end
+
+    context 'when the _id is set' do
+      context 'when the _id is already occupied' do
+        before do
+          mongo_session[:things].insert_one('_id' => 1)
+        end
+
+        it 'throws the error' do
+          expect do
+            subject.insert('_id' => 1)
+          end.to raise_error Mongo::Error::OperationFailure
+        end
+      end
+
+      context 'when the _id is not occupied' do
+        it 'returns the same id' do
+          id = subject.insert('_id' => 1)
+          expect(id).to eq 1
+        end
+      end
+    end
+  end
+
+  describe 'update(id, doc)' do
+    before do
+      subject.insert('_id' => 1, 'name' => 'chair')
+    end
+
+    it 'updates the doc' do
+      subject.update(1, 'name' => 'table')
+      expect(subject.find(1)['name']).to eq 'table'
+    end
+  end
+
+  describe 'delete(id)' do
+    before do
+      subject.insert('_id' => 1)
+    end
+
+    it 'deletes the doc' do
+      subject.delete(1)
+      expect(subject.find(1)).to be_nil
+    end
+  end
+
+  describe 'build_query' do
+    it 'returns the object what includes methods of Origin::Queryable' do
+      expect(subject.build_query).to respond_to :aliases, :where, :group
+    end
+  end
+
+  describe 'exec_query(query)' do
+    before do
+      3.times { subject.insert({}) }
+    end
+
+    it 'returns docs' do
+      docs = subject.exec_query(subject.build_query)
+      expect(docs.to_a.length).to eq 3
+    end
+  end
+
+  describe 'delete_by_query(query)' do
+    before do
+      3.times { subject.insert({}) }
+    end
+
+    it 'deletes docs' do
+      subject.delete_by_query(subject.build_query)
+      found = subject.exec_query(subject.build_query)
+      expect(found.to_a).to be_empty
+    end
+  end
+end

data/spec/rmodel/sequel/mapper_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe Rmodel::Sequel::Mapper do
+  before do
+    stub_const 'User', Struct.new(:id, :name, :age)
+  end
+
+  subject { described_class.new(User).define_attributes(:name, :age) }
+
+  describe '#deserialize(hash)' do
+    it 'returns an instance of the appropriate class' do
+      expect(subject.deserialize({})).to be_an_instance_of User
+    end
+
+    it 'sets the attributes correctly' do
+      object = subject.deserialize(name: 'John', age: 20)
+
+      expect(object.name).to eq 'John'
+      expect(object.age).to eq 20
+    end
+
+    context 'when _id is given' do
+      it 'sets the #id correctly' do
+        object = subject.deserialize(id: 1)
+        expect(object.id).to eq 1
+      end
+    end
+  end
+
+  describe '#serialize(object, id_included)' do
+    it 'returns an instance of Hash' do
+      hash = subject.serialize(User.new(1, 'John', 20), true)
+      expect(hash).to be_an_instance_of Hash
+    end
+
+    it 'sets the keys correctly' do
+      hash = subject.serialize(User.new(1, 'John', 20), true)
+
+      expect(hash[:name]).to eq 'John'
+      expect(hash[:age]).to eq 20
+    end
+
+    context 'when id_included = true' do
+      it 'sets the id' do
+        hash = subject.serialize(User.new(1), true)
+        expect(hash[:id]).to eq 1
+      end
+    end
+
+    context 'when id_included = false' do
+      it 'doesnt set the id' do
+        hash = subject.serialize(User.new(1), false)
+        expect(hash.key?(:id)).to be false
+      end
+    end
+  end
+
+  it_behaves_like 'base mapper'
+end

data/spec/rmodel/sequel/repository_spec.rb

@@ -1,53 +1,42 @@
-RSpec.describe Rmodel::Sequel::Repository do
-  it_behaves_like 'repository crud' do
-    include_examples 'clean sequel database'
+RSpec.describe 'Repository with Sequel' do
+  include_examples 'clean sequel database'
 
-    before do
-      create_database
-      stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
-    end
+  shared_examples 'definitions' do
+    let(:source) { Rmodel::Sequel::Source.new(sequel_conn, :things) }
+    let(:mapper_klass) { Rmodel::Sequel::Mapper }
+  end
 
-    let(:factory) { Rmodel::Sequel::SimpleFactory.new(Thing, :name) }
-    subject { ThingRepository.new(sequel_conn, :things, factory) }
-    let(:unique_constraint_error) { Sequel::UniqueConstraintViolation }
+  it_behaves_like 'repository crud' do
+    before { create_database }
 
-    def insert_record(id, columns)
-      record = columns.dup
-      record[:id] = id
-      sequel_conn[:things].insert(record)
-    end
+    include_context 'definitions'
+    let(:unique_constraint_error) { Sequel::UniqueConstraintViolation }
   end
 
   it_behaves_like 'sugarable repository' do
-    include_examples 'clean sequel database'
-
-    before do
-      create_database
-      stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
-    end
-
-    subject do
-      factory = Rmodel::Sequel::SimpleFactory.new(Thing, :name)
-      ThingRepository.new(sequel_conn, :things, factory)
-    end
+    before { create_database }
+    include_context 'definitions'
   end
 
   it_behaves_like 'timestampable repository' do
-    include_examples 'clean sequel database'
+    before { create_database(true) }
+    include_context 'definitions'
+  end
 
-    before do
-      create_database(true)
-      stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
-    end
+  it_behaves_like 'initialization' do
+    before { create_database(true) }
+    include_context 'definitions'
+  end
 
-    let(:repo_w_timestamps) do
-      factory = Rmodel::Sequel::SimpleFactory.new(Thing, :name, :created_at, :updated_at)
-      ThingRepository.new(sequel_conn, :things, factory)
-    end
+  it_behaves_like 'scopable repository' do
+    include_context 'definitions'
 
-    let(:repo_wo_timestamps) do
-      factory = Rmodel::Sequel::SimpleFactory.new(Thing, :name)
-      ThingRepository.new(sequel_conn, :things, factory)
+    def create_database
+      sequel_conn.create_table(:things) do
+        primary_key :id
+        Integer :a
+        Integer :b
+      end
     end
   end
 

data/spec/rmodel/sequel/source_spec.rb

@@ -0,0 +1,121 @@
+RSpec.describe Rmodel::Sequel::Source do
+  include_context 'clean sequel database'
+  before { create_database }
+
+  subject { Rmodel::Sequel::Source.new(sequel_conn, :things) }
+
+  describe '#initialize(connection, table)'
+
+  describe 'find(id)' do
+    context 'when an existent id is given' do
+      before do
+        sequel_conn[:things].insert(id: 1, name: 'chair')
+      end
+
+      it 'returns the tuple' do
+        tuple = subject.find(1)
+        expect(tuple[:name]).to eq 'chair'
+      end
+    end
+
+    context 'when a non-existent id is given' do
+      it 'returns nil' do
+        expect(subject.find(1)).to be_nil
+      end
+    end
+  end
+
+  describe 'insert(tuple)' do
+    context 'when the id is not set' do
+      let(:inserted_id) { subject.insert(name: 'chair') }
+
+      it 'returns the new id' do
+        expect(inserted_id).not_to be_nil
+      end
+
+      it 'saves the tuple' do
+        found = sequel_conn[:things].where(id: inserted_id).first
+        expect(found[:name]).to eq 'chair'
+      end
+    end
+
+    context 'when the id is set' do
+      context 'when the id is already occupied' do
+        before do
+          sequel_conn[:things].insert(id: 1)
+        end
+
+        it 'throws the error' do
+          expect do
+            subject.insert(id: 1)
+          end.to raise_error Sequel::UniqueConstraintViolation
+        end
+      end
+
+      context 'when the id is not occupied' do
+        it 'returns the same id' do
+          id = subject.insert(id: 1)
+          expect(id).to eq 1
+        end
+      end
+    end
+  end
+
+  describe 'update(id, doc)' do
+    before do
+      subject.insert(id: 1, name: 'chair')
+    end
+
+    it 'updates the doc' do
+      subject.update(1, name: 'table')
+      expect(subject.find(1)[:name]).to eq 'table'
+    end
+  end
+
+  describe 'delete(id)' do
+    before do
+      subject.insert(id: 1)
+    end
+
+    it 'deletes the doc' do
+      subject.delete(1)
+      expect(subject.find(1)).to be_nil
+    end
+  end
+
+  describe 'build_query' do
+    it 'returns the instance of Sequel::Dataset' do
+      expect(subject.build_query).to be_a_kind_of Sequel::Dataset
+    end
+  end
+
+  describe 'exec_query(query)' do
+    before do
+      3.times { subject.insert({}) }
+    end
+
+    it 'returns tuples' do
+      docs = subject.exec_query(subject.build_query)
+      expect(docs.to_a.length).to eq 3
+    end
+  end
+
+  describe 'delete_by_query(query)' do
+    before do
+      3.times { subject.insert({}) }
+    end
+
+    it 'deletes tuples' do
+      subject.delete_by_query(subject.build_query)
+      found = subject.exec_query(subject.build_query)
+      expect(found.to_a).to be_empty
+    end
+  end
+
+  def create_database
+    sequel_conn.create_table(:things) do
+      primary_key :id
+      String :name
+    end
+  end
+end

data/spec/shared/base_mapper.rb

@@ -0,0 +1,39 @@
+require 'active_support/hash_with_indifferent_access'
+
+RSpec.shared_examples 'base mapper' do
+  describe '#initialize' do
+    context 'when the Thing model is given' do
+      before { stub_const 'Thing', Class.new }
+      subject { described_class.new(Thing) }
+
+      it 'creates instances of Thing' do
+        expect(subject.deserialize({})).to be_instance_of Thing
+      end
+    end
+  end
+
+  describe '#define_timestamps' do
+    context 'on serialization' do
+      before do
+        stub_const 'Thing', Struct.new(:created_at, :updated_at)
+      end
+
+      subject { described_class.new(Thing).define_timestamps }
+
+      let(:thing) { Thing.new(Time.now, Time.now) }
+
+      let(:serialized) do
+        hash = subject.serialize(thing, false)
+        ActiveSupport::HashWithIndifferentAccess.new(hash)
+      end
+
+      it 'adds created_at to a hash' do
+        expect(serialized).to have_key(:created_at)
+      end
+
+      it 'adds updated_at to a hash' do
+        expect(serialized).to have_key(:updated_at)
+      end
+    end
+  end
+end