trailblazer-operation 0.4.1 → 0.6.0

data/test/class_dependencies_test.rb

@@ -1,16 +1,15 @@
 require "test_helper"
 
 class ClassDependenciesTest < Minitest::Spec
-
   #- Operation[] and Operation[]=
 
-  class Index < Trailblazer::Operation
-    extend ClassDependencies
+  # class Index < Trailblazer::Operation
+  #   extend ClassDependencies
 
-    self["model.class"] = Module
+  #   self["model.class"] = Module
 
-    step ->(options, **) { options["a"] = options["model.class"] }
-  end
+  #   step ->(options, **) { options["a"] = options["model.class"] }
+  # end
 
-  it { Index.({}).inspect("a", "model.class").must_equal %{<Result:true [Module, Module] >} }
+  it { skip "https://trello.com/c/t8bUJlqb/25-op-class-dependencies"; Index.({}).inspect("a", "model.class").must_equal %{<Result:true [Module, Module] >} }
 end

data/test/docs/doormat_test.rb

@@ -5,7 +5,7 @@ class TemplateWithGroupTest < Minitest::Spec
 
   #:template
   class Memo::Operation < Trailblazer::Operation
-    step :log_call,  group: :start
+    step :log_call, group: :start
     step :log_success,  group: :end, before: "End.success"
     fail :log_errors,   group: :end, before: "End.failure"
     #~tmethods
@@ -49,8 +49,10 @@ class TemplateWithGroupTest < Minitest::Spec
   #:template-user end
 
   # it { pp F['__sequence__'].to_a }
-  it { Memo::Create.(params: {}, "b_return" => false,
-                                  ).inspect("row").must_equal %{<Result:true [[:a, :l, :b, :c, :z]] >} }
+  it {
+    skip
+    Memo::Create.(params: {}, "b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :l, :b, :c, :z]] >}
+  }
 end
 
 class DoormatWithGroupTest < Minitest::Spec
@@ -59,12 +61,12 @@ class DoormatWithGroupTest < Minitest::Spec
   #:doormat-group
   class Memo::Create < Trailblazer::Operation
     step :create_model
-    step :log_success,  group: :end, before: "End.success"
+    step :log_success, group: :end, before: "End.success"
 
     step :validate
     step :save
 
-    fail :log_errors,   group: :end, before: "End.failure"
+    fail :log_errors, group: :end, before: "End.failure"
     #~methods
     def create_model(options, **)
       options["row"] = [:a]
@@ -93,8 +95,10 @@ class DoormatWithGroupTest < Minitest::Spec
   #:doormat-group end
 
   # it { pp F['__sequence__'].to_a }
-  it { Memo::Create.(params: {}, "b_return" => false,
-                                  ).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >} }
+  it {
+    skip
+    Memo::Create.(params: {}, "b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >}
+  }
 end
 
 class DoormatStepDocsTest < Minitest::Spec
@@ -137,8 +141,7 @@ class DoormatStepDocsTest < Minitest::Spec
   #:doormat-before end
 
   # it { pp F['__sequence__'].to_a }
-  it { Memo::Create.(params: {}, "b_return" => false,
-                                  ).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >} }
+  it { Memo::Create.(params: {}, "b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >} }
 end
 
 class DoormatInheritanceTest < Minitest::Spec
@@ -183,7 +186,5 @@ class DoormatInheritanceTest < Minitest::Spec
   #:doormat-before-inheritance-sub end
 
   # it { pp F['__sequence__'].to_a }
-  it { Create.({}, "b_return" => false,
-                                  ).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >} }
+  it { Create.("b_return" => false).inspect("row").must_equal %{<Result:true [[:a, :b, :c, :z]] >} }
 end
-

data/test/docs/macaroni_test.rb

@@ -8,19 +8,17 @@ class MacaroniTaskBuilderTest < Minitest::Spec
   end
 
   #:create
-  class Memo::Create < Trailblazer::Operation
+  class Memo::Create < Trailblazer::Operation(step_interface_builder: Trailblazer::Operation::Railway::KwSignature)
     #~ign
-    Normalizer, _ = Trailblazer::Activity::Magnetic::Normalizer.build( task_builder: Railway::KwSignature, pipeline: Railway::Normalizer::Pipeline )
-
-    step :create_model, normalizer: Normalizer
-    step :save,         normalizer: Normalizer
+    step :create_model
+    step :save
     #~ign end
     #~methods
-    def create_model( params:, options:, ** )
-      options[:model] = Memo.new( title: params[:title] )
+    def create_model(params:, options:, **)
+      options[:model] = Memo.new(title: params[:title])
     end
 
-    def save( model:, ** )
+    def save(model:, **)
       model.save
     end
     #~methods end
@@ -28,6 +26,6 @@ class MacaroniTaskBuilderTest < Minitest::Spec
   #:create end
 
   it "allows optional macaroni call style" do
-    Memo::Create.( params: { title: "Wow!" } ).inspect(:model).must_equal %{<Result:true [#<struct MacaroniTaskBuilderTest::Memo title=\"!woW\">] >}
+    Memo::Create.(params: {title: "Wow!"}).inspect(:model).must_equal %{<Result:true [#<struct MacaroniTaskBuilderTest::Memo title=\"!woW\">] >}
   end
 end

data/test/docs/operation_test.rb

@@ -1,23 +1,88 @@
 require "test_helper"
 
 class DocsActivityTest < Minitest::Spec
-  Memo = Struct.new(:body)
+  Memo = Struct.new(:text)
 
+  #:memo
   class Memo::Create < Trailblazer::Operation
     step :create_model
+
     def create_model(ctx, params:, **)
-      ctx[:model] = Memo.new(params[:body])
+      ctx[:model] = Memo.new(params[:text])
     end
   end
+  #:memo end
+
+  it "what" do
+    #:call-circuit
+    ctx = {params: {text: "Enjoy an IPA"}}
+    signal, (ctx, _) = Memo::Create.([ctx, {}], {})
+
+    puts signal #=> #<Trailblazer::Activity::Railway::End::Success semantic=:success>
+    #:call-circuit end
+
+    signal.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+  end
 
   #:describe
   describe Memo::Create do
     it "creates a sane Memo instance" do
-      result = Memo::Create.( params: { body: "Enjoy an IPA" } )
+      #:call-public
+      result = Memo::Create.(params: {text: "Enjoy an IPA"})
+
+      puts result.success?    #=> true
+
+      model = result[:model]
+      puts model.text         #=> "Enjoy an IPA"
+      #:call-public end
 
       result.success?.must_equal true
-      result[:model].body.must_equal "Enjoy an IPA"
+      result[:model].text.must_equal "Enjoy an IPA"
     end
   end
   #:describe end
+
+  it do
+    module J
+      Memo = Struct.new(:id)
+
+      #:op
+      class Create < Trailblazer::Operation
+        #~flow
+        step :validate, fast_track: true
+        fail :log_error
+        step :create
+        #~flow end
+
+        #~mod
+        def create(ctx, **)
+          ctx[:model] = Memo.new
+        end
+        #~rest
+        def validate(ctx, params:, **)
+          ctx[:input] # true/false
+          true
+        end
+
+        def log_error(ctx, params:, **)
+          logger.error("wrong params: #{params.inspect}")
+          true
+        end
+        #~rest
+        #~mod end
+      end
+      #:op end
+    end
+
+    ctx = {params: {text: "Hydrate!"}}
+    result = J::Create.(ctx)
+
+    result.success?.must_equal true
+    # ctx.inspect.must_equal %{{:params=>{:text=>\"Hydrate!\"}, :create=>true}}
+
+    #:op-result
+    result.success? #=> true
+    result[:model]  #=> #<Memo ..>
+    #:op-result end
+  end
 end

data/test/docs/wiring_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 
 class WiringDocsTest < Minitest::Spec
   class Memo
-    def initialize(options={})
+    def initialize(_options = {})
       @options
     end
 
@@ -16,6 +16,8 @@ class WiringDocsTest < Minitest::Spec
   # _"Everything's a memo."_
 
   module Step
+    Memo = Class.new(WiringDocsTest::Memo)
+
     #:memo-op
     class Memo::Create < Trailblazer::Operation
       step :create_model
@@ -28,34 +30,41 @@ class WiringDocsTest < Minitest::Spec
       #~memo-methods
       def create_model(options, **)
       end
+
       def validate(options, **)
       end
+
       def assign_errors(options, **)
       end
+
       def index(options, **)
       end
+
       def uuid(options, **)
       end
+
       def save(options, **)
       end
+
       def log_errors(options, **)
       end
       #~memo-methods end
     end
     #:memo-op end
-
   end
 
   it do
-    result = Memo::Create.( text: "Punk is not dead." )
+    Step::Memo::Create.(text: "Punk is not dead.")
   end
 
 
   module PassFast
+    Memo = Class.new(WiringDocsTest::Memo)
+
     #:pf-op
     class Memo::Create < Trailblazer::Operation
       step :create_model
-      step :validate,     pass_fast: true
+      step :validate, pass_fast: true
       fail :assign_errors
       step :index
       pass :uuid
@@ -64,25 +73,32 @@ class WiringDocsTest < Minitest::Spec
       #~pf-methods
       def create_model(options, **)
       end
+
       def validate(options, **)
       end
+
       def assign_errors(options, **)
       end
+
       def index(options, **)
       end
+
       def uuid(options, **)
       end
+
       def save(options, **)
       end
+
       def log_errors(options, **)
       end
       #~pf-methods end
     end
     #:pf-op end
-
   end
 
   module FailFast
+    Memo = Class.new(WiringDocsTest::Memo)
+
     #:ff-op
     class Memo::Create < Trailblazer::Operation
       step :create_model
@@ -95,25 +111,33 @@ class WiringDocsTest < Minitest::Spec
       #~ff-methods
       def create_model(options, **)
       end
+
       def validate(options, **)
       end
+
       def assign_errors(options, **)
       end
+
       def index(options, **)
       end
+
       def uuid(options, **)
       end
+
       def save(options, **)
       end
+
       def log_errors(options, **)
       end
       #~ff-methods end
     end
     #:ff-op end
-
   end
 
+  #rubocop:disable Lint/DuplicateMethods
   module FailFast
+    Memo = Class.new(WiringDocsTest::Memo)
+
     #:ff-step-op
     class Memo::Create < Trailblazer::Operation
       step :create_model
@@ -126,32 +150,39 @@ class WiringDocsTest < Minitest::Spec
       #~ff-step-methods
       def create_model(options, **)
       end
+
       def validate(options, **)
       end
+
       def assign_errors(options, **)
       end
+
       def index(options, **)
       end
+
       def uuid(options, **)
       end
+
       def save(options, **)
       end
+
       def log_errors(options, **)
       end
       #~ff-step-methods end
     end
     #:ff-step-op end
   end
+#rubocop:enable Lint/DuplicateMethods
 
 =begin
 describe all options :pass_fast, :fast_track and emiting signals directly, like Left.
 =end
   module FastTrack
-    class Memo < WiringDocsTest::Memo; end
+    Memo = Class.new(WiringDocsTest::Memo)
 
     #:ft-step-op
     class Memo::Create < Trailblazer::Operation
-      step :create_model,  fast_track: true
+      step :create_model, fast_track: true
       step :validate
       fail :assign_errors, fast_track: true
       step :index
@@ -160,34 +191,40 @@ describe all options :pass_fast, :fast_track and emiting signals directly, like
       fail :log_errors
       #~ft-step-methods
       #:ft-create
-      def create_model(options, create_empty_model:false, **)
+      def create_model(options, create_empty_model: false, **)
         options[:model] = Memo.new
         create_empty_model ? Railway.pass_fast! : true
       end
+
       #:ft-create end
       #:signal-validate
-      def validate(options, params: {}, **)
+      def validate(_options, params: {}, **)
         if params[:text].nil?
           Trailblazer::Activity::Left  #=> left track, failure
         else
           Trailblazer::Activity::Right #=> right track, success
         end
       end
+
       #:signal-validate end
       def assign_errors(options, model:, **)
         options[:errors] = "Something went wrong!"
 
         model.id.nil? ? Railway.fail_fast! : false
       end
-      def index(options, model:, **)
+
+      def index(_options, *)
         true
       end
-      def uuid(options, **)
+
+      def uuid(_options, **)
         true
       end
-      def save(options, model:, **)
+
+      def save(_options, model:, **)
         model.id = 1
       end
+
       def log_errors(options, **)
       end
       #~ft-step-methods end
@@ -196,7 +233,7 @@ describe all options :pass_fast, :fast_track and emiting signals directly, like
 
     class Memo::Create2 < Memo::Create
       #:signalhelper-validate
-      def validate(options, params: {}, **)
+      def validate(_options, params: {}, **)
         if params[:text].nil?
           Railway.fail! #=> left track, failure
         else
@@ -210,7 +247,7 @@ describe all options :pass_fast, :fast_track and emiting signals directly, like
   it "runs #create_model, only" do
     Memo = FastTrack::Memo
     #:ft-call
-    result = Memo::Create.( create_empty_model: true )
+    result = Memo::Create.(create_empty_model: true)
     puts result.success?        #=> true
     puts result[:model].inspect #=> #<Memo text=nil>
     #:ft-call end
@@ -222,7 +259,7 @@ describe all options :pass_fast, :fast_track and emiting signals directly, like
   it "fast-tracks in #assign_errors" do
     Memo = FastTrack::Memo
     #:ft-call-err
-    result = Memo::Create.( {} )
+    result = Memo::Create.({})
     puts result.success?          #=> false
     puts result[:model].inspect   #=> #<Memo text=nil>
     puts result[:errors].inspect  #=> "Something went wrong!"
@@ -235,7 +272,7 @@ describe all options :pass_fast, :fast_track and emiting signals directly, like
 
   it "goes till #save by emitting signals directly" do
     Memo = FastTrack::Memo
-    result = Memo::Create.( params: { text: "Punk is not dead!" } )
+    result = Memo::Create.(params: {text: "Punk is not dead!"})
     result.success?.must_equal true
     result[:model].id.must_equal 1
     result[:errors].must_be_nil
@@ -243,124 +280,13 @@ describe all options :pass_fast, :fast_track and emiting signals directly, like
 
   it "goes till #save by using signal helper" do
     Memo = FastTrack::Memo
-    result = Memo::Create2.( params: { text: "Punk is not dead!" } )
+    result = Memo::Create2.(params: {text: "Punk is not dead!"})
     result.success?.must_equal true
     result[:model].id.must_equal 1
     result[:errors].must_be_nil
   end
 end
 
-=begin
-:before, :after, :replace, :delete, :group, :id
-=end
-class WiringsDocSeqOptionsTest < Minitest::Spec
-  module Id
-    class Memo < WiringDocsTest::Memo; end
-
-    #:id
-    class Memo::Create < Trailblazer::Operation
-      step :create_model, id: "create_memo"
-      step :validate,     id: "validate_params"
-      step :save
-      #~id-methods
-      def create_model(options, **)
-      end
-      def validate(options, **)
-      end
-      def save(options, **)
-      end
-      #~id-methods end
-    end
-    #:id end
-
-    #:delete
-    class Memo::Create::Admin < Memo::Create
-      step nil, delete: "validate_params", id: ""
-    end
-    #:delete end
-
-    #:before
-    class Memo::Create::Authorized < Memo::Create
-      step :policy, before: "create_memo"
-      #~before-methods
-      def policy(options, **)
-      end
-      #~before-methods end
-    end
-    #:before end
-
-    #:after
-    class Memo::Create::Logging < Memo::Create
-      step :logger, after: "validate_params"
-      #~after-methods
-      def logger(options, **)
-      end
-      #~after-methods end
-    end
-    #:after end
-
-    #:replace
-    class Memo::Update < Memo::Create
-      step :find_model, replace: "create_memo", id: "update_memo"
-      #~replace-methods
-      def find_model(options, **)
-      end
-      #~replace-methods end
-    end
-    #:replace end
-  end
-
-  it ":id shows up in introspect" do
-    Memo = Id::Memo
-    #:id-inspect
-    Trailblazer::Operation.introspect( Memo::Create )
-    #=> [>create_memo,>validate_params,>save]
-    #:id-inspect end
-
-    Trailblazer::Operation.introspect( Memo::Create ).must_equal %{[>create_memo,>validate_params,>save]}
-  end
-
-  it ":delete removes step" do
-    Memo = Id::Memo
-    #:delete-inspect
-    Trailblazer::Operation.introspect( Memo::Create::Admin )
-    #=> [>create_model,>save]
-    #:delete-inspect end
-
-    Trailblazer::Operation.introspect( Memo::Create::Admin ).must_equal %{[>create_memo,>save]}
-  end
-
-  it ":before inserts" do
-    Memo = Id::Memo
-    #:before-inspect
-    Trailblazer::Operation.introspect( Memo::Create::Authorized )
-    #=> [>create_model,>save]
-    #:before-inspect end
-
-    Trailblazer::Operation.introspect( Memo::Create::Authorized ).must_equal %{[>policy,>create_memo,>validate_params,>save]}
-  end
-
-  it ":after inserts" do
-    Memo = Id::Memo
-    #:after-inspect
-    Trailblazer::Operation.introspect( Memo::Create::Logging )
-    #=> [>create_memo,>validate_params,>logger,>save]
-    #:after-inspect end
-
-    Trailblazer::Operation.introspect( Memo::Create::Logging ).must_equal %{[>create_memo,>validate_params,>logger,>save]}
-  end
-
-  it ":replace inserts" do
-    Memo = Id::Memo
-    #:replace-inspect
-    Trailblazer::Operation.introspect( Memo::Update )
-    #=> [>update_memo,>validate_params,>save]
-    #:replace-inspect end
-
-    Trailblazer::Operation.introspect( Memo::Update ).must_equal %{[>update_memo,>validate_params,>save]}
-  end
-end
-
 # @see https://github.com/trailblazer/trailblazer/issues/190#issuecomment-326992255
 class WiringsDocRecoverTest < Minitest::Spec
   Memo = WiringDocsTest::Memo
@@ -396,27 +322,27 @@ class WiringsDocRecoverTest < Minitest::Spec
   let(:my_image) { "beautiful landscape" }
 
   it "works for S3" do
-    result = Memo::Upload.( image: my_image, s3: true )
+    result = Memo::Upload.(image: my_image, s3: true)
 
-    [ result.success?, result[:s3], result[:azure], result[:b2], result[:problem] ].must_equal [ true, true, nil, nil, nil ]
+    [result.success?, result[:s3], result[:azure], result[:b2], result[:problem]].must_equal [true, true, nil, nil, nil]
   end
 
   it "works for Azure" do
-    result = Memo::Upload.( image: my_image, azure: true, s3: false )
+    result = Memo::Upload.(image: my_image, azure: true, s3: false)
 
-    [ result.success?, result[:s3], result[:azure], result[:b2], result[:problem] ].must_equal [ true, false, true, nil, nil ]
+    [result.success?, result[:s3], result[:azure], result[:b2], result[:problem]].must_equal [true, false, true, nil, nil]
   end
 
   it "works for B2" do
-    result = Memo::Upload.( image: my_image, b2: true, azure: false, s3: false )
+    result = Memo::Upload.(image: my_image, b2: true, azure: false, s3: false)
 
-    [ result.success?, result[:s3], result[:azure], result[:b2], result[:problem] ].must_equal [ true, false, false, true, nil ]
+    [result.success?, result[:s3], result[:azure], result[:b2], result[:problem]].must_equal [true, false, false, true, nil]
   end
 
   it "fails for all" do
-    result = Memo::Upload.( image: my_image, b2: false, azure: false, s3: false )
+    result = Memo::Upload.(image: my_image, b2: false, azure: false, s3: false)
 
-    [ result.success?, result[:s3], result[:azure], result[:b2], result[:problem] ].must_equal [ false, false, false, false, "All uploads failed." ]
+    [result.success?, result[:s3], result[:azure], result[:b2], result[:problem]].must_equal [false, false, false, false, "All uploads failed."]
   end
 end
 
@@ -425,11 +351,11 @@ class WiringsDocCustomConnectionTest < Minitest::Spec
 
   #:target-id
   class Memo::Upload < Trailblazer::Operation
-    step :new?, Output(:failure) => "index"
+    step :new?, Output(:failure) => Id(:index)
     step :upload
     step :validate
     fail :validation_error
-    step :index, id: "index"
+    step :index, id: :index
     #~target-id-methods
     def new?(options, is_new:, **)
       options[:new?] = is_new
@@ -439,7 +365,7 @@ class WiringsDocCustomConnectionTest < Minitest::Spec
       options[:upload] = true
     end
 
-    def validate(options, validate:true, **)
+    def validate(options, validate: true, **)
       options[:validate] = validate
     end
 
@@ -457,17 +383,17 @@ class WiringsDocCustomConnectionTest < Minitest::Spec
   let(:my_image) { "beautiful landscape" }
 
   it "works with new image" do
-    result = Memo::Upload.( image: my_image, is_new: true )
+    result = Memo::Upload.(image: my_image, is_new: true)
     result.inspect(:new?, :upload, :validate, :validation_error, :index).must_equal %{<Result:true [true, true, true, nil, true] >}
   end
 
   it "skips everything but index for existing image" do
-    result = Memo::Upload.( image: my_image, is_new: false )
+    result = Memo::Upload.(image: my_image, is_new: false)
     result.inspect(:new?, :upload, :validate, :validation_error, :index).must_equal %{<Result:true [false, nil, nil, nil, true] >}
   end
 
   it "fails in validation" do
-    result = Memo::Upload.( image: my_image, is_new: true, validate: false )
+    result = Memo::Upload.(image: my_image, is_new: true, validate: false)
     result.inspect(:new?, :upload, :validate, :validation_error, :index).must_equal %{<Result:false [true, true, false, true, nil] >}
   end
 end
@@ -479,22 +405,25 @@ class WiringsDocDeciderTest < Minitest::Spec
   class Memo::Upsert < Trailblazer::Operation
     step :find_model, Output(:failure) => Track(:create_route)
     step :update
-    step :create, magnetic_to: [:create_route]
+    step :create, magnetic_to: :create_route
     step :save
     #~methods
-    def find_model(options, id:nil, **)
+    def find_model(options, id: nil, **)
       options[:model] = Memo.find(id)
     end
 
-    def find_model(options, id:, **)
+    def find_model(options, id:, **) #rubocop:disable Lint/DuplicateMethods
       options[:find_model] = id
     end
+
     def update(options, **)
       options[:update] = true
     end
+
     def create(options, **)
       options[:create] = true
     end
+
     def save(options, **)
       options[:save] = true
     end
@@ -503,11 +432,11 @@ class WiringsDocDeciderTest < Minitest::Spec
   #:decider end
 
   it "goes the create route" do
-    Memo::Upsert.( id: false ).inspect(:find_model, :update, :create, :save).must_equal %{<Result:true [false, nil, true, true] >}
+    Memo::Upsert.(id: false).inspect(:find_model, :update, :create, :save).must_equal %{<Result:true [false, nil, true, true] >}
   end
 
   it "goes the update route" do
-    Memo::Upsert.( id: true ).inspect(:find_model, :update, :create, :save).must_equal %{<Result:true [true, true, nil, true] >}
+    Memo::Upsert.(id: true).inspect(:find_model, :update, :create, :save).must_equal %{<Result:true [true, true, nil, true] >}
   end
 end
 
@@ -521,19 +450,22 @@ class WiringsDocEndTest < Minitest::Spec
     fail :db_error
     step :save
     #~methods
-    def find_model(options, id:nil, **)
+    def find_model(options, id: nil, **)
       options[:model] = Memo.find(id)
     end
 
-    def find_model(options, id:, **)
+    def find_model(options, id:, **) #rubocop:disable Lint/DuplicateMethods
       options[:find_model] = id
     end
+
     def update(options, update: true, **)
       options[:update] = update
     end
+
     def db_error(options, **)
       options[:db_error] = 1
     end
+
     def save(options, **)
       options[:save] = true
     end
@@ -542,17 +474,17 @@ class WiringsDocEndTest < Minitest::Spec
   #:end end
 
   it "goes success path" do
-    Memo::Update.( id: true ).inspect(:find_model, :update, :save, :db_error).must_equal %{<Result:true [true, true, true, nil] >}
+    Memo::Update.(id: true).inspect(:find_model, :update, :save, :db_error).must_equal %{<Result:true [true, true, true, nil] >}
   end
 
   it "errors out on End.model_not_found" do
-    result = Memo::Update.( id: false )
+    result = Memo::Update.(id: false)
     result.inspect(:find_model, :update, :save, :db_error).must_equal %{<Result:false [false, nil, nil, nil] >}
     result.event.to_h.must_equal(semantic: :model_not_found)
   end
 
   it "takes normal error track" do
-    result = Memo::Update.( id: true, update: false )
+    result = Memo::Update.(id: true, update: false)
     result.inspect(:find_model, :update, :save, :db_error).must_equal %{<Result:false [true, false, nil, 1] >}
     result.event.to_h.must_equal(semantic: :failure)
   end