rmodel 0.4.0.dev → 1.0.0

data/spec/shared/clean_moped.rb

@@ -1,10 +1,14 @@
 RSpec.shared_context 'clean mongo database' do
-  let(:mongo_session) { Mongo::Client.new([ '127.0.0.1:27017' ], database: 'rmodel_test') }
+  let(:mongo_session) { create_connection }
 
   before(:all) do
     Mongo::Logger.logger.level = Logger::ERROR
-    mongo_session = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'rmodel_test')
+    mongo_session = create_connection
     mongo_session.database.drop
   end
   after { mongo_session.database.drop }
+
+  def create_connection
+    Mongo::Client.new(['127.0.0.1:27017'], database: 'rmodel_test')
+  end
 end

data/spec/shared/clean_sequel.rb

@@ -1,5 +1,5 @@
 RSpec.shared_context 'clean sequel database' do
-  let(:sequel_conn) { Sequel.connect(adapter: 'sqlite', database: 'rmodel_test.sqlite3') }
+  let(:sequel_conn) { Sequel.sqlite('rmodel_test.sqlite3') }
 
   before(:all) do
     Mongo::Logger.logger.level = Logger::ERROR

data/spec/shared/{repository_ext → repository}/crud.rb

@@ -1,10 +1,12 @@
 RSpec.shared_examples 'repository crud' do
-  before do
-    stub_const('Thing', Struct.new(:id, :name))
-  end
+  before { stub_const('Thing', Struct.new(:id, :name)) }
+
+  let(:mapper) { mapper_klass.new(Thing).define_attributes(:name) }
+
+  subject { Rmodel::Repository.new(source, mapper) }
 
   describe '#find' do
-    before { insert_record(1, name: 'chair') }
+    before { subject.insert_one(Thing.new(1, 'chair')) }
 
     context 'when an existent id is given' do
       it 'returns the instance of correct type' do
@@ -23,36 +25,39 @@ RSpec.shared_examples 'repository crud' do
     end
   end
 
-  describe '#insert' do
+  describe '#insert_one(object)' do
     context 'when the id is not provided' do
       let(:thing) { Thing.new(nil, 'chair') }
 
+      before { subject.insert_one(thing) }
+
       it 'sets the id before insert' do
-        subject.insert(thing)
         expect(thing.id).not_to be_nil
       end
 
       it 'persists the object' do
-        subject.insert(thing)
         expect(subject.find(thing.id).name).to eq 'chair'
       end
     end
 
     context 'when the id is provided' do
-      let(:thing) { Thing.new(1000, 'chair') }
+      let(:thing) { Thing.new(1000) }
 
       it 'uses the existent id' do
-        subject.insert(thing)
+        subject.insert_one(thing)
         expect(thing.id).to eq 1000
       end
     end
 
     context 'when the given id already exists' do
       let(:thing) { Thing.new }
-      before { subject.insert(thing) }
+
+      before { subject.insert_one(thing) }
 
       it 'raises the error' do
-        expect { subject.insert(thing) }.to raise_error unique_constraint_error
+        expect do
+          subject.insert_one(thing)
+        end.to raise_error unique_constraint_error
       end
     end
   end
@@ -71,12 +76,13 @@ RSpec.shared_examples 'repository crud' do
     end
   end
 
-  describe '#remove' do
+  describe '#destroy' do
     let(:thing) { Thing.new }
+
     before { subject.insert(thing) }
 
-    it 'removes the record' do
-      subject.remove(thing)
+    it 'destroys the record' do
+      subject.destroy(thing)
       expect(subject.find(thing.id)).to be_nil
     end
   end

data/spec/shared/repository/initialization.rb

@@ -0,0 +1,39 @@
+RSpec.shared_examples 'initialization' do
+  before do
+    stub_const 'Thing', Struct.new(:id, :name)
+
+    stub_const 'ThingRepository', Class.new(Rmodel::Repository)
+    class ThingRepository
+      attr_reader :source, :mapper
+    end
+  end
+
+  let(:source) { Object.new }
+  let(:mapper) { mapper_klass.new(Thing).define_attributes(:name) }
+
+  describe '#initialize(source, collection, mapper)' do
+    context 'when all constructor arguments are passed' do
+      it 'works!' do
+        expect do
+          ThingRepository.new(source, mapper)
+        end.not_to raise_error
+      end
+    end
+
+    context 'when source is nil' do
+      it 'raises the error' do
+        expect do
+          ThingRepository.new(nil, mapper)
+        end.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when mapper is nil' do
+      it 'raises the error' do
+        expect do
+          ThingRepository.new(source, nil)
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/shared/repository/scopable.rb

@@ -0,0 +1,137 @@
+RSpec.shared_examples 'scopable repository' do
+  before do
+    stub_const 'Thing', Struct.new(:id, :a, :b)
+    stub_const 'ThingRepository', Class.new(Rmodel::Repository)
+
+    # Use the same scope syntax for Mongo and Sequel
+    class ThingRepository
+      scope :a_equals_2 do
+        where(a: 2)
+      end
+
+      scope :a_equals do |n|
+        where(a: n)
+      end
+
+      scope :b_equals do |n|
+        where(b: n)
+      end
+    end
+  end
+
+  let(:mapper) { mapper_klass.new(Thing).define_attributes(:a, :b) }
+
+  subject { ThingRepository.new(source, mapper) }
+
+  before do
+    create_database if defined?(create_database)
+
+    subject.insert(Thing.new(nil, 2, 3))
+    subject.insert(Thing.new(nil, 2, 4))
+    subject.insert(Thing.new(nil, 5, 6))
+  end
+
+  describe '.scope' do
+    context 'when a scope w/o arguments is defined' do
+      it 'works!' do
+        expect(subject.fetch.a_equals_2.count).to eq 2
+      end
+
+      it 'returns an array of instances of the appropriate class' do
+        expect(subject.fetch.a_equals_2.first).to be_an_instance_of Thing
+      end
+    end
+
+    context 'when a scope w/ arguments is defined' do
+      it 'works!' do
+        expect(subject.fetch.a_equals(2).count).to eq 2
+      end
+    end
+
+    context 'when two scopes are defined and chained' do
+      it 'works!' do
+        expect(subject.fetch.a_equals(2).b_equals(4).count).to eq 1
+      end
+    end
+
+    context 'when an unknown scope is used' do
+      it 'raises the NoMethodError' do
+        expect { subject.fetch.something }.to raise_error NoMethodError
+      end
+    end
+  end
+
+  describe '#fetch' do
+    describe '#delete_all' do
+      context 'when no scope is given' do
+        it 'removes all objects' do
+          subject.fetch.delete_all
+          expect(subject.fetch.count).to eq 0
+        end
+      end
+
+      context 'when the scope filters 2 objects from 3' do
+        it 'removes 2 objects' do
+          subject.fetch.a_equals_2.delete_all
+          expect(subject.fetch.count).to eq 1
+        end
+      end
+    end
+
+    describe '#destroy_all' do
+      context 'when no scope is given' do
+        it 'destroys all objects' do
+          subject.fetch.destroy_all
+          expect(subject.fetch.count).to eq 0
+        end
+
+        it 'calls #destroy for each object' do
+          expect(subject).to receive(:destroy).exactly(3).times
+          subject.fetch.destroy_all
+        end
+      end
+
+      context 'when the scope filters 2 objects from 3' do
+        it 'destroys 2 objects' do
+          subject.fetch.a_equals_2.destroy_all
+          expect(subject.fetch.count).to eq 1
+        end
+
+        it 'calls #destroy for each object' do
+          expect(subject).to receive(:destroy).exactly(2).times
+          subject.fetch.a_equals_2.destroy_all
+        end
+      end
+    end
+  end
+
+  describe '#all' do
+    it 'gets all objects' do
+      objects = subject.all
+      expect(objects.length).to eq 3
+    end
+  end
+
+  describe '#delete_all' do
+    context 'when no scope is given' do
+      it 'deletes all objects' do
+        subject.delete_all
+        expect(subject.fetch.count).to eq 0
+      end
+    end
+  end
+
+  describe '#destroy_all' do
+    context 'when no scope is given' do
+      it 'deletes all objects' do
+        subject.destroy_all
+        expect(subject.fetch.count).to eq 0
+      end
+
+      it 'calls #destroy for each object' do
+        expect(subject).to receive(:destroy).exactly(3).times
+        subject.destroy_all
+      end
+    end
+  end
+end

data/spec/shared/repository/sugarable.rb

@@ -0,0 +1,67 @@
+RSpec.shared_examples 'sugarable repository' do
+  before { stub_const('Thing', Struct.new(:id, :name)) }
+
+  let(:mapper) { mapper_klass.new(Thing).define_attributes(:name) }
+
+  subject { Rmodel::Repository.new(source, mapper) }
+
+  describe '#find!(id)' do
+    context 'when an existent id is given' do
+      before { subject.insert(Thing.new(1)) }
+
+      it 'returns the right instance' do
+        expect(subject.find!(1)).not_to be_nil
+      end
+    end
+
+    context 'when a non-existent id is given' do
+      it 'raises NotFound' do
+        expect { subject.find!(1) }.to raise_error Rmodel::NotFound
+      end
+    end
+  end
+
+  describe '#insert(object1, object2, ...)' do
+    context 'when one object is provided' do
+      it 'inserts one object' do
+        subject.insert(Thing.new)
+        expect(subject.fetch.count).to eq 1
+      end
+    end
+
+    context 'when an array of objects is provided' do
+      it 'inserts all objects' do
+        subject.insert([Thing.new, Thing.new])
+        expect(subject.fetch.count).to eq 2
+      end
+    end
+
+    context 'when objects are provided as many arguments' do
+      it 'inserts all objects' do
+        subject.insert(Thing.new, Thing.new)
+        expect(subject.fetch.count).to eq 2
+      end
+    end
+  end
+
+  describe 'save' do
+    let(:thing) { Thing.new }
+
+    context 'when a new object is given' do
+      it 'gets inserted' do
+        subject.save(thing)
+        expect(subject.find(thing.id)).not_to be_nil
+      end
+    end
+
+    context 'when an existent object is given' do
+      before { subject.insert(thing) }
+
+      it 'gets updated' do
+        thing.name = 'chair'
+        subject.save(thing)
+        expect(subject.find(thing.id).name).to eq 'chair'
+      end
+    end
+  end
+end

data/spec/shared/repository/timestampable.rb

@@ -0,0 +1,137 @@
+RSpec.shared_examples 'timestampable repository' do
+  let(:mapper) { mapper_klass.new(Thing).define_attribute(:name) }
+
+  subject { Rmodel::Repository.new(source, mapper) }
+
+  context 'when the entity object has timestamp attributes' do
+    before do
+      stub_const('Thing', Struct.new(:id, :name, :created_at, :updated_at))
+      mapper.define_attributes(:created_at, :updated_at)
+    end
+
+    context 'when we insert(object)' do
+      context 'and created_at is already set' do
+        let(:thing) { Thing.new(nil, 'chair', Time.now) }
+
+        it "doesn't change the value of created_at" do
+          set_created_at = thing.created_at
+          subject.insert(thing)
+          expect(thing.created_at).to eq set_created_at
+        end
+      end
+
+      context 'and created_at is not set yet' do
+        let(:thing) { Thing.new }
+
+        before { subject.insert(thing) }
+
+        it 'sets the value of created_at' do
+          expect(thing.created_at).not_to be_nil
+        end
+
+        it 'saves created_at in the database' do
+          expect(subject.find(thing.id).created_at).not_to be_nil
+        end
+      end
+    end
+
+    context 'when we update(object)' do
+      let(:thing) { Thing.new }
+
+      before do
+        subject.insert(thing)
+        thing.name = 'chair'
+        subject.update(thing)
+      end
+
+      it 'sets the value of updated_at' do
+        expect(thing.updated_at).not_to be_nil
+      end
+
+      it 'saves the updated_at in a database' do
+        expect(subject.find(thing.id).updated_at).not_to be_nil
+      end
+    end
+
+    context 'when the Time.current method exists' do
+      let(:thing) { Thing.new }
+
+      before do
+        stub_const 'Time', Time
+        def Time.current
+          now
+        end
+        allow(Time).to receive(:current)
+      end
+
+      context 'on insert' do
+        before { subject.insert(thing) }
+
+        it 'calls Time.current' do
+          expect(Time).to have_received(:current)
+        end
+      end
+
+      context 'on update' do
+        before do
+          subject.insert(thing)
+          subject.update(thing)
+        end
+
+        it 'calls Time.current' do
+          expect(Time).to have_received(:current).twice
+        end
+      end
+    end
+  end
+
+  context 'when the entity has no attributes created_at and updated_at' do
+    before { stub_const 'Thing', Struct.new(:id, :name) }
+
+    let(:thing) { Thing.new }
+
+    it "doesn't raise errors" do
+      expect do
+        subject.insert(thing)
+        thing.name = 'chair'
+        subject.update(thing)
+      end.not_to raise_error
+    end
+  end
+
+  context 'when the repo class is inherited' do
+    before do
+      stub_const('Thing', Struct.new(:id, :name, :created_at, :updated_at))
+      mapper.define_attributes(:created_at, :updated_at)
+      stub_const 'ThingRepository', Class.new(Rmodel::Repository)
+    end
+
+    subject { ThingRepository.new(source, mapper) }
+
+    context 'on insert' do
+      let(:thing) { Thing.new }
+
+      before { subject.insert(thing) }
+
+      it 'sets the created_at' do
+        found = subject.find(thing.id)
+        expect(found.created_at).not_to be_nil
+      end
+    end
+
+    context 'on update' do
+      let(:thing) { Thing.new }
+
+      before do
+        subject.insert(thing)
+        thing.name = 'chair'
+        subject.update(thing)
+      end
+
+      it 'sets the updated_at' do
+        found = subject.find(thing.id)
+        expect(found.updated_at).not_to be_nil
+      end
+    end
+  end
+end