zyra 0.0.1 → 1.1.0

data/spec/integration/yard/zyra_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zyra do
+  describe 'yard' do
+    describe '.register' do
+      it 'Register models searching' do
+        Zyra.register(User, find_by: :email)
+        Zyra
+          .register(User, :user_by_name, find_by: :name)
+          .on(:return) do |user|
+            user.update(email: "#{user.name.gsub(/ /, '_')}@srv.com")
+          end
+
+        attributes = {
+          name: 'my name',
+          email: 'my_email@srv.com'
+        }
+
+        user = Zyra.find_or_create(:user, attributes)
+        expect(user.email).to eq('my_email@srv.com')
+
+        user = Zyra.find_or_create(:user_by_name, attributes)
+        expect(user.email).to eq('my_name@srv.com')
+      end
+    end
+
+    describe '.find_or_create' do
+      it 'Regular usage passing all attributes' do
+        Zyra.register(User, find_by: :email)
+
+        email = 'email@srv.com'
+
+        user = Zyra.find_or_create(
+          :user,
+          email: email, name: 'initial name'
+        )
+
+        expect(user.name).to eq('initial name')
+
+        user = Zyra.find_or_create(
+          :user,
+          email: email, name: 'final name'
+        )
+
+        expect(user.name).to eq('initial name')
+      end
+    end
+
+    describe '.on' do
+      it 'Adding a hook on return' do
+        Zyra.register(User, find_by: :email)
+        Zyra.on(:user, :return) do |user|
+          user.update(name: 'initial name')
+        end
+
+        email = 'email@srv.com'
+
+        user = Zyra.find_or_create(
+          :user,
+          email: email
+        )
+
+        expect(user.name).to eq('initial name')
+        user.update(name: 'some other name')
+
+        user = Zyra.find_or_create(:user, email: email)
+
+        expect(user.name).to eq('initial name')
+      end
+
+      it 'Adding a hook on found' do
+        Zyra.register(User, find_by: :email)
+        Zyra.on(:user, :found) do |user|
+          user.update(name: 'final name')
+        end
+
+        email = 'email@srv.com'
+        attributes = { email: email, name: 'initial name' }
+
+        user = Zyra.find_or_create(:user, attributes)
+
+        expect(user.name).to eq('initial name')
+
+        user = Zyra.find_or_create(:user, attributes)
+
+        expect(user.name).to eq('final name')
+      end
+
+      it 'Adding a hook on build' do
+        Zyra.register(User, find_by: :email)
+        Zyra.on(:user, :build) do |user|
+          user.name = 'initial name'
+        end
+
+        email = 'email@srv.com'
+
+        user = Zyra.find_or_create(:user, email: email)
+
+        expect(user.name).to eq('initial name')
+        user.update(name: 'some other name')
+
+        user = Zyra.find_or_create(:user, email: email)
+
+        expect(user.name).to eq('some other name')
+      end
+
+      it 'Adding a hook on create' do
+        Zyra.register(User, find_by: :email)
+        Zyra.on(:user, :create) do |user|
+          user.update(name: 'initial name')
+        end
+
+        email = 'email@srv.com'
+
+        user = Zyra.find_or_create(:user, email: email)
+
+        expect(user.name).to eq('initial name')
+        user.update(name: 'some other name')
+
+        user = Zyra.find_or_create(:user, email: email)
+
+        expect(user.name).to eq('some other name')
+      end
+    end
+  end
+end

data/spec/lib/zyra/creator_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zyra::Creator do
+  subject(:creator) do
+    described_class.new(model_class, event_registry: event_registry)
+  end
+
+  let(:event_registry) { Jace::Registry.new }
+  let(:model_class)    { User }
+
+  describe '#create' do
+    it do
+      expect(creator.create).to be_a(model_class)
+    end
+
+    it do
+      expect(creator.create)
+        .to be_persisted
+    end
+
+    context 'when attributes are given' do
+      let(:name) { SecureRandom.hex(10) }
+
+      it 'initializes the model with the given attribute' do
+        expect(creator.create(name: name).name)
+          .to eq(name)
+      end
+    end
+
+    context 'when a block is given' do
+      let(:name) { SecureRandom.hex(10) }
+
+      it 'initializes the model with the given attribute' do
+        value = name
+        expect(creator.create { |model| model.name = value }.name)
+          .to eq(name)
+      end
+    end
+
+    context 'when building has an after build handler' do
+      let(:name) { SecureRandom.hex(10) }
+
+      before do
+        value = name
+        event_registry.register(:build) do |model|
+          model.name = "#{value}#{model.id}"
+        end
+      end
+
+      it 'runs the event handler' do
+        expect(creator.create.name)
+          .to eq(name)
+      end
+    end
+
+    context 'when building has an after create handler' do
+      let(:name) { SecureRandom.hex(10) }
+
+      before do
+        value = name
+        event_registry.register(:create) do |model|
+          model.name = "#{value}#{model.id}"
+        end
+      end
+
+      it 'runs the event handler' do
+        model = creator.create
+        expect(model.name)
+          .to eq("#{name}#{model.id}")
+      end
+    end
+  end
+end

data/spec/lib/zyra/finder_creator_spec.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zyra::FinderCreator do
+  subject(:finder) do
+    described_class.new(model_class, keys)
+  end
+
+  let(:event_registry) { Jace::Registry.new }
+  let(:model_class)    { User }
+  let(:keys)           { :email }
+  let(:email)          { SecureRandom.hex(10) }
+
+  describe '#find_or_create' do
+    let(:attributes) do
+      {
+        name: 'Some Name',
+        email: email,
+        password: 'SomePassword'
+      }
+    end
+
+    context 'when there is no entry in the database' do
+      it do
+        expect(finder.find_or_create(attributes)).to be_a(model_class)
+      end
+
+      it do
+        expect { finder.find_or_create(attributes) }
+          .to change(model_class, :count)
+      end
+
+      context 'when a block is given' do
+        it 'runs the block' do
+          user = finder.find_or_create(attributes) do |u|
+            u.update(name: 'new name')
+          end
+
+          expect(user.name).to eq('new name')
+        end
+      end
+    end
+
+    context 'when there is an entry and a block is given' do
+      before { create(:user, **attributes) }
+
+      it 'runs the block' do
+        user = finder.find_or_create(attributes) do |u|
+          u.update(name: 'new name')
+        end
+
+        expect(user.name).to eq('new name')
+      end
+    end
+
+    context 'when the entry is there with the same attributes' do
+      let!(:user) { create(:user, **attributes) }
+
+      it 'returns the user' do
+        expect(finder.find_or_create(attributes)).to eq(user)
+      end
+    end
+
+    context 'when the entry is there with other attributes' do
+      let!(:user) { create(:user, email: email) }
+
+      it 'returns the user' do
+        expect(finder.find_or_create(attributes)).to eq(user)
+      end
+    end
+
+    context 'when there is another entry' do
+      before { create(:user) }
+
+      it 'returns a new model' do
+        expect(finder.find_or_create(attributes)).to be_a(model_class)
+      end
+
+      it do
+        expect { finder.find_or_create(attributes) }
+          .to change(model_class, :count)
+      end
+    end
+
+    context 'when the keys is set as string' do
+      let(:keys)  { 'email' }
+      let!(:user) { create(:user, **attributes) }
+
+      it 'finds the user the same way' do
+        expect(finder.find_or_create(attributes)).to eq(user)
+      end
+    end
+
+    context 'when the attributes have string keys' do
+      let(:attributes) { { 'email' => email } }
+      let!(:user)      { create(:user, **attributes) }
+
+      it 'finds the user the same way' do
+        expect(finder.find_or_create(attributes)).to eq(user)
+      end
+    end
+
+    context 'when there is an event handler on found' do
+      let(:name) { 'new_name' }
+
+      before do
+        new_name = name
+
+        finder.on(:found) do |model|
+          model.update(name: new_name)
+        end
+      end
+
+      context 'when the model is found' do
+        let!(:user) { create(:user, **attributes) }
+
+        it 'runs the event after the model was found' do
+          expect { finder.find_or_create(attributes) }
+            .to change { user.reload.name }
+            .to(name)
+        end
+
+        it do
+          expect { finder.find_or_create(attributes) }
+            .not_to change(model_class, :count)
+        end
+      end
+
+      context 'when the model is not found' do
+        it 'does not run the event after the model was found' do
+          expect(finder.find_or_create(attributes).name)
+            .not_to eq(name)
+        end
+
+        it do
+          expect(finder.find_or_create(attributes)).to be_a(model_class)
+        end
+
+        it do
+          expect { finder.find_or_create(attributes) }
+            .to change(model_class, :count)
+        end
+      end
+    end
+
+    context 'when there is an event handler on build' do
+      let(:name) { 'new_name' }
+
+      before do
+        new_name = name
+
+        finder.on(:build) do |model|
+          model.name = new_name
+        end
+      end
+
+      context 'when the model is found' do
+        let!(:user) { create(:user, **attributes) }
+
+        it 'does not run the event after the model was found' do
+          expect { finder.find_or_create(attributes) }
+            .not_to change { user.reload.name }
+        end
+      end
+
+      context 'when the model is not found' do
+        it 'runs the event after the model was build' do
+          expect(finder.find_or_create(attributes).reload.name)
+            .to eq(name)
+        end
+
+        it do
+          expect(finder.find_or_create(attributes)).to be_a(model_class)
+        end
+
+        it do
+          expect { finder.find_or_create(attributes) }
+            .to change(model_class, :count)
+        end
+      end
+    end
+
+    context 'when there is an event handler on create' do
+      let(:name) { 'new_name' }
+
+      before do
+        new_name = name
+
+        finder.on(:create) do |model|
+          model.name = new_name
+        end
+      end
+
+      context 'when the model is found' do
+        before { create(:user, **attributes) }
+
+        it 'does not run the event after the model was found' do
+          expect(finder.find_or_create(attributes).name)
+            .not_to eq(name)
+        end
+      end
+
+      context 'when the model is not found' do
+        it 'runs the event after the model was created' do
+          expect(finder.find_or_create(attributes).name)
+            .to eq(name)
+        end
+
+        it 'does not run the event after the model was build' do
+          expect(finder.find_or_create(attributes).reload.name)
+            .not_to eq(name)
+        end
+
+        it do
+          expect(finder.find_or_create(attributes)).to be_a(model_class)
+        end
+
+        it do
+          expect { finder.find_or_create(attributes) }
+            .to change(model_class, :count)
+        end
+      end
+    end
+
+    context 'when there is an event handler on return' do
+      let(:name) { 'new_name' }
+
+      before do
+        new_name = name
+
+        finder.on(:return) do |model|
+          model.update(name: new_name)
+        end
+      end
+
+      context 'when the model is found' do
+        let!(:user) { create(:user, **attributes) }
+
+        it 'does not run the event after the model was found' do
+          expect { finder.find_or_create(attributes) }
+            .to change { user.reload.name }
+        end
+      end
+
+      context 'when the model is not found' do
+        it 'runs the event after the model was returned' do
+          expect(finder.find_or_create(attributes).reload.name)
+            .to eq(name)
+        end
+
+        it do
+          expect(finder.find_or_create(attributes)).to be_a(model_class)
+        end
+
+        it do
+          expect { finder.find_or_create(attributes) }
+            .to change(model_class, :count)
+        end
+      end
+    end
+  end
+end

data/spec/lib/zyra/finder_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zyra::Finder do
+  subject(:finder) do
+    described_class.new(model_class, keys, event_registry: event_registry)
+  end
+
+  let(:event_registry) { Jace::Registry.new }
+  let(:model_class)    { User }
+  let(:keys)           { :email }
+  let(:email)          { SecureRandom.hex(10) }
+
+  describe '#find' do
+    let(:attributes) do
+      {
+        name: 'Some Name',
+        email: email,
+        password: 'SomePassword'
+      }
+    end
+
+    context 'when there is no entry in the database' do
+      it do
+        expect(finder.find(attributes)).to be_nil
+      end
+
+      context 'when a block is given' do
+        it do
+          user = finder.find(attributes) { |u| u.name = 'other' }
+          expect(user).to be_nil
+        end
+      end
+    end
+
+    context 'when the model is found and a block is given' do
+      let!(:user) { create(:user, **attributes) }
+
+      it 'runs the block' do
+        expect { finder.find(attributes) { |u| u.update(name: 'other') } }
+          .to change { user.reload.name }
+          .to('other')
+      end
+    end
+
+    context 'when the entry is there with the same attributes' do
+      let!(:user) { create(:user, **attributes) }
+
+      it 'returns the user' do
+        expect(finder.find(attributes)).to eq(user)
+      end
+    end
+
+    context 'when the entry is there with other attributes' do
+      let!(:user) { create(:user, email: email) }
+
+      it 'returns the user' do
+        expect(finder.find(attributes)).to eq(user)
+      end
+    end
+
+    context 'when there is another entry' do
+      before { create(:user) }
+
+      it 'returns the user' do
+        expect(finder.find(attributes)).to be_nil
+      end
+    end
+
+    context 'when the keys is set as string' do
+      let(:keys)  { 'email' }
+      let!(:user) { create(:user, **attributes) }
+
+      it 'finds the user the same way' do
+        expect(finder.find(attributes)).to eq(user)
+      end
+    end
+
+    context 'when the attributes have string keys' do
+      let(:attributes) { { 'email' => email } }
+      let!(:user)      { create(:user, **attributes) }
+
+      it 'finds the user the same way' do
+        expect(finder.find(attributes)).to eq(user)
+      end
+    end
+
+    context 'when there is an event handler' do
+      let(:name) { 'new_name' }
+
+      before do
+        new_name = name
+
+        event_registry.register(:found) do |model|
+          model.update(name: new_name)
+        end
+      end
+
+      context 'when the model is found' do
+        let!(:user) { create(:user, **attributes) }
+
+        it 'runs the event after the model was found' do
+          expect { finder.find(attributes) }
+            .to change { user.reload.name }
+            .to(name)
+        end
+      end
+
+      context 'when the model is not found' do
+        it do
+          expect(finder.find(attributes)).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/lib/zyra/registry_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Zyra::Registry do
+  let(:registry) { described_class.new }
+
+  describe '#register' do
+    it_behaves_like 'a method that registers a finder creator'
+  end
+
+  describe '#on' do
+    it_behaves_like 'a method that registers an event handler'
+  end
+
+  describe '#find_or_create' do
+    it_behaves_like 'a method that returns or create a model'
+  end
+end

data/spec/lib/zyra_spec.rb

@@ -3,6 +3,19 @@
 require 'spec_helper'
 
 describe Zyra do
-  it 'does something' do
+  let(:registry) { described_class }
+
+  before { described_class.reset }
+
+  describe '.register' do
+    it_behaves_like 'a method that registers a finder creator'
+  end
+
+  describe '.on' do
+    it_behaves_like 'a method that registers an event handler'
+  end
+
+  describe '.find_or_create' do
+    it_behaves_like 'a method that returns or create a model'
   end
 end

data/spec/spec_helper.rb

@@ -10,6 +10,13 @@ SimpleCov.start 'gem'
 
 require 'zyra'
 require 'pry-nav'
+require 'factory_bot'
+require 'database_cleaner'
+
+require 'active_record'
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3', database: ':memory:'
+)
 
 support_files = File.expand_path('spec/support/**/*.rb')
 
@@ -21,6 +28,17 @@ RSpec.configure do |config|
   config.filter_run_excluding :integration unless ENV['ALL']
 
   config.order = 'random'
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
 end
 
 RSpec::Matchers.define_negated_matcher :not_change, :change

data/spec/support/factories/user.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :user, class: '::User' do
+    sequence(:name)  { |n| "Name-#{n}" }
+    sequence(:email) { |n| "user-#{n}@email.com" }
+    password         { SecureRandom.hex(10) }
+  end
+end

data/spec/support/factory_bot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+end
+
+FactoryBot.find_definitions

data/spec/support/models/post.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+end

data/spec/support/models/user.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class User < ActiveRecord::Base
+  has_many :posts
+end

data/spec/support/schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :users, force: true do |t|
+    t.string :name
+    t.string :email
+    t.string :password
+    t.string :reference
+  end
+
+  create_table :posts, force: true do |t|
+    t.integer :user_id
+    t.string :name
+    t.text :content
+  end
+end