light-service 0.10.3 → 0.15.0

data/spec/lib/generators/full_generator_test_blobs.rb

@@ -0,0 +1,193 @@
+# rubocop:disable Metrics/ClassLength, Metrics/MethodLength
+class FullGeneratorTestBlobs
+  def self.simple_action_blob
+    <<~BLOB
+      # frozen_string_literal: true
+
+      class MyAction
+        extend ::LightService::Action
+
+        executed do |ctx|
+        end
+
+        rolled_back do |ctx|
+        end
+      end
+    BLOB
+  end
+
+  def self.simple_action_spec_blob
+    <<~BLOB
+      # frozen_string_literal: true
+
+      require 'rails_helper'
+
+      RSpec.describe MyAction, type: :action do
+        subject { described_class.execute(ctx) }
+
+        let(:ctx) do
+          {
+          }
+        end
+
+        context "when executed" do
+          xit "is expected to be successful" do
+            expect(subject).to be_a_success
+          end
+        end
+      end
+    BLOB
+  end
+
+  # There's some weird whitespace issue which prevents
+  # using HEREDOCS :(
+  def self.advanced_action_blob
+    "# frozen_string_literal: true\n" \
+      "\n" \
+      "module My::Fancy\n" \
+      "  class Action\n" \
+      "    extend ::LightService::Action\n" \
+      "\n" \
+      "    expects  :foo, :bar\n" \
+      "    promises :baz, :qux\n" \
+      "\n" \
+      "    executed do |ctx|\n" \
+      "      foo = ctx.foo\n" \
+      "      bar = ctx.bar\n" \
+      "    end\n" \
+      "  end\n" \
+      "end"
+  end
+
+  def self.advanced_action_spec_blob
+    <<~BLOB
+      # frozen_string_literal: true
+
+      require 'rails_helper'
+
+      RSpec.describe My::Fancy::Action, type: :action do
+        subject { described_class.execute(ctx) }
+
+        let(:ctx) do
+          {
+            foo: nil,
+            bar: nil,
+          }
+        end
+
+        context "when executed" do
+          xit "is expected to be successful" do
+            expect(subject).to be_a_success
+          end
+
+          xit "is expected to promise 'baz'" do
+            expect(subject.baz).to eq SomeBazClass
+          end
+
+          xit "is expected to promise 'qux'" do
+            expect(subject.qux).to eq SomeQuxClass
+          end
+        end
+      end
+    BLOB
+  end
+
+  def self.simple_organizer_blob
+    <<~BLOB
+      # frozen_string_literal: true
+
+      class MyOrganizer
+        extend ::LightService::Organizer
+
+        def self.call(params)
+          with(
+            #foo: params[:foo],
+            #bar: params[:bar]
+          ).reduce(actions)
+        end
+
+        def self.actions
+          [
+            #OneAction,
+            #TwoAction,
+          ]
+        end
+      end
+    BLOB
+  end
+
+  def self.simple_organizer_spec_blob
+    <<~BLOB
+      # frozen_string_literal: true
+
+      require 'rails_helper'
+
+      RSpec.describe MyOrganizer, type: :organizer do
+        subject { described_class.call(ctx) }
+
+        let(:ctx) do
+          {
+            #foo: 'something foo',
+            #bar: { baz: qux },
+          }
+        end
+
+        context "when called" do
+          xit "is expected to be successful" do
+            expect(subject).to be_a_success
+          end
+        end
+      end
+    BLOB
+  end
+
+  def self.advanced_organizer_blob
+    "# frozen_string_literal: true\n" \
+      "\n" \
+      "module My::Fancy\n" \
+      "  class Organizer\n" \
+      "    extend ::LightService::Organizer\n" \
+      "\n" \
+      "    def self.call(params)\n" \
+      "      with(\n" \
+      "        #foo: params[:foo],\n" \
+      "        #bar: params[:bar]\n" \
+      "      ).reduce(actions)\n" \
+      "    end\n" \
+      "\n" \
+      "    def self.actions\n" \
+      "      [\n" \
+      "        #My::Fancy::OneAction,\n" \
+      "        #My::Fancy::TwoAction,\n" \
+      "      ]\n" \
+      "    end\n" \
+      "  end\n" \
+      "end"
+  end
+
+  def self.advanced_organizer_spec_blob
+    <<~BLOB
+      # frozen_string_literal: true
+
+      require 'rails_helper'
+
+      RSpec.describe My::Fancy::Organizer, type: :organizer do
+        subject { described_class.call(ctx) }
+
+        let(:ctx) do
+          {
+            #foo: 'something foo',
+            #bar: { baz: qux },
+          }
+        end
+
+        context "when called" do
+          xit "is expected to be successful" do
+            expect(subject).to be_a_success
+          end
+        end
+      end
+    BLOB
+  end
+end
+# rubocop:enable Metrics/ClassLength, Metrics/MethodLength

data/spec/lib/generators/organizer_generator_advanced_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+require_relative '../../../lib/generators/light_service/organizer_generator.rb'
+require_relative './full_generator_test_blobs'
+
+describe LightService::Generators::OrganizerGenerator, :type => :generator do
+  destination File.expand_path('tmp', __dir__)
+
+  context "when generating an advanced organizer" do
+    before(:all) do
+      prepare_destination
+      run_generator
+    end
+
+    after(:all) do
+      FileUtils.rm_rf destination_root
+    end
+
+    arguments %w[my/fancy/organizer --dir=processes]
+
+    specify do
+      expect(destination_root).to(have_structure do
+        directory "app/processes/my/fancy" do
+          file "organizer.rb" do
+            contains FullGeneratorTestBlobs.advanced_organizer_blob
+          end
+        end
+
+        directory "spec/processes/my/fancy" do
+          file "organizer_spec.rb" do
+            contains FullGeneratorTestBlobs.advanced_organizer_spec_blob
+          end
+        end
+      end)
+    end
+  end
+end

data/spec/lib/generators/organizer_generator_simple_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+require_relative '../../../lib/generators/light_service/organizer_generator.rb'
+require_relative './full_generator_test_blobs'
+
+describe LightService::Generators::OrganizerGenerator, :type => :generator do
+  destination File.expand_path('tmp', __dir__)
+
+  context "when generating a simple organizer" do
+    before(:all) do
+      prepare_destination
+      run_generator
+    end
+
+    after(:all) do
+      FileUtils.rm_rf destination_root
+    end
+
+    arguments %w[my_organizer]
+
+    specify do
+      expect(destination_root).to(have_structure do
+        directory "app/organizers" do
+          file "my_organizer.rb" do
+            contains FullGeneratorTestBlobs.simple_organizer_blob
+          end
+        end
+
+        directory "spec/organizers" do
+          file "my_organizer_spec.rb" do
+            contains FullGeneratorTestBlobs.simple_organizer_spec_blob
+          end
+        end
+      end)
+    end
+  end
+end

data/spec/organizer_spec.rb

@@ -19,6 +19,11 @@ describe LightService::Organizer do
       result = TestDoubles::AnOrganizer.call(:user => user)
       expect(result).to eq(ctx)
     end
+
+    it "sets itself as the organizer" do
+      result = TestDoubles::AnOrganizer.call(:user => user)
+      expect(result.organized_by).to eq TestDoubles::AnOrganizer
+    end
   end
 
   context "when #with is called with Context" do
@@ -44,20 +49,6 @@ describe LightService::Organizer do
     end
   end
 
-  context "when no starting context is specified" do
-    it "creates one implicitly" do
-      expect(TestDoubles::AnAction).to receive(:execute)
-        .with({})
-        .and_return(ctx)
-      expect(TestDoubles::AnotherAction).to receive(:execute)
-        .with(ctx)
-        .and_return(ctx)
-
-      expect { TestDoubles::AnOrganizer.do_something_with_no_starting_context }
-        .not_to raise_error
-    end
-  end
-
   context "when aliases are declared" do
     let(:organizer) do
       Class.new do
@@ -83,4 +74,41 @@ describe LightService::Organizer do
       organizer.call
     end
   end
+
+  context "when an organizer is nested and reduced within another" do
+    let(:reduced) { TestDoubles::NestingOrganizer.call(ctx) }
+    let(:organizer_result) do
+      TestDoubles::NotExplicitlyReturningContextOrganizer.call(ctx)
+    end
+
+    it "reduces an organizer which returns something" do
+      expect(organizer_result).to eq([1, 2, 3])
+    end
+
+    it "adds :foo and :bar to the context" do
+      reduced
+      expect(ctx[:foo]).to eq([1, 2, 3])
+      expect(ctx[:bar]).to eq(ctx[:foo])
+    end
+
+    it "returns the context" do
+      expect(reduced).to eq(ctx)
+    end
+  end
+
+  context 'can add items to the context' do
+    specify 'with #add_to_context' do
+      result = TestDoubles::AnOrganizerThatAddsToContext.call
+      expect(result[:strongest_avenger]).to eq 'The Thor'
+      expect(result[:last_jedi]).to eq 'Rey'
+    end
+  end
+
+  context 'can assign key aliaeses' do
+    it 'with #add_aliases' do
+      result = TestDoubles::AnOrganizerThatAddsAliases.call
+      expect(result[:foo]).to eq :bar
+      expect(result[:baz]).to eq :bar
+    end
+  end
 end

data/spec/sample/provides_free_shipping_action_spec.rb

@@ -15,7 +15,7 @@ describe ProvidesFreeShippingAction do
   end
 
   context "when the order total with tax is <= 200" do
-    specify "order gets free shipping" do
+    specify "order does not get free shipping" do
       allow(order).to receive_messages(:total_with_tax => 200)
       expect(order).not_to receive(:provide_free_shipping!)
 

data/spec/spec_helper.rb

@@ -8,15 +8,20 @@ if ENV['RUN_COVERAGE_REPORT']
     add_filter 'vendor/'
     add_filter %r{^/spec/}
   end
-
   SimpleCov.minimum_coverage_by_file 90
+
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
 end
 
 require 'light-service'
 require 'light-service/testing'
 require 'ostruct'
-require 'active_support/core_ext/string'
 require 'pry'
 require 'support'
+require 'test_doubles'
+require 'stringio'
+require 'fileutils'
+require 'generator_spec'
 
 I18n.enforce_available_locales = true

data/spec/test_doubles.rb

@@ -102,6 +102,36 @@ module TestDoubles
     end
   end
 
+  class NotExplicitlyReturningContextOrganizer
+    extend LightService::Organizer
+
+    def self.call(context)
+      context[:foo] = [1, 2, 3]
+    end
+  end
+
+  class NestingOrganizer
+    extend LightService::Organizer
+
+    def self.call(context)
+      with(context).reduce(actions)
+    end
+
+    def self.actions
+      [NotExplicitlyReturningContextOrganizer, NestedAction]
+    end
+  end
+
+  class NestedAction
+    extend LightService::Action
+
+    expects :foo
+
+    executed do |context|
+      context[:bar] = context.foo
+    end
+  end
+
   class MakesTeaWithMilkAction
     extend LightService::Action
     expects :tea, :milk
@@ -239,6 +269,18 @@ module TestDoubles
     end
   end
 
+  class AddsOne
+    extend LightService::Organizer
+
+    def call(ctx)
+      with(ctx).reduce(actions)
+    end
+
+    def self.actions
+      [AddsOneAction]
+    end
+  end
+
   class AddsOneAction
     extend LightService::Action
     expects :number
@@ -513,4 +555,39 @@ module TestDoubles
       ctx.total += ctx.number
     end
   end
+
+  class CapitalizeMessage
+    extend LightService::Action
+    expects :a_message
+    promises :final_message
+
+    executed do |ctx|
+      ctx.final_message = ctx.a_message.upcase
+    end
+  end
+
+  class AnOrganizerThatAddsToContext
+    extend LightService::Organizer
+    def self.call
+      with.reduce(actions)
+    end
+
+    def self.actions
+      [add_to_context(
+        :strongest_avenger => 'The Thor',
+        :last_jedi => 'Rey'
+      )]
+    end
+  end
+
+  class AnOrganizerThatAddsAliases
+    extend LightService::Organizer
+    def self.call
+      with(:foo => :bar).reduce(actions)
+    end
+
+    def self.actions
+      [add_aliases(:foo => :baz)]
+    end
+  end
 end