aspector 0.13.1 → 0.14.0

data/spec/functionals/aspect_on_an_instance_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+RSpec.describe 'Advices on private methods' do
+  subject { klass.new }
+
+  let(:klass) do
+    ClassBuilder.build
+  end
+
+  let(:instance1) { klass.new }
+  let(:instance2) { klass.new }
+
+  context 'before aspect' do
+    before do
+      aspector(instance1) do
+        before :exec do
+          values << 'exec-before'
+        end
+      end
+    end
+
+    it 'should bind only to one instance to which we want to bind' do
+      instance1.exec
+      instance2.exec
+      expect(instance1.values).to eq %w( exec-before exec-result )
+      expect(instance2.values).to eq %w( exec-result )
+    end
+  end
+
+  context 'around aspect' do
+    before do
+      aspector(instance1) do
+        around :exec do |proxy, &block|
+          values << 'exec-around-before'
+          result = proxy.call(&block)
+          values << 'exec-around-after'
+          result
+        end
+      end
+    end
+
+    it 'should bind only to one instance to which we want to bind' do
+      instance1.exec
+      instance2.exec
+      expect(instance1.values).to eq %w( exec-around-before exec-result exec-around-after )
+      expect(instance2.values).to eq %w( exec-result )
+    end
+  end
+
+  context 'after aspect' do
+    before do
+      aspector(instance1) do
+        after :exec do |_result|
+          values << 'exec-after'
+        end
+      end
+    end
+
+    it 'should bind only the aspect that binds to private methods' do
+      instance1.exec
+      instance2.exec
+      expect(instance1.values).to eq %w( exec-result exec-after )
+      expect(instance2.values).to eq %w( exec-result )
+    end
+  end
+end

data/spec/functionals/aspector_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+RSpec.describe Aspector do
+  let(:klass) { ClassBuilder.build }
+  subject { klass.new }
+
+  context 'binding multiple aspects in a single place' do
+    before do
+      aspector(klass) do
+        before(:exec) { values << 'first-aspect' }
+      end
+
+      aspector(klass) do
+        before(:exec) { values << 'second-aspect' }
+      end
+    end
+
+    it 'should work' do
+      subject.exec
+      expect(subject.values).to eq %w( second-aspect first-aspect exec-result )
+    end
+  end
+
+  context 'when we try to treat Aspect as a regular class' do
+    let(:aspect_klass) do
+      ClassBuilder.inherit(Aspector::Base) do
+        before(:exec) { values << 'before-exec' }
+      end
+    end
+
+    before do
+      aspect_klass.apply(klass)
+    end
+
+    it 'should work' do
+      subject.exec
+      expect(subject.values).to eq %w( before-exec exec-result )
+    end
+  end
+
+  context 'when we want to apply aspect multiple times' do
+    let(:aspect_klass) do
+      Aspector do
+        before(:exec) { values << 'before-exec' }
+      end
+    end
+
+    before do
+      aspect_klass.apply(klass)
+      aspect_klass.apply(klass)
+    end
+
+    it 'should apply aspect multiple times' do
+      subject.exec
+      expect(subject.values).to eq %w( before-exec before-exec exec-result )
+    end
+  end
+
+  context 'when we set new_methods_only to true' do
+    let(:aspect_klass) do
+      Aspector do
+        before(:exec) { values << 'before-exec' }
+      end
+    end
+
+    before do
+      aspect_klass.apply(klass, new_methods_only: true)
+    end
+
+    context 'and we try to apply it to already existing method' do
+      it 'should not apply to existing methods' do
+        subject.exec
+        expect(subject.values).to eq %w( exec-result )
+      end
+    end
+
+    context 'and we try to apply it to a new method' do
+      let(:klass) do
+        ClassBuilder.raw do
+          def values
+            @values ||= []
+          end
+        end
+      end
+
+      before do
+        klass.send :define_method, :exec do
+          values << 'exec-result'
+        end
+      end
+
+      it 'should apply to new methods' do
+        subject.exec
+        expect(subject.values).to eq %w( before-exec exec-result )
+      end
+    end
+  end
+
+  context 'when we set existing_methods_only to true' do
+    let(:aspect_klass) do
+      Aspector do
+        before(:exec) { values << 'before-exec' }
+      end
+    end
+
+    before do
+      aspect_klass.apply(klass, existing_methods_only: true)
+    end
+
+    context 'and we try to apply it to already existing method' do
+      it 'should apply to existing methods' do
+        subject.exec
+        expect(subject.values).to eq %w( before-exec exec-result )
+      end
+    end
+
+    context 'and we try to apply it to a new method' do
+      let(:klass) do
+        ClassBuilder.raw do
+          def values
+            @values ||= []
+          end
+        end
+      end
+
+      before do
+        klass.send :define_method, :exec do
+          values << 'exec-result'
+        end
+      end
+
+      it 'should not apply to new methods' do
+        subject.exec
+        expect(subject.values).to eq %w( exec-result )
+      end
+    end
+  end
+end

data/spec/functionals/aspects_combined_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe 'Aspects combined' do
+  let(:klass) { ClassBuilder.build }
+  subject { klass.new }
+
+  context 'when we want to combine multiple different aspects' do
+    before do
+      aspector(klass) do
+        before :exec do
+          values << 'exec-before'
+        end
+
+        after :exec do |result|
+          values << 'exec-after'
+          result
+        end
+
+        around :exec do |proxy, &block|
+          values << 'exec-around-before'
+          result = proxy.call(&block)
+          values << 'exec-around-after'
+          result
+        end
+      end
+    end
+
+    it 'should work' do
+      expected = %w(
+        exec-before exec-around-before exec-result exec-around-after exec-after
+      )
+
+      subject.exec
+      expect(subject.values).to eq expected
+    end
+  end
+end

data/spec/functionals/aspects_execution_order_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe 'Aspect execution order' do
+  let(:klass) { ClassBuilder.build }
+  subject { klass.new }
+
+  context 'when we apply aspects in certain order' do
+    before do
+      aspector(klass) do
+        before :exec do
+          values << 'exec-before1'
+        end
+
+        after :exec do |result|
+          values << 'exec-after1'
+          result
+        end
+
+        around :exec do |proxy, &block|
+          values << 'exec-around-before1'
+          result = proxy.call(&block)
+          values << 'exec-around-after1'
+          result
+        end
+
+        before :exec do
+          values << 'exec-before2'
+        end
+
+        after :exec do |result|
+          values << 'exec-after2'
+          result
+        end
+
+        around :exec do |proxy, &block|
+          values << 'exec-around-before2'
+          result = proxy.call(&block)
+          values << 'exec-around-after2'
+          result
+        end
+      end
+    end
+
+    it 'should use this order' do
+      expected = %w(
+        exec-before1
+        exec-before2
+        exec-around-before1
+        exec-around-before2
+        exec-result
+        exec-around-after2
+        exec-around-after1
+        exec-after1
+        exec-after2
+      )
+
+      subject.exec
+      expect(subject.values).to eq expected
+    end
+  end
+end

data/spec/functionals/aspects_on_private_methods_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+RSpec.describe 'Aspects on private methods' do
+  subject { klass.new }
+
+  let(:klass) do
+    ClassBuilder.build do
+      private :exec
+    end
+  end
+
+  context 'before aspect' do
+    before do
+      aspector(klass) do
+        before :exec do
+          values << 'exec-before(public_methods_only)'
+        end
+      end
+
+      aspector(klass, private_methods: true) do
+        before :exec do
+          values << 'exec-before'
+        end
+      end
+    end
+
+    it 'should bind only the aspect that binds to private methods' do
+      subject.send :exec
+      expect(subject.values).to eq %w( exec-before exec-result )
+    end
+  end
+
+  context 'around aspect' do
+    before do
+      aspector(klass) do
+        around :exec do |proxy, &block|
+          values << 'exec-around-before(public_methods_only)'
+          result = proxy.call(&block)
+          values << 'exec-around-after(public_methods_only)'
+          result
+        end
+      end
+
+      aspector(klass, private_methods: true) do
+        around :exec do |proxy, &block|
+          values << 'exec-around-before'
+          result = proxy.call(&block)
+          values << 'exec-around-after'
+          result
+        end
+      end
+    end
+
+    it 'should bind only the aspect that binds to private methods' do
+      subject.send :exec
+      expect(subject.values).to eq %w( exec-around-before exec-result exec-around-after )
+    end
+  end
+
+  context 'after aspect' do
+    before do
+      aspector(klass) do
+        after :exec do |result|
+          values << 'exec-after(public_methods_only)'
+          result
+        end
+      end
+
+      aspector(klass, private_methods: true) do
+        after :exec do |result|
+          values << 'exec-after'
+          result
+        end
+      end
+    end
+
+    it 'should bind only the aspect that binds to private methods' do
+      subject.send :exec
+      expect(subject.values).to eq %w( exec-result exec-after )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,31 +1,30 @@
-ENV["ASPECTOR_LOG_LEVEL"] ||= "warn"
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rubygems'
 require 'rspec'
-require 'rspec/autorun'
-require 'aspector'
+require 'simplecov'
+require 'pry'
 
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 
-RSpec.configure do |config|
+# Don't include unnecessary stuff into rcov
+SimpleCov.start do
+  add_filter '/vendor/'
+  add_filter '/gems/'
+  add_filter '/.bundle/'
+  add_filter '/spec/'
+  merge_timeout 600
 end
 
-def create_test_class &block
-  klass = Class.new do
-    def value
-      @value ||= []
-    end
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
-    def test
-      value << "test"
-    end
-  end
+RSpec.configure do |config|
+  config.disable_monkey_patching!
 
-  klass.class_eval &block if block_given?
-  klass
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
 end
 
+require 'aspector'
+
+ENV['ASPECTOR_LOG_LEVEL'] ||= ::Logger::WARN.to_s

data/spec/support/class_builder.rb

@@ -0,0 +1,44 @@
+# rubocop:disable NestedMethodDefinition
+# Class builder helps creating anonymous classes that we can use to spec our aspector
+# We need co create new class instances to have an "empty" and "clear" class for each spec
+# This module acts as an interface to create classes
+module ClassBuilder
+  class << self
+    # Builds a new anonymous class with a predefined methods
+    # @param block [Proc, nil] block that should be evaluated (if given)
+    # @return [Class] created anonymous class
+    def build(&block)
+      klass = raw do
+        def values
+          @values ||= []
+        end
+
+        # This is a method that we use as a place to bind to
+        # @note This method accepts dummy not used parameter but we keep it
+        #   so we can exec with parameter if we need
+        def exec(_param = nil)
+          values << 'exec-result'
+        end
+      end
+
+      klass.class_eval(&block) if block_given?
+      klass
+    end
+
+    # Creates an empty class without any predefined methods
+    # @param block [Proc, nil] block that should be evaluated (if given)
+    # @return [Class] created anonymous class
+    def raw(&block)
+      Class.new(&block)
+    end
+
+    # This method allows us to create a class that inherits from any other
+    # @param klass [Class] any class from which we want to inherit in our anonymous class
+    # @param block [Proc] a block of code that should be evaluated in a new anonymous class body
+    # @return [Class] new anonymous class
+    def inherit(klass, &block)
+      Class.new(klass, &block)
+    end
+  end
+end
+# rubocop:enable NestedMethodDefinition