rails-patterns 0.4.0 → 0.8.0

data/spec/patterns/ruleset_spec.rb

@@ -0,0 +1,260 @@
+RSpec.describe Ruleset do
+  context 'when empty ruleset is initialized' do
+    it 'raises an error' do
+      empty_ruleset_klass = Class.new(Ruleset)
+      custom_ruleset_klass = Class.new(Ruleset)
+      subject = double
+
+      with_mocked_rules do |rules|
+        rules << mock_rule(:rule_1)
+        custom_ruleset_klass.add_rule(:rule_1)
+
+        expect { custom_ruleset_klass.new(subject) }.not_to raise_error
+      end
+
+      expect { empty_ruleset_klass.new(subject) }.to raise_error Ruleset::EmptyRuleset
+    end
+  end
+
+  describe '#forceable?' do
+    context 'all rules are forceable' do
+      it 'returns true' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_forceable: true)
+          rules << mock_rule(:rule_2, is_forceable: true)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).forceable?).to eq true
+        end
+      end
+    end
+
+    context 'at least one rule is not forceable' do
+      it 'returns false' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_forceable: false, is_satisfied: false, is_applicable: true)
+          rules << mock_rule(:rule_2, is_forceable: true)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).forceable?).to eq false
+        end
+      end
+
+      context 'and rule is satisfied' do
+        it 'returns true' do
+          with_mocked_rules do |rules|
+            subject = double
+            rules << mock_rule(
+              :rule_1,
+              is_forceable: false,
+              is_satisfied: true,
+              is_applicable: true
+            )
+            rules << mock_rule(:rule_2, is_forceable: true)
+
+            custom_ruleset_klass = Class.new(Ruleset)
+            custom_ruleset_klass.add_rule(:rule_1)
+            custom_ruleset_klass.add_rule(:rule_2)
+
+            expect(custom_ruleset_klass.new(subject).forceable?).to eq true
+          end
+        end
+      end
+
+      context 'and rule is not applicable' do
+        it 'returns true' do
+          with_mocked_rules do |rules|
+            subject = double
+            rules << mock_rule(
+              :rule_1,
+              is_forceable: false,
+              is_satisfied: false,
+              is_applicable: false
+            )
+            rules << mock_rule(:rule_2, is_forceable: true)
+
+            custom_ruleset_klass = Class.new(Ruleset)
+            custom_ruleset_klass.add_rule(:rule_1)
+            custom_ruleset_klass.add_rule(:rule_2)
+
+            expect(custom_ruleset_klass.new(subject).forceable?).to eq true
+          end
+        end
+      end
+    end
+  end
+
+  describe '#not_applicable?' do
+    context 'all rules are not applicable' do
+      it 'returns true' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_applicable: false)
+          rules << mock_rule(:rule_2, is_applicable: false)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).not_applicable?).to eq true
+        end
+      end
+    end
+
+    context 'at least one rule is applicable' do
+      it 'returns false' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_applicable: false)
+          rules << mock_rule(:rule_2, is_applicable: true)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).not_applicable?).to eq false
+        end
+      end
+    end
+  end
+
+  describe '#satisfied?' do
+    context 'all rules are satisfied' do
+      it 'returns true' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1)
+          rules << mock_rule(:rule_2)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).satisfied?).to eq true
+        end
+      end
+    end
+
+    context 'at least one rule is not satisfied' do
+      it 'returns false' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1)
+          rules << mock_rule(:rule_2, is_satisfied: false)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).satisfied?).to eq false
+        end
+      end
+
+      context 'when rule is not applicable' do
+        it 'returns true' do
+          with_mocked_rules do |rules|
+            subject = double
+            rules << mock_rule(:rule_1)
+            rules << mock_rule(:rule_2, is_satisfied: false, is_applicable: false)
+
+            custom_ruleset_klass = Class.new(Ruleset)
+            custom_ruleset_klass.add_rule(:rule_1)
+            custom_ruleset_klass.add_rule(:rule_2)
+
+            expect(custom_ruleset_klass.new(subject).satisfied?).to eq true
+          end
+        end
+      end
+
+      context 'when provided with force: true' do
+        context 'when rule is forceable' do
+          it 'returns true' do
+            with_mocked_rules do |rules|
+              subject = double
+              rules << mock_rule(:rule_1)
+              rules << mock_rule(:rule_2, is_satisfied: false, is_forceable: true)
+
+              custom_ruleset_klass = Class.new(Ruleset)
+              custom_ruleset_klass.add_rule(:rule_1)
+              custom_ruleset_klass.add_rule(:rule_2)
+
+              expect(custom_ruleset_klass.new(subject).satisfied?(force: true)).to eq true
+            end
+          end
+        end
+
+        context 'when rule is not forceable' do
+          it 'returns false' do
+            with_mocked_rules do |rules|
+              subject = double
+              rules << mock_rule(:rule_1)
+              rules << mock_rule(:rule_2, is_satisfied: false, is_forceable: false)
+
+              custom_ruleset_klass = Class.new(Ruleset)
+              custom_ruleset_klass.add_rule(:rule_1)
+              custom_ruleset_klass.add_rule(:rule_2)
+
+              expect(custom_ruleset_klass.new(subject).satisfied?(force: true)).to eq false
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#each' do
+    it 'yields all rules for ruleset' do
+      with_mocked_rules do |rules|
+        rules << (_, rule_1 = mock_rule(:rule_1))
+        rules << (_, rule_2 = mock_rule(:rule_2))
+        rules << (_, rule_3 = mock_rule(:rule_3))
+        custom_ruleset_klass_1 = Class.new(Ruleset)
+        custom_ruleset_klass_1.add_rule(:rule_1)
+        custom_ruleset_klass_1.add_rule(:rule_2)
+        Ruleset2 = Class.new(Ruleset)
+        Ruleset2.add_rule(:rule_3)
+        custom_ruleset_klass_1.add_rule(:ruleset_2)
+
+        ruleset = custom_ruleset_klass_1.new(double)
+
+        expect { |b| ruleset.each(&b) }.to yield_successive_args(rule_1, rule_2, rule_3)
+      ensure
+        remove_class(Ruleset2)
+      end
+    end
+  end
+
+  private
+
+  def mock_rule(rule_name, is_applicable: true, is_satisfied: true, is_forceable: true)
+    klass = Object.const_set(rule_name.to_s.classify, Class.new(Rule))
+    rule = double(
+      not_applicable?: !is_applicable,
+      satisfied?: is_satisfied,
+      forceable?: is_forceable
+    )
+    allow(klass).to receive(:new).with(anything) { rule }
+    [klass, rule]
+  end
+
+  def with_mocked_rules
+    rules_storage = []
+    yield rules_storage
+  ensure
+    rules_storage.each do |rule_klass, _rule_instance|
+      remove_class(rule_klass)
+    end
+  end
+
+  def remove_class(klass)
+    Object.send(:remove_const, klass.name.to_sym)
+  end
+end

data/spec/patterns/service_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe Patterns::Service do
       expect(DoSomething.call).to be_kind_of(DoSomething)
     end
 
-    it "instantiates service object passing arguments to constructor" do
+    it "instantiates service object passing keyword arguments to constructor" do
       DoSomething = Class.new(Patterns::Service) do
         def initialize(argument_1:, argument_2:); end
         def call; end
@@ -25,6 +25,21 @@ RSpec.describe Patterns::Service do
       }.not_to raise_error
     end
 
+    it "instantiates service object passing positional arguments to constructor" do
+      DoSomething = Class.new(Patterns::Service) do
+        def initialize(argument_1, argument_2); end
+        def call; end
+      end
+
+      expect {
+        DoSomething.call
+      }.to raise_error ArgumentError
+
+      expect {
+        DoSomething.call(10, 20)
+      }.not_to raise_error
+    end
+
     it "calls #call method on service object instance" do
       Spy = Class.new do
         def self.some_method; end

data/spec/patterns/strong_ruleset_spec.rb

@@ -0,0 +1,79 @@
+RSpec.describe StrongRuleset do
+  it 'inherites from Ruleset' do
+    custom_strong_ruleset_klass = Class.new(StrongRuleset)
+    expect(custom_strong_ruleset_klass.ancestors).to include Ruleset
+  end
+
+  context 'when any of rules is not applicable' do
+    it 'is not satisfied' do
+      with_mocked_rules do |rules|
+        subject = double
+        rules << mock_rule(:rule_1, is_applicable: false)
+        rules << mock_rule(:rule_2)
+
+        custom_ruleset_klass = Class.new(StrongRuleset)
+        custom_ruleset_klass.add_rule(:rule_1)
+        custom_ruleset_klass.add_rule(:rule_2)
+
+        expect(custom_ruleset_klass.new(subject).satisfied?).to eq false
+      end
+    end
+
+    context 'when not applicable rule is not satisfied' do
+      it 'is not forceable' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_applicable: false, is_satisfied: false)
+          rules << mock_rule(:rule_2)
+
+          custom_ruleset_klass = Class.new(StrongRuleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).forceable?).to eq false
+        end
+      end
+    end
+
+    it 'is not applicable' do
+      with_mocked_rules do |rules|
+        subject = double
+        rules << mock_rule(:rule_1, is_applicable: false)
+        rules << mock_rule(:rule_2)
+
+        custom_ruleset_klass = Class.new(StrongRuleset)
+        custom_ruleset_klass.add_rule(:rule_1)
+        custom_ruleset_klass.add_rule(:rule_2)
+
+        expect(custom_ruleset_klass.new(subject).applicable?).to eq false
+      end
+    end
+  end
+
+  private
+
+  def mock_rule(rule_name, is_applicable: true, is_satisfied: true, is_forceable: true)
+    klass = Object.const_set(rule_name.to_s.classify, Class.new(Rule))
+    rule = double(
+      not_applicable?: !is_applicable,
+      applicable?: is_applicable,
+      satisfied?: is_satisfied,
+      forceable?: is_forceable
+    )
+    allow(klass).to receive(:new).with(anything) { rule }
+    [klass, rule]
+  end
+
+  def with_mocked_rules
+    rules_storage = []
+    yield rules_storage
+  ensure
+    rules_storage.each do |rule_klass, _rule_instance|
+      remove_class(rule_klass)
+    end
+  end
+
+  def remove_class(klass)
+    Object.send(:remove_const, klass.name.to_sym)
+  end
+end

data/spec/spec_helper.rb

@@ -17,10 +17,15 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
-require "rails-patterns"
+require "active_support/all"
+require "active_support/testing/time_helpers"
 require "pry"
+require "redis"
+require "rails-patterns"
 
 RSpec.configure do |config|
+  config.include ActiveSupport::Testing::TimeHelpers
+
   # rspec-expectations config goes here. You can use an alternate
   # assertion/expectation library such as wrong or the stdlib/minitest
   # assertions if you prefer.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-patterns
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Stevo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-04-21 00:00:00.000000000 Z
+date: 2020-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby2_keywords
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: juwelier
   requirement: !ruby/object:Gem::Requirement
@@ -103,6 +117,7 @@ extra_rdoc_files:
 - README.md
 files:
 - ".document"
+- ".github/workflows/ruby.yml"
 - ".rspec"
 - Gemfile
 - Gemfile.lock
@@ -111,22 +126,33 @@ files:
 - Rakefile
 - VERSION
 - lib/patterns.rb
+- lib/patterns/calculation.rb
 - lib/patterns/collection.rb
 - lib/patterns/form.rb
 - lib/patterns/query.rb
+- lib/patterns/rule.rb
+- lib/patterns/ruleset.rb
 - lib/patterns/service.rb
+- lib/patterns/strong_ruleset.rb
 - lib/rails-patterns.rb
 - rails-patterns.gemspec
+- spec/helpers/custom_calculation.rb
+- spec/helpers/custom_calculation_script.rb
+- spec/helpers/rails_redis_cache_mock.rb
+- spec/patterns/calculation_spec.rb
 - spec/patterns/collection_spec.rb
 - spec/patterns/form_spec.rb
 - spec/patterns/query_spec.rb
+- spec/patterns/rule_spec.rb
+- spec/patterns/ruleset_spec.rb
 - spec/patterns/service_spec.rb
+- spec/patterns/strong_ruleset_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/selleo/pattern
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -134,16 +160,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: A collection of lightweight, standardized, rails-oriented patterns.
 test_files: []