rmodel 0.4.0.dev → 1.0.0

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

@@ -1,114 +0,0 @@
-RSpec.describe Rmodel::Sequel::Repository do
-  include_context 'clean sequel database'
-
-  before do
-    create_database
-    stub_const('Thing', Struct.new(:id, :a, :b))
-    stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
-  end
-
-  subject do
-    factory = Rmodel::Sequel::SimpleFactory.new(Thing, :a, :b)
-    ThingRepository.new(sequel_conn, :things, factory)
-  end
-
-  before do
-    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
-      before do
-        ThingRepository.class_eval do
-          scope :a_equals_2 do
-            where(a: 2)
-          end
-        end
-      end
-
-      it 'works!' do
-        expect(subject.query.a_equals_2.count).to eq 2
-      end
-
-      it 'returns an array of instances of the appropriate class' do
-        expect(subject.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(subject.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(subject.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 {
-          subject.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
-          subject.query.remove
-          expect(subject.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
-          subject.query.a_equals_2.remove
-          expect(subject.query.count).to eq 1
-        end
-      end
-    end
-  end
-
-  def create_database
-    sequel_conn.create_table(:things) do
-      primary_key :id
-      Integer :a
-      Integer :b
-    end
-  end
-end

data/spec/rmodel/sequel/repository_initialize_spec.rb

@@ -1,118 +0,0 @@
-RSpec.describe Rmodel::Sequel::Repository do
-  before do
-    stub_const('Thing', Struct.new(:id, :name))
-    stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
-    ThingRepository.send :attr_reader, :client, :table, :factory
-  end
-  let(:factory) { Rmodel::Sequel::SimpleFactory.new(Thing, :name) }
-
-  describe '.client(name)' do
-    conn_options = { adapter: 'sqlite', database: 'rmodel_test.sqlite3' }
-
-    subject { ThingRepository.new(nil, :things, factory) }
-
-    context 'when it is called with an existent name' do
-      before do
-        Rmodel.setup do
-          client :not_default, conn_options
-        end
-
-        ThingRepository.class_eval do
-          client :not_default
-        end
-      end
-      after { Rmodel::setup.clear }
-
-      it 'sets the appropriate #client' do
-        expect(subject.client).to be_a_kind_of Sequel::Database
-      end
-    end
-
-    context 'when it is called with a non-existent name' do
-      before do
-        ThingRepository.class_eval do
-          client :not_default
-        end
-      end
-
-      it 'makes #initialize raise the ArgumentError' do
-        expect { subject }.to raise_error ArgumentError
-      end
-    end
-
-    context 'when it is not called' do
-      context 'when the :default client is set' do
-        before do
-          Rmodel.setup do
-            client :default, conn_options
-          end
-        end
-        after { Rmodel::setup.clear }
-
-        it 'sets #client to be default' do
-          expect(subject.client).to be_a_kind_of Sequel::Database
-        end
-      end
-
-      context 'when the :default client is not set' do
-        it 'makes #initialize raise the ArgumentError' do
-          expect { subject }.to raise_error ArgumentError
-        end
-      end
-    end
-  end
-
-  describe '.table(name)' do
-    subject { ThingRepository.new(Object.new, nil, factory) }
-
-    context 'when the :people table is given' do
-      before do
-        ThingRepository.class_eval do
-          table :people
-        end
-      end
-
-      it 'uses the :people' do
-        expect(subject.table).to eq :people
-      end
-    end
-
-    context 'when no table is given' do
-      it 'gets the right name by convention' do
-        expect(subject.table).to eq :things
-      end
-    end
-  end
-
-  describe '.simple_factory(klass, attribute1, attribute2, ...)' do
-    subject { ThingRepository.new(Object.new, :things) }
-
-    context 'when it is called' do
-      before do
-        ThingRepository.class_eval do
-          simple_factory Thing, :name, :email
-        end
-      end
-
-      it 'sets the appropriate #factory' do
-        expect(subject.factory).to be_an_instance_of Rmodel::Sequel::SimpleFactory
-      end
-    end
-
-    context 'when it is not called' do
-      it 'make #initialize raise an error' do
-        expect { subject }.to raise_error ArgumentError
-      end
-    end
-  end
-
-  describe '#initialize(client, collection, factory)' do
-    context 'when all constructor arguments are passed' do
-      it 'works!' do
-        expect {
-          ThingRepository.new(Object.new, :users, factory)
-        }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/rmodel/sequel/simple_factory_spec.rb

@@ -1,55 +0,0 @@
-RSpec.describe Rmodel::Sequel::SimpleFactory do
-  context 'when the User(id, name, email) class is defined' do
-    before { stub_const('User', Struct.new(:id, :name, :email)) }
-
-    subject { described_class.new(User, :name, :email) }
-
-    describe '#fromHash' do
-      context 'when the hash with id, name and email is given' do
-        let(:hash) { { id: 1, name: 'John', email: 'john@example.com' } }
-        let(:result) { subject.fromHash(hash) }
-
-        it 'returns an instance of User' do
-          expect(result).to be_an_instance_of User
-        end
-
-        it 'sets the attributes correctly' do
-          expect(result.name).to eq 'John'
-          expect(result.email).to eq 'john@example.com'
-        end
-
-        it 'sets the User#id correctly' do
-          expect(result.id).to eq 1
-        end
-      end
-    end
-
-    describe '#toHash' do
-      let(:user) { User.new(1, 'John', 'john@example.com') }
-      context 'when id_included is false' do
-        let(:result) { subject.toHash(user, 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 'John'
-          expect(result[:email]).to eq 'john@example.com'
-        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(user, true) }
-
-        it 'sets the "id" key' do
-          expect(result[:id]).to eq 1
-        end
-      end
-    end
-  end
-end

data/spec/rmodel/setup_spec.rb

@@ -1,54 +0,0 @@
-RSpec.describe Rmodel do
-  describe '.setup' do
-    before { Rmodel::Setup.instance.clear }
-    context 'when no block is passed' do
-      it 'returns Rmodel::Setup.instance' do
-        expect(Rmodel.setup).to equal Rmodel::Setup.instance
-      end
-    end
-
-    context 'when the block is passed' do
-      let(:clients_config) { Rmodel::Setup.instance.instance_variable_get('@clients_config') }
-
-      it 'returns Rmodel::Setup.instance' do
-        expect(Rmodel.setup).to equal Rmodel::Setup.instance
-      end
-
-      it 'runs setup methods within the block' do
-        Rmodel.setup do
-          client :default, {}
-        end
-        expect(clients_config[:default]).to eq({})
-      end
-    end
-  end
-
-  describe Rmodel::Setup do
-    subject { Rmodel::Setup.instance }
-    let(:clients_config) { subject.instance_variable_get('@clients_config') }
-
-    describe '#new' do
-      it 'raises the NoMethodError' do
-        expect { Rmodel::Setup.new }.to raise_error NoMethodError
-      end
-    end
-
-    describe '#client(name, config)' do
-      it 'makes config available via #clients[name]' do
-        subject.client :default, { host: 'localhost' }
-        expect(clients_config[:default]).to eq( host: 'localhost' )
-      end
-    end
-
-    describe '#clear' do
-      context 'when one client is set' do
-        before { subject.client :default, { host: 'localhost' } }
-
-        it 'removes all clients' do
-          subject.clear
-          expect(clients_config).to be_empty
-        end
-      end
-    end
-  end
-end

data/spec/shared/repository_ext/sugarable.rb

@@ -1,44 +0,0 @@
-RSpec.shared_examples 'sugarable repository' do
-  before do
-    stub_const('Thing', Struct.new(:id, :name))
-  end
-
-  describe '#find!' 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 '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_ext/timestampable.rb

@@ -1,67 +0,0 @@
-RSpec.shared_examples 'timestampable repository' do
-  context 'when the entity object has attributes created_at and updated_at' do
-    before do
-      stub_const('Thing', Struct.new(:id, :name, :created_at, :updated_at))
-    end
-
-    subject { repo_w_timestamps }
-
-    context 'when we insert(object)' do
-      context 'and the object.created_at is already set' do
-        let(:thing) { Thing.new(nil, 'chair', Time.now) }
-
-        it 'doesnt 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 the object.created_at is not set yet' do
-        let(:thing) { Thing.new(nil, 'chair') }
-
-        it 'sets the value of created_at' do
-          subject.insert(thing)
-          expect(thing.created_at).not_to be_nil
-        end
-      end
-    end
-
-    context 'when we update(object)' do
-      let(:thing) { Thing.new(nil, 'chair') }
-      before { subject.insert(thing) }
-
-      it 'sets the value of created_at' do
-        thing.name = 'table'
-        subject.update(thing)
-        expect(thing.updated_at).not_to be_nil
-      end
-    end
-  end
-
-  context 'when the entity has no attributes :created_at and updated_at' do
-    before do
-      stub_const('Thing', Struct.new(:id, :name))
-    end
-
-    let(:thing) { Thing.new(nil, 'chair') }
-    subject { repo_wo_timestamps }
-
-    context 'when we insert(object)' do
-      it 'does nothing special' do
-        subject.insert(thing)
-        expect(thing.respond_to?(:created_at)).to be false
-      end
-    end
-
-    context 'when we update(object)' do
-      before { subject.insert(thing) }
-
-      it 'does nothing special' do
-        thing.name = 'table'
-        subject.update(thing)
-        expect(thing.respond_to?(:updated_at)).to be false
-      end
-    end
-  end
-end