zyra 0.0.2 → 1.0.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

@@ -6,100 +6,14 @@ describe Zyra::Registry do
   let(:registry) { described_class.new }
 
   describe '#register' do
-    context 'when providing symbol alias' do
-      let(:key) { :user_alias }
-
-      it 'creates a builder for the given class' do
-        expect(registry.register(User, key))
-          .to eq(Zyra::Builder.new(User))
-      end
-
-      it 'register builder under the key' do
-        expect { registry.register(User, key) }
-          .to change { registry.builder_for(key) }
-          .from(nil).to(Zyra::Builder.new(User))
-      end
-    end
-
-    context 'when providing string alias' do
-      let(:key) { 'user' }
-
-      it 'creates a builder for the given class' do
-        expect(registry.register(User, key))
-          .to eq(Zyra::Builder.new(User))
-      end
-
-      it 'register builder under the key' do
-        expect { registry.register(User, key) }
-          .to change { registry.builder_for(key) }
-          .from(nil).to(Zyra::Builder.new(User))
-      end
-    end
-
-    context 'when not providing an alias' do
-      let(:key) { :user }
-
-      it 'creates a builder for the given class' do
-        expect(registry.register(User))
-          .to eq(Zyra::Builder.new(User))
-      end
-
-      it 'register builder under the correct key' do
-        expect { registry.register(User) }
-          .to change { registry.builder_for(key) }
-          .from(nil).to(Zyra::Builder.new(User))
-      end
-    end
+    it_behaves_like 'a method that registers a finder creator'
   end
 
-  describe '#builder_for' do
-    let(:key) { :user }
-
-    context 'when there is no builder registered' do
-      it do
-        expect(registry.builder_for(key))
-          .to be_nil
-      end
-    end
-
-    context 'when there is no builder registered on a symbol key' do
-      before do
-        registry.register(User, :user)
-      end
-
-      it do
-        expect(registry.builder_for(key))
-          .to eq(Zyra::Builder.new(User))
-      end
-
-      context 'when passing a string key' do
-        let(:key) { 'user' }
-
-        it do
-          expect(registry.builder_for(key))
-            .to eq(Zyra::Builder.new(User))
-        end
-      end
-    end
-
-    context 'when there is no builder registered on a string key' do
-      before do
-        registry.register(User, 'user')
-      end
-
-      it do
-        expect(registry.builder_for(key))
-          .to eq(Zyra::Builder.new(User))
-      end
-
-      context 'when passing a string key' do
-        let(:key) { 'user' }
+  describe '#on' do
+    it_behaves_like 'a method that registers an event handler'
+  end
 
-        it do
-          expect(registry.builder_for(key))
-            .to eq(Zyra::Builder.new(User))
-        end
-      end
-    end
+  describe '#find_or_create' do
+    it_behaves_like 'a method that returns or create a model'
   end
 end