aspector 0.13.1 → 0.14.0

data/spec/units/advices/raw_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+RSpec.describe 'Raw advices' do
+  subject { klass.new }
+
+  context 'standard case' do
+    let(:klass) do
+      ClassBuilder.build do
+        def before_exec
+          values << 'before_exec'
+        end
+      end
+    end
+
+    before do
+      aspector(klass) do
+        raw :exec do
+          alias_method :exec_without_aspect, :exec
+
+          def exec
+            values << 'exec-result'
+            exec_without_aspect
+          end
+        end
+      end
+    end
+
+    it 'should execute exec_without_aspect' do
+      expect(subject)
+        .to receive(:exec_without_aspect)
+        .once
+
+      subject.exec
+    end
+
+    it 'should work' do
+      subject.exec
+      expect(subject.values).to eq %w( exec-result exec-result )
+    end
+  end
+
+  context 'when we want to use method that is defined after aspector binding' do
+    let(:klass) do
+      ClassBuilder.build do
+        aspector do
+          raw :exec do
+            alias_method :exec_without_aspect, :exec
+
+            def exec
+              after_defined_method
+              exec_without_aspect
+            end
+          end
+        end
+
+        def after_defined_method
+          values << 'after-defined'
+        end
+      end
+    end
+
+    it 'should be able to use it' do
+      subject.exec
+      expect(subject.values).to eq %w( after-defined exec-result )
+    end
+  end
+end

data/spec/units/base_class_methods_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+RSpec.describe 'Aspector::Base class methods' do
+  subject { ClassBuilder.inherit(Aspector::Base) }
+
+  describe '.enable' do
+    pending
+  end
+
+  describe '.disable' do
+    pending
+  end
+
+  describe '.logger' do
+    pending
+  end
+
+  describe '.advices' do
+    pending
+  end
+
+  describe '.default_options' do
+    pending
+  end
+
+  describe '.apply' do
+    pending
+  end
+
+  describe '.default' do
+    context 'when there are no default options' do
+      let(:options) { { rand => rand } }
+
+      before do
+        subject.instance_variable_set(:'@default_options', nil)
+      end
+
+      it 'should assign provided options' do
+        subject.send(:default, options)
+
+        expect(subject.instance_variable_get(:'@default_options')).to eq options
+      end
+    end
+
+    context 'when there are default options' do
+      let(:options) { { rand => rand } }
+      let(:default_options) { { rand => rand } }
+
+      before do
+        subject.instance_variable_set(:'@default_options', default_options)
+      end
+
+      it 'should merge with existing options' do
+        subject.send(:default, options)
+
+        defaults = options.merge(default_options)
+        expect(subject.instance_variable_get(:'@default_options')).to eq defaults
+      end
+    end
+  end
+
+  describe '.before' do
+    subject do
+      ClassBuilder.inherit(Aspector::Base) do
+        before :test, :do_before
+      end
+    end
+
+    let(:advices) { subject.send(:advices) }
+    let(:advice) { advices.first }
+
+    it 'should create an advice' do
+      expect(subject.send(:advices).size).to eq 1
+    end
+
+    it 'created advice should be a before one' do
+      expect(advice.before?).to eq true
+      expect(advice.before_filter?).to eq false
+      expect(advice.after?).to eq false
+      expect(advice.around?).to eq false
+      expect(advice.raw?).to eq false
+    end
+
+    it 'skip_if_false for this advice should not be true' do
+      expect(advice.options[:skip_if_false]).not_to eq true
+    end
+
+    it 'should create a advice with a do_before method' do
+      expect(advice.with_method).to eq :do_before
+    end
+  end
+
+  describe '.before_filter' do
+    subject do
+      ClassBuilder.inherit(Aspector::Base) do
+        before_filter :test, :do_before
+      end
+    end
+
+    let(:advices) { subject.send(:advices) }
+    let(:advice) { advices.first }
+
+    it 'should create an advice' do
+      expect(subject.send(:advices).size).to eq 1
+    end
+
+    it 'created advice should be only a before one' do
+      expect(advice.before_filter?).to eq true
+      expect(advice.before?).to eq false
+      expect(advice.after?).to eq false
+      expect(advice.around?).to eq false
+      expect(advice.raw?).to eq false
+    end
+
+    it 'should create a advice with a do_before method' do
+      expect(advice.with_method).to eq :do_before
+    end
+  end
+
+  describe '.after' do
+    subject do
+      ClassBuilder.inherit(Aspector::Base) do
+        after :test, :do_after
+      end
+    end
+
+    let(:advices) { subject.send(:advices) }
+    let(:advice) { advices.first }
+
+    it 'should create an advice' do
+      expect(subject.send(:advices).size).to eq 1
+    end
+
+    it 'created advice should be a before one' do
+      expect(advice.after?).to eq true
+      expect(advice.before_filter?).to eq false
+      expect(advice.before?).to eq false
+      expect(advice.around?).to eq false
+      expect(advice.raw?).to eq false
+    end
+
+    it 'skip_if_false for this advice should not be true' do
+      expect(advice.options[:skip_if_false]).not_to eq true
+    end
+
+    it 'should create a advice with a do_after method' do
+      expect(advice.with_method).to eq :do_after
+    end
+  end
+
+  describe '.around' do
+    subject do
+      ClassBuilder.inherit(Aspector::Base) do
+        around :test, :do_around
+      end
+    end
+
+    let(:advices) { subject.send(:advices) }
+    let(:advice) { advices.first }
+
+    it 'should create an advice' do
+      expect(subject.send(:advices).size).to eq 1
+    end
+
+    it 'created advice should be a around one' do
+      expect(advice.after?).to eq false
+      expect(advice.before?).to eq false
+      expect(advice.around?).to eq true
+      expect(advice.raw?).to eq false
+    end
+
+    it 'skip_if_false for this advice should not be true' do
+      expect(advice.options[:skip_if_false]).not_to eq true
+    end
+
+    it 'should create a advice with a do_around method' do
+      expect(advice.with_method).to eq :do_around
+    end
+  end
+
+  describe '.raw' do
+    subject do
+      ClassBuilder.inherit(Aspector::Base) do
+        raw :test do
+        end
+      end
+    end
+
+    let(:advices) { subject.send(:advices) }
+    let(:advice) { advices.first }
+
+    it 'should create an advice' do
+      expect(subject.send(:advices).size).to eq 1
+    end
+
+    it 'created advice should be a around one' do
+      expect(advice.after?).to eq false
+      expect(advice.before_filter?).to eq false
+      expect(advice.before?).to eq false
+      expect(advice.around?).to eq false
+      expect(advice.raw?).to eq true
+    end
+
+    it 'skip_if_false for this advice should not be true' do
+      expect(advice.options[:skip_if_false]).not_to eq true
+    end
+  end
+
+  describe '.target' do
+    context 'when there is no code and no block' do
+      let(:code) { nil }
+
+      it 'should raise ArgumentError' do
+        expect { subject.send(:target, code) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when there is code and no block given' do
+      let(:code) { true }
+
+      it 'should not raise ArgumentError' do
+        expect { subject.send(:target, code) {} }.not_to raise_error
+      end
+    end
+
+    context 'when there is block given and no code' do
+      let(:code) { nil }
+
+      it 'should not raise ArgumentError' do
+        expect { subject.send(:target, code) {} }.not_to raise_error
+      end
+    end
+
+    context 'when there is code and block given' do
+      let(:code) { true }
+
+      it 'should not raise ArgumentError' do
+        expect { subject.send(:target, code) {} }.not_to raise_error
+      end
+    end
+  end
+
+  describe '.options' do
+    it 'should return DeferredOptions instance' do
+      expect(subject.send(:options)).to be_kind_of Aspector::DeferredOption
+    end
+  end
+
+  describe '._deferred_logics_' do
+    context 'when there is nothing in @deferred_logics' do
+      pending
+    end
+
+    context 'when there is value in @deferred_logics' do
+      pending
+    end
+  end
+
+  describe '._create_advice_' do
+    pending
+  end
+end

data/spec/units/base_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+RSpec.describe Aspector::Base do
+  let(:klass) { ClassBuilder.build }
+  let(:aspect) do
+    Aspector do
+      before :exec do
+        values << 'do_before'
+      end
+    end
+  end
+
+  subject { klass.new }
+
+  describe 'default options' do
+    context 'when we create aspector with default options' do
+      subject do
+        Aspector do
+          default exec: 'value'
+        end
+      end
+
+      it 'should store them' do
+        expect(subject.send(:default_options)[:exec]).to eq 'value'
+      end
+    end
+  end
+
+  describe '#options' do
+    # They are used to access options set when aspect is applied
+    let(:method) { rand }
+    let(:aspect) do
+      Aspector do
+        before options[:methods] do
+          values << 'do_this'
+        end
+      end
+    end
+
+    before do
+      aspect.apply(klass, methods: :exec)
+    end
+
+    it 'should use methods block' do
+      subject.exec
+      expect(subject.values).to eq %w( do_this exec-result )
+    end
+  end
+
+  describe '#apply' do
+    context 'applying to a single target' do
+      it 'should apply a given code to the method' do
+        aspect.apply(klass)
+        subject.exec
+        expect(subject.values).to eq %w( do_before exec-result )
+      end
+    end
+
+    context 'applying to multiple targets at once' do
+      let(:klass1) { ClassBuilder.build }
+      let(:klass2) { ClassBuilder.build }
+
+      let(:instance1) { klass1.new }
+      let(:instance2) { klass2.new }
+
+      before { aspect.apply(klass1, klass2) }
+
+      it 'should apply to all the targets' do
+        instance1.exec
+        expect(instance1.values).to eq %w( do_before exec-result )
+
+        instance2.exec
+        expect(instance2.values).to eq %w( do_before exec-result )
+      end
+    end
+
+    context 'when we try to apply to nonexisting method' do
+      let(:aspect) do
+        Aspector do
+          before options[:methods] do
+            # dummy advice
+          end
+        end
+      end
+
+      it 'should not do anything (should not fail)' do
+        expect { aspect.apply(klass, methods: 'not_exist') }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#target' do
+    context 'adding method to targeted class/module' do
+      before do
+        aspector(klass) do
+          target do
+            def before_exec
+              values << 'before-exec'
+            end
+          end
+
+          before :exec, :before_exec
+        end
+      end
+
+      it 'should add to target' do
+        subject.exec
+        expect(subject.values).to eq %w( before-exec exec-result )
+      end
+    end
+
+    context 'when we provide an aspect as an argument to a #target method' do
+      let(:aspect_class) do
+        Class.new(Aspector::Base) do
+          target do |aspect|
+            define_method :before_exec do
+              values << "before_exec(#{aspect.class})"
+            end
+          end
+
+          before :exec, :before_exec
+        end
+      end
+
+      it 'should add it to target' do
+        aspect_class.apply(klass)
+
+        subject.exec
+        expect(subject.values).to eq ["before_exec(#{aspect_class})", 'exec-result']
+      end
+    end
+  end
+end