rmodel 0.4.0.dev → 1.0.0

data/spec/rmodel/mongo/repository_ext/queryable_spec.rb

@@ -1,103 +0,0 @@
-RSpec.describe Rmodel::Mongo::Repository do
-  include_context 'clean mongo database'
-
-  before do
-    stub_const('Thing', Struct.new(:id, :a, :b))
-    stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
-  end
-
-  let(:factory) { Rmodel::Mongo::SimpleFactory.new(Thing, :a, :b) }
-  let(:repo) { ThingRepository.new(mongo_session, :things, factory) }
-
-  before do
-    repo.insert(Thing.new(nil, 2, 3))
-    repo.insert(Thing.new(nil, 2, 4))
-    repo.insert(Thing.new(nil, 5, 6))
-  end
-
-  describe '.scope' do
-    context 'when a scope w/o arguments is defined' do
-      before do
-        ThingRepository.class_eval do
-          scope :a_equals_2 do
-            where(a: 2)
-          end
-        end
-      end
-
-      it 'works!' do
-        expect(repo.query.a_equals_2.count).to eq 2
-      end
-
-      it 'returns an array of instances of the appropriate class' do
-        expect(repo.query.a_equals_2.first).to be_an_instance_of Thing
-      end
-    end
-
-    context 'when a scope w/ arguments is defined' do
-      before do
-        ThingRepository.class_eval do
-          scope :a_equals do |n|
-            where(a: n)
-          end
-        end
-      end
-
-      it 'works!' do
-        expect(repo.query.a_equals(2).count).to eq 2
-      end
-    end
-
-    context 'when two scopes are defined and chained' do
-      before do
-        ThingRepository.class_eval do
-          scope :a_equals do |n|
-            where(a: n)
-          end
-
-          scope :b_equals do |n|
-            where(b: n)
-          end
-        end
-      end
-
-      it 'works!' do
-        expect(repo.query.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 {
-          repo.query.something
-        }.to raise_error NoMethodError
-      end
-    end
-  end
-
-  describe '.query' do
-    describe '#remove' do
-      context 'when no scope is given' do
-        it 'removes all objects' do
-          repo.query.remove
-          expect(repo.query.count).to eq 0
-        end
-      end
-
-      context 'when the scope filters 2 objects from 3' do
-        before do
-          ThingRepository.class_eval do
-            scope :a_equals_2 do
-              where(a: 2)
-            end
-          end
-        end
-
-        it 'removes 2 objects' do
-          repo.query.a_equals_2.remove
-          expect(repo.query.count).to eq 1
-        end
-      end
-    end
-  end
-end

data/spec/rmodel/mongo/repository_initialize_spec.rb

@@ -1,174 +0,0 @@
-RSpec.describe Rmodel::Mongo::Repository do
-  before do
-    Mongo::Logger.logger.level = Logger::ERROR
-    stub_const('User', Struct.new(:id, :name, :email))
-  end
-
-  describe '.client(name)' do
-    subject { UserRepository.new }
-
-    before { Rmodel::Setup.send :public, :client }
-
-    context 'when it is called with an existent name' do
-      before do
-        Rmodel.setup do
-          client :mongo, { hosts: [ 'localhost' ] }
-        end
-
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
-          client :mongo
-          simple_factory User, :name, :email
-          attr_reader :client
-        })
-      end
-      after { Rmodel::setup.clear }
-
-      it 'sets the appropriate #client' do
-        expect(subject.client).to be_an_instance_of Mongo::Client
-      end
-    end
-
-    context 'when it is called with a non-existent name' do
-      before do
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
-          client :mongo
-          simple_factory User, :name, :email
-          attr_reader :client
-        })
-      end
-
-      it 'makes #client raise the ArgumentError' do
-        expect { subject.client }.to raise_error ArgumentError
-      end
-    end
-
-    context 'when it is not called' do
-      before do
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
-          simple_factory User, :name, :email
-          attr_reader :client
-        })
-      end
-
-      context 'when the :default client is set' do
-        before do
-          Rmodel.setup do
-            client :default, { hosts: [ 'localhost' ] }
-          end
-        end
-        after { Rmodel::setup.clear }
-
-        it 'sets #client to be default' do
-          expect(subject.client).to be_an_instance_of Mongo::Client
-        end
-      end
-
-      context 'when the :default client is not set' do
-        it 'makes #client raise the ArgumentError' do
-          expect { subject.client }.to raise_error ArgumentError
-        end
-      end
-    end
-  end
-
-  describe '.collection(name)' do
-    subject { UserRepository.new }
-
-    before do
-      Rmodel.setup do
-        client :default, { hosts: [ 'localhost' ] }
-      end
-    end
-    after { Rmodel::setup.clear }
-
-    context 'when the :people collection is given' do
-      before do
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
-          collection :people
-          simple_factory User, :name, :email
-          attr_reader :collection
-        })
-      end
-
-      it 'uses the :people' do
-        expect(subject.collection).to eq :people
-      end
-    end
-
-    context 'when no collection is given' do
-      before do
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
-          simple_factory User, :name, :email
-          attr_reader :collection
-        })
-      end
-
-      it 'gets the right name by convention' do
-        expect(subject.collection).to eq :users
-      end
-    end
-  end
-
-  describe '.simple_factory(klass, attribute1, attribute2, ..., &block)' do
-    subject { UserRepository.new }
-
-    before do
-      Rmodel.setup do
-        client :default, { hosts: [ 'localhost' ] }
-      end
-    end
-    after { Rmodel::setup.clear }
-
-    context 'when it is called' do
-      before do
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
-          simple_factory User, :name, :email
-          attr_reader :factory
-        })
-      end
-
-      it 'sets the appropriate #factory' do
-        expect(subject.factory).to be_an_instance_of Rmodel::Mongo::SimpleFactory
-      end
-    end
-
-    context 'when it is not called' do
-      before do
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository))
-      end
-
-      it 'make #initialize raise an error' do
-        expect {
-          UserRepository.new
-        }.to raise_error ArgumentError
-      end
-    end
-
-    context 'when a block is given' do
-      it 'evaluates the block within the context of the factory' do
-        tmp = nil
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
-          simple_factory User, :name, :email do
-            tmp = self
-          end
-        })
-        expect(tmp).to be_an_instance_of Rmodel::Mongo::SimpleFactory
-      end
-    end
-  end
-
-  describe '#initialize(client, collection, factory)' do
-    context 'when all constructor arguments are passed' do
-      before do
-        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository))
-      end
-      let(:factory) { Rmodel::Mongo::SimpleFactory.new(User, :name, :email) }
-
-      it 'works!' do
-        expect {
-          UserRepository.new(Object.new, :users, factory)
-        }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/rmodel/mongo/simple_factory_spec.rb

@@ -1,195 +0,0 @@
-RSpec.describe Rmodel::Mongo::SimpleFactory do
-  context 'when the Thing(id, name, price, parts, owner) class is defined' do
-    before do
-      stub_const('Thing', Struct.new(:id, :name, :price, :parts, :owner))
-      stub_const('Part', Struct.new(:id, :name, :producer))
-      stub_const('Producer', Struct.new(:id, :country))
-      stub_const('Owner', Struct.new(:id, :full_name, :phones))
-      stub_const('Phone', Struct.new(:id, :number))
-    end
-
-    subject do
-      described_class.new(Thing, :name, :price) do
-        embeds_many :parts, simple_factory(Part, :name) do
-          embeds_one :producer, simple_factory(Producer, :country)
-        end
-        embeds_one :owner, simple_factory(Owner, :full_name) do
-          embeds_many :phones, simple_factory(Phone, :number)
-        end
-      end
-    end
-
-    describe '#fromHash(hash)' do
-      let(:result) { subject.fromHash(hash) }
-
-      context 'when the hash with _id, name and price is given' do
-        let(:hash) { { '_id' => 1, 'name' => 'chair', 'price' => 100 } }
-
-        it 'returns an instance of Thing' do
-          expect(result).to be_an_instance_of Thing
-        end
-
-        it 'sets the attributes correctly' do
-          expect(result.name).to eq 'chair'
-          expect(result.price).to eq 100
-        end
-
-        it 'sets the Thing#id correctly' do
-          expect(result.id).to eq 1
-        end
-
-        it 'leaves <many embedded> nil' do
-          expect(result.parts).to be_nil
-        end
-
-        it 'leaves <one embedded> nil' do
-          expect(result.owner).to be_nil
-        end
-      end
-
-      context 'when the hash contains many parts' do
-        let(:hash) do
-          {
-            'parts' => [
-              { '_id' => 1, 'name' => 'back', 'producer' => { '_id' => 10, 'country' => 'UK' } },
-              { '_id' => 2, 'name' => 'leg' }
-            ]
-          }
-        end
-
-        it 'maps subdocuments to <many embedded>' do
-          expect(result.parts.length).to eq 2
-
-          expect(result.parts[0]).to be_an_instance_of Part
-          expect(result.parts[0].id).to eq 1
-          expect(result.parts[0].name).to eq 'back'
-
-          expect(result.parts[0].producer).to be_an_instance_of Producer
-          expect(result.parts[0].producer.id).to eq 10
-          expect(result.parts[0].producer.country).to eq 'UK'
-
-          expect(result.parts[1]).to be_an_instance_of Part
-          expect(result.parts[1].id).to eq 2
-          expect(result.parts[1].name).to eq 'leg'
-          expect(result.parts[1].producer).to be_nil
-        end
-      end
-
-      context 'when the hash contains one owner' do
-        let(:hash) do
-          {
-            'owner' => {
-              '_id' => 3,
-              'full_name' => 'John Doe',
-              'phones' => [
-                { '_id' => 20, 'number' => '+1111111111' },
-                { '_id' => 21, 'number' => '+2222222222' }
-              ]
-            }
-           }
-        end
-
-        it 'maps subdocument to <one embedded>' do
-          expect(result.owner).to be_an_instance_of Owner
-          expect(result.owner.id).to eq 3
-          expect(result.owner.full_name).to eq 'John Doe'
-
-          expect(result.owner.phones.length).to eq 2
-
-          expect(result.owner.phones[0].id).to eq 20
-          expect(result.owner.phones[0].number).to eq '+1111111111'
-
-          expect(result.owner.phones[1].id).to eq 21
-          expect(result.owner.phones[1].number).to eq '+2222222222'
-        end
-      end
-    end
-
-    describe '#toHash(object, id_included)' do
-      let(:thing) { Thing.new(1, 'chair', 100) }
-
-      context 'when id_included is false' do
-        let(:result) { subject.toHash(thing, false) }
-
-        it 'returns an instance of Hash' do
-          expect(result).to be_an_instance_of Hash
-        end
-
-        it 'sets the keys correctly' do
-          expect(result['name']).to eq 'chair'
-          expect(result['price']).to eq 100
-        end
-
-        it 'has no the "_id" key' do
-          expect(result.has_key?('_id')).to be false
-        end
-      end
-
-      context 'when id_included is true' do
-        let(:result) { subject.toHash(thing, true) }
-
-        it 'sets the "_id" key' do
-          expect(result['_id']).to eq 1
-        end
-      end
-
-      context 'when the object has <many embedded>' do
-        let(:thing) do
-          Thing.new(1, 'chair', 100, [
-            Part.new(1, 'back', Producer.new(10, 'UK')),
-            Part.new(2, 'leg')
-          ])
-        end
-        let(:result) { subject.toHash(thing, true) }
-
-        it 'maps <many embedded> to subdocuments' do
-          expect(result['parts'].length).to eq 2
-
-          expect(result['parts'][0]['_id']).to eq 1
-          expect(result['parts'][0]['name']).to eq 'back'
-
-          expect(result['parts'][0]['producer']['_id']).to eq 10
-          expect(result['parts'][0]['producer']['country']).to eq 'UK'
-
-          expect(result['parts'][1]['_id']).to eq 2
-          expect(result['parts'][1]['name']).to eq 'leg'
-        end
-      end
-
-      context 'when the object has <one embedded>' do
-        let(:thing) do
-          Thing.new(1, 'chair', 100, nil, Owner.new(3, 'John Doe', [
-            Phone.new(20, '+1111111111'),
-            Phone.new(21, '+2222222222')
-          ]))
-        end
-        let(:result) { subject.toHash(thing, true) }
-
-        it 'maps <one embedded> to the subdocument' do
-          expect(result['owner']['_id']).to eq 3
-          expect(result['owner']['full_name']).to eq 'John Doe'
-
-          expect(result['owner']['phones'].length).to eq 2
-
-          expect(result['owner']['phones'][0]['_id']).to eq 20
-          expect(result['owner']['phones'][0]['number']).to eq '+1111111111'
-
-          expect(result['owner']['phones'][1]['_id']).to eq 21
-          expect(result['owner']['phones'][1]['number']).to eq '+2222222222'
-        end
-      end
-    end
-
-    describe '#initialize(..., &block)' do
-      context 'when a block is given' do
-        it 'passes self to the block' do
-          tmp = nil
-          factory = described_class.new(Thing, :name) do
-            tmp = self
-          end
-          expect(tmp).to be factory
-        end
-      end
-    end
-  end
-end