rails-patterns 0.4.0 → 0.8.0

data/spec/helpers/custom_calculation.rb

@@ -0,0 +1,16 @@
+require 'active_support/all'
+require 'active_support/testing/time_helpers'
+require_relative 'rails_redis_cache_mock'
+require_relative '../../lib/patterns/calculation'
+
+CustomCalculation = Class.new(Patterns::Calculation) do
+  set_cache_expiry_every 1.hour
+  class_attribute :counter
+  self.counter = 0
+
+  private
+
+  def result
+    self.class.counter += 1
+  end
+end

data/spec/helpers/custom_calculation_script.rb

@@ -0,0 +1,4 @@
+require_relative 'rails_redis_cache_mock'
+require_relative 'custom_calculation'
+
+CustomCalculation.result

data/spec/helpers/rails_redis_cache_mock.rb

@@ -0,0 +1,5 @@
+class Rails
+  def self.cache
+    @cache ||= ActiveSupport::Cache::RedisCacheStore.new
+  end
+end

data/spec/patterns/calculation_spec.rb

@@ -0,0 +1,200 @@
+RSpec.describe Patterns::Calculation do
+  before(:all) do
+    class Rails
+      def self.cache
+        @cache ||= ActiveSupport::Cache::MemoryStore.new
+      end
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :Rails)
+  end
+
+  after do
+    Object.send(:remove_const, :CustomCalculation) if defined?(CustomCalculation)
+    Rails.cache.clear
+    ActiveSupport::Cache::RedisCacheStore.new.clear
+  end
+
+  describe ".result" do
+    it "returns a result of the calculation within a #result method" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        private
+
+        def result
+          50
+        end
+      end
+
+      expect(CustomCalculation.result).to eq 50
+    end
+
+    it "#result, #result_for and #calculate are aliases" do
+      CustomCalculation = Class.new(Patterns::Calculation)
+
+      expect(CustomCalculation.method(:result)).to eq CustomCalculation.method(:result_for)
+      expect(CustomCalculation.method(:result)).to eq CustomCalculation.method(:calculate)
+    end
+
+    it "exposes the first argument as a subject" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        private
+
+        def result
+          subject
+        end
+      end
+
+      expect(CustomCalculation.result('test')).to eq 'test'
+    end
+
+    it "exposes all keyword arguments using #options" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        private
+
+        def result
+          [options[:arg_1], options[:arg_2]]
+        end
+      end
+
+      expect(CustomCalculation.result(nil, arg_1: 20, arg_2: 30)).to eq([20, 30])
+    end
+  end
+
+  describe "caching" do
+    it "caches result for 'set_cache_expiry_every' period" do
+      travel_to DateTime.new(2017, 1, 1, 12, 0) do
+        CustomCalculation = Class.new(Patterns::Calculation) do
+          set_cache_expiry_every 1.hour
+
+          class_attribute :counter
+          self.counter = 0
+
+          private
+
+          def result
+            self.class.counter += 1
+          end
+        end
+
+        expect(CustomCalculation.result).to eq 1
+        expect(CustomCalculation.result).to eq 1
+      end
+
+      travel_to DateTime.new(2017, 1, 1, 13, 1) do
+        expect(CustomCalculation.result).to eq 2
+        expect(CustomCalculation.result).to eq 2
+      end
+    end
+
+    it "caches result for every option passed" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        set_cache_expiry_every 1.hour
+
+        class_attribute :counter
+        self.counter = 0
+
+        private
+
+        def result
+          self.class.counter += 1
+        end
+      end
+
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(CustomCalculation.result(1024)).to eq 2
+      expect(CustomCalculation.result(1024)).to eq 2
+      expect(CustomCalculation.result(1024, arg: 1)).to eq 3
+      expect(CustomCalculation.result(1024, arg: 1)).to eq 3
+    end
+
+    it "caches result for every option passed dependant on the class" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        set_cache_expiry_every 1.hour
+
+        class_attribute :counter
+        self.counter = 0
+
+        private
+
+        def result
+          self.class.counter += 1
+        end
+      end
+
+      DifferentCalculation = Class.new(Patterns::Calculation) do
+        set_cache_expiry_every 1.hour
+
+        class_attribute :counter
+        self.counter = 100
+
+        private
+
+        def result
+          self.class.counter += 1
+        end
+      end
+
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(DifferentCalculation.result(123)).to eq 101
+      expect(DifferentCalculation.result(123)).to eq 101
+
+      Object.send(:remove_const, :DifferentCalculation)
+    end
+
+    it "does not cache result if 'set_cache_expiry_every' is not set" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        class_attribute :counter
+        self.counter = 0
+
+        private
+
+        def result
+          self.class.counter += 1
+        end
+      end
+
+      expect(CustomCalculation.result).to eq 1
+      expect(CustomCalculation.result).to eq 2
+    end
+
+    describe "when RedisCacheStore is used" do
+      it "does not store data in cache if 'cache_expiry_period' is not set" do
+        client = Redis.new
+        class Rails
+          def self.cache
+            @cache ||= ActiveSupport::Cache::RedisCacheStore.new
+          end
+        end
+
+        CustomCalculation = Class.new(Patterns::Calculation) do
+          class_attribute :counter
+          self.counter = 0
+
+          private
+
+          def result
+            self.class.counter += 1
+          end
+        end
+
+        expect(CustomCalculation.result).to eq 1
+        expect(CustomCalculation.result).to eq 2
+        expect(client.keys).to be_empty
+      end
+    end
+
+    it "uses cache keys consistent between processes" do
+      `bundle exec ruby spec/helpers/custom_calculation.rb`
+      Process.spawn('bundle exec ruby spec/helpers/custom_calculation_script.rb')
+      Process.spawn('bundle exec ruby spec/helpers/custom_calculation_script.rb')
+      Process.spawn('bundle exec ruby spec/helpers/custom_calculation_script.rb')
+      Process.waitall
+
+      expect(Redis.new.keys.length).to eq 1
+    end
+  end
+end

data/spec/patterns/form_spec.rb

@@ -316,7 +316,7 @@ RSpec.describe Patterns::Form do
   end
 
   describe "#to_model" do
-    it "retruns itself" do
+    it "returns itself" do
       CustomForm = Class.new(Patterns::Form)
 
       form = CustomForm.new(double)
@@ -345,86 +345,132 @@ RSpec.describe Patterns::Form do
     end
   end
 
-  describe "#model_name" do
-    describe "#param_key" do
-      context "resource exists" do
-        context "resource responds to #model_name" do
-          context "param_key is not defined" do
-            it "returns object responding to #param_key returning resource#param_key" do
-              CustomForm = Class.new(Patterns::Form)
-              resource = double(model_name: double(param_key: "resource_key"))
-
-              form = CustomForm.new(resource)
-              result = form.model_name
-
-              expect(result).to respond_to(:param_key)
-              expect(result.param_key).to eq "resource_key"
-            end
-          end
-
-          context "param_key is defined" do
-            it "returns param_key" do
-              CustomForm = Class.new(Patterns::Form) do
-                param_key "test_key"
-              end
-              resource = double(model_name: double(param_key: "resource_key"))
+  describe "#to_param" do
+    context "resource exists" do
+      context "resource responds to #to_param" do
+        it "returns resource#to_param" do
+          CustomForm = Class.new(Patterns::Form)
+          resource = double(to_param: 100)
 
-              form = CustomForm.new(resource)
-              result = form.model_name
+          form = CustomForm.new(resource)
 
-              expect(result.param_key).to eq "test_key"
-            end
-          end
+          expect(form.to_param).to eq 100
         end
+      end
+    end
+
+    context "resource does not exist" do
+      it "returns nil" do
+        CustomForm = Class.new(Patterns::Form)
 
-        context "resource does not respond to #model_name" do
-          context "param_key is not defined" do
-            it "raises NoParamKey" do
-              CustomForm = Class.new(Patterns::Form)
+        form = CustomForm.new
 
-              form = CustomForm.new(double)
+        expect(form.to_param).to eq nil
+      end
+    end
+  end
 
-              expect { form.model_name }.to raise_error(Patterns::Form::NoParamKey)
-            end
-          end
+  describe "#model_name" do
+    context "resource exists" do
+      context "resource responds to #model_name" do
+        context "param_key is not defined" do
+          it "returns object's model name param_key, route_key and singular_route_key" do
+            CustomForm = Class.new(Patterns::Form)
+            resource = double(model_name: double(
+              param_key: "resource_key",
+              route_key: "resource_keys",
+              singular_route_key: "resource_key"
+            ))
 
-          context "param_key is defined" do
-            it "returns param_key" do
-              CustomForm = Class.new(Patterns::Form) do
-                param_key "test_key"
-              end
+            form = CustomForm.new(resource)
+            result = form.model_name
 
-              form = CustomForm.new(double)
-              result = form.model_name
+            expect(result).to have_attributes(
+              param_key: "resource_key",
+              route_key: "resource_keys",
+              singular_route_key: "resource_key"
+            )
+          end
+        end
 
-              expect(result.param_key).to eq "test_key"
+        context "param_key is defined" do
+          it "returns param_key, route_key and singular_route_key derived from param key" do
+            CustomForm = Class.new(Patterns::Form) do
+              param_key "test_key"
             end
+            resource = double(model_name: double(
+              param_key: "resource_key",
+              route_key: "resource_keys",
+              singular_route_key: "resource_key"
+            ))
+
+            form = CustomForm.new(resource)
+            result = form.model_name
+
+            expect(result).to have_attributes(
+              param_key: "test_key",
+              route_key: "test_keys",
+              singular_route_key: "test_key"
+            )
           end
         end
       end
 
-      context "resource does not exist" do
+      context "resource does not respond to #model_name" do
         context "param_key is not defined" do
           it "raises NoParamKey" do
             CustomForm = Class.new(Patterns::Form)
 
-            form = CustomForm.new
+            form = CustomForm.new(double)
 
             expect { form.model_name }.to raise_error(Patterns::Form::NoParamKey)
           end
         end
 
         context "param_key is defined" do
-          it "returns param_key" do
+          it "returns param_key, route_key and singular_route_key derived from param key" do
             CustomForm = Class.new(Patterns::Form) do
               param_key "test_key"
             end
 
-            form = CustomForm.new
+            form = CustomForm.new(double)
             result = form.model_name
 
-            expect(result.param_key).to eq "test_key"
+            expect(result).to have_attributes(
+              param_key: "test_key",
+              route_key: "test_keys",
+              singular_route_key: "test_key"
+            )
+          end
+        end
+      end
+    end
+
+    context "resource does not exist" do
+      context "param_key is not defined" do
+        it "raises NoParamKey" do
+          CustomForm = Class.new(Patterns::Form)
+
+          form = CustomForm.new
+
+          expect { form.model_name }.to raise_error(Patterns::Form::NoParamKey)
+        end
+      end
+
+      context "param_key is defined" do
+        it "returns param_key, route_key and singular_route_key derived from param key" do
+          CustomForm = Class.new(Patterns::Form) do
+            param_key "test_key"
           end
+
+          form = CustomForm.new
+          result = form.model_name
+
+          expect(result).to have_attributes(
+            param_key: "test_key",
+            route_key: "test_keys",
+            singular_route_key: "test_key"
+          )
         end
       end
     end

data/spec/patterns/rule_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Rule do
+  after(:each) do
+    Object.send(:remove_const, :CustomRule) if defined?(CustomRule)
+  end
+
+  it 'requires subject as the first argument' do
+    CustomRule = Class.new(Rule)
+
+    expect { CustomRule.new }.to raise_error ArgumentError
+    expect { CustomRule.new(Object.new) }.not_to raise_error
+  end
+
+  it 'requires #satisfied? method to be defined' do
+    InvalidCustomRule = Class.new(Rule)
+    CustomRule = Class.new(Rule) do
+      def satisfied?
+        true
+      end
+    end
+
+    expect { InvalidCustomRule.new(Object.new).satisfied? }.to raise_error NotImplementedError
+    expect { CustomRule.new(Object.new).satisfied? }.not_to raise_error
+  end
+
+  describe '#satisfied?' do
+    context 'when subject meets the conditions' do
+      it 'returns true' do
+        article = OpenStruct.new('published?' => true, 'deleted?' => false)
+
+        ArticleIsPublishedRule = Class.new(Rule) do
+          def satisfied?
+            subject.published?
+          end
+
+          def not_applicable?
+            subject.deleted?
+          end
+        end
+
+        expect(ArticleIsPublishedRule.new(article).satisfied?).to eq true
+      end
+    end
+  end
+end