trailblazer 2.1.0.rc1 → 2.1.0.rc12

data/test/dsl/contract_test.rb

@@ -1,294 +0,0 @@
-require "test_helper"
-require "trailblazer/operation/contract"
-
-# contract Constant # new
-# contract Constant, inherit: true # extend existing
-# contract do end # extend existing || new
-# contract Constant do .. end # new, extend new
-
-class DslContractTest < MiniTest::Spec
-  module Call
-    def call(params)
-      validate(params, model: model=OpenStruct.new) { contract.sync }
-      model
-    end
-
-    def self.included(includer)
-      includer.step Trailblazer::Operation::Model( OpenStruct, :new )
-      includer.step Trailblazer::Operation::Contract::Build()
-      includer.step Trailblazer::Operation::Contract::Validate()
-      includer.step Trailblazer::Operation::Contract::Persist( method: :sync )
-      # includer.> ->(op, *) { op["x"] = [] }
-    end
-  end
-
-  # ---
-  # Operation::["contract.default.class"]
-  # Operation::["contract.default.class"]=
-  class Create < Trailblazer::Operation
-    include Contract
-    self["contract.default.class"] = String
-  end
-
-  # reader method.
-  # no subclassing.
-  it { Create["contract.default.class"].must_equal String }
-
-  class CreateOrFind < Create
-  end
-
-  # no inheritance with setter.
-  it { CreateOrFind["contract.default.class"].must_equal nil }
-
-  # ---
-  # Op::contract Constant
-  class Update < Trailblazer::Operation
-    class IdContract < Reform::Form
-      property :id
-    end
-
-    extend Contract::DSL
-    contract IdContract
-
-    include Call
-  end
-
-  # UT: subclasses contract.
-  it { Update["contract.default.class"].superclass.must_equal Update::IdContract }
-  # IT: only knows `id`.
-  it { Update.(params: {id: 1, title: "Coaster"})[:model].inspect.must_equal %{#<OpenStruct id=1>} }
-
-  # Op::contract with inheritance
-  # no ::contract call.
-  class Upgrade < Update
-  end
-
-  # UT: subclasses contract but doesn't share with parent.
-  it { Upgrade["contract.default.class"].superclass.must_equal Update::IdContract }
-  it { Upgrade["contract.default.class"].wont_equal Update["contract.default.class"] }
-  # IT: only knows `id`.
-  it { Upgrade.(params: {id: 1, title: "Coaster"})[:model].inspect.must_equal %{#<OpenStruct id=1>} }
-
-  # ::contract B overrides old A contract.
-  # this makes sure when calling contract(Constant), the old class gets wiped and is replaced with the new constant.
-  class Upsert < Update
-    class TitleContract < Reform::Form
-      property :title
-    end
-
-    contract TitleContract
-  end
-
-  # UT: subclasses contract.
-  it { Upsert["contract.default.class"].superclass.must_equal Upsert::TitleContract }
-  # IT: only knows `title`.
-  it { Upsert.(params: {id: 1, title: "Coaster"})[:model].inspect.must_equal %{#<OpenStruct title="Coaster">} }
-
-  # ::contract B do ..end overrides and extends new.
-  # using a constant will wipe out the existing class.
-  class Upside < Update
-    contract Upsert::TitleContract do
-      property :id
-    end
-  end
-
-  # UT: subclasses contract.
-  it { Upside["contract.default.class"].superclass.must_equal Upsert::TitleContract }
-  # IT: only knows `title`.
-  it { Upside.(params: {id: 1, title: "Coaster"})[:model].inspect.must_equal %{#<OpenStruct title="Coaster", id=1>} }
-
-
-
-  #---
-  # contract do .. end
-  # (with block)
-  class Delete < Trailblazer::Operation
-    include Call
-    extend Contract::DSL
-    contract do
-      property :title
-    end
-  end
-
-  # UT: contract path is "contract.default.class"
-  it { Delete["contract.default.class"].definitions.keys.must_equal ["title"] }
-  # IT: knows `title`.
-  it { Delete.(params: {id: 1, title: "Coaster"})[:model].inspect.must_equal %{#<OpenStruct title=\"Coaster\">} }
-
-  class Wipe < Trailblazer::Operation
-    extend Contract::DSL
-
-    self["x"] = contract do end
-  end
-  # UT: ::contract returns form class
-  it { Wipe["x"].superclass.must_equal Reform::Form }
-
-  # subsequent calls merge.
-  class Remove < Trailblazer::Operation
-    extend Contract::DSL
-    include Call
-
-    contract do
-      property :title
-    end
-
-    contract do
-      property :id
-    end
-  end
-
-  # IT: knows `title` and `id`, since contracts get merged.
-  it { Remove.(params: {id: 1, title: "Coaster"})[:model].inspect.must_equal %{#<OpenStruct title=\"Coaster\", id=1>} }
-
-
-
-
-
-
-  # Operation::["contract.default.class"]
-  # Operation::["contract.default.class"]=
-  describe %{Operation::["contract.default.class"]} do
-
-    class Update2 < Trailblazer::Operation
-      self["contract.default.class"] = String
-    end
-
-    it { Update2["contract.default.class"].must_equal String }
-  end
-
-  describe "inheritance across operations" do
-    # inheritance
-    class Operation < Trailblazer::Operation
-      extend Contract::DSL
-      contract do
-        property :title
-        property :band
-      end
-
-      class JSON < self
-        contract do # inherit Contract
-          property :genre, validates: {presence: true}
-          property :band, virtual: true
-        end
-      end
-
-      class XML < self
-      end
-    end
-
-    # inherits subclassed Contract.
-    it { Operation["contract.default.class"].wont_equal Operation::JSON["contract.default.class"] }
-    it { Operation::XML["contract.default.class"].superclass.must_equal Reform::Form }
-
-    it do
-      form = Operation["contract.default.class"].new(OpenStruct.new)
-      form.validate({})#.must_equal true
-      form.errors.to_s.must_equal "{}"
-
-      form = Operation::JSON["contract.default.class"].new(OpenStruct.new)
-      form.validate({})#.must_equal true
-      form.errors.to_s.must_equal "{:genre=>[\"can't be blank\"]}"
-    end
-
-    # allows overriding options
-    it do
-      form = Operation::JSON["contract.default.class"].new(song = OpenStruct.new)
-      form.validate({genre: "Punkrock", band: "Osker"}).must_equal true
-      form.sync
-
-      song.genre.must_equal "Punkrock"
-      song.band.must_equal nil
-    end
-  end
-
-  describe "Op.contract CommentForm" do
-    class SongForm < Reform::Form
-      property :songTitle, validates: {presence: true}
-    end
-
-    class OpWithExternalContract < Trailblazer::Operation
-      extend Contract::DSL
-      contract SongForm
-      include Call
-    end
-
-    it { OpWithExternalContract.(params: {"songTitle"=> "Monsterparty"})["contract.default"].songTitle.must_equal "Monsterparty" }
-  end
-
-  describe "Op.contract CommentForm do .. end" do
-    class DifferentSongForm < Reform::Form
-      property :songTitle, validates: {presence: true}
-    end
-
-    class OpNotExtendingContract < Trailblazer::Operation
-      extend Contract::DSL
-      contract DifferentSongForm
-      include Call
-    end
-
-    class OpExtendingContract < Trailblazer::Operation
-      extend Contract::DSL
-      contract DifferentSongForm do
-        property :genre
-      end
-      include Call
-    end
-
-    # this operation copies DifferentSongForm and shouldn't have `genre`.
-    it do
-      contract = OpNotExtendingContract.(params: {"songTitle"=>"Monsterparty", "genre"=>"Punk"})["contract.default"]
-      contract.songTitle.must_equal "Monsterparty"
-      assert_raises(NoMethodError) { contract.genre }
-    end
-
-    # this operation copies DifferentSongForm and extends it with the property `genre`.
-    it do
-      contract = OpExtendingContract.(params: {"songTitle"=>"Monsterparty", "genre"=>"Punk"})["contract.default"]
-      contract.songTitle.must_equal "Monsterparty"
-      contract.genre.must_equal "Punk"
-    end
-
-    # of course, the original contract wasn't modified, either.
-    it do
-      assert_raises(NoMethodError) { DifferentSongForm.new(OpenStruct.new).genre }
-    end
-  end
-
-  describe "Op.contract :name, Form" do
-    class Follow < Trailblazer::Operation
-      ParamsForm = Class.new
-
-      extend Contract::DSL
-      contract :params, ParamsForm
-    end
-
-    it { Follow["contract.params.class"].superclass.must_equal Follow::ParamsForm }
-  end
-
-  describe "Op.contract :name do..end" do
-    class Unfollow < Trailblazer::Operation
-      extend Contract::DSL
-      contract :params do
-        property :title
-      end
-    end
-
-    it { Unfollow["contract.params.class"].superclass.must_equal Reform::Form }
-  end
-
-  # multiple ::contract calls.
-  describe "multiple ::contract calls" do
-    class Star < Trailblazer::Operation
-      extend Contract::DSL
-      contract do
-        property :title
-      end
-
-      contract do
-        property :id
-      end
-    end
-
-    it { Star["contract.default.class"].definitions.keys.must_equal ["title", "id"]  }
-  end
-end

data/test/module_test.rb

@@ -1,100 +0,0 @@
-# require 'test_helper'
-# require "trailblazer/operation/module"
-# require "trailblazer/operation/callback"
-# require "trailblazer/operation/contract"
-
-# class OperationModuleTest < MiniTest::Spec
-#   Song = Struct.new(:name, :artist)
-#   Artist = Struct.new(:id, :full_name)
-
-#   class Create < Trailblazer::Operation
-#     include Trailblazer::Operation::Callback
-#     include Contract::Explicit
-
-#     contract do
-#       property :name
-#       property :artist, populate_if_empty: Artist do
-#         property :id
-#       end
-#     end
-
-#     callback do
-#       on_change :notify_me!
-#     end
-
-#     attr_reader :model
-#     def call(params)
-#       self["model"] = Song.new
-
-#       validate(params, model: self["model"]) do
-#         contract.sync
-
-#         dispatch!
-#       end
-
-#       self
-#     end
-
-#     def dispatched
-#       self["dispatched"] ||= []
-#     end
-
-#   private
-#     def notify_me!(*)
-#       dispatched << :notify_me!
-#     end
-#   end
-
-
-#   module SignedIn
-#     include Trailblazer::Operation::Module
-
-#     contract do
-#       property :artist, inherit: true do
-#         property :full_name
-
-#         puts definitions.inspect
-#       end
-#     end
-
-#     callback do
-#       on_change :notify_you!
-#     end
-
-#     def notify_you!(*)
-#       dispatched << :notify_you!
-#     end
-#   end
-
-
-#   class Update < Create
-#     callback do
-#       on_change :notify_them!
-#     end
-
-#     include SignedIn
-
-#     def notify_them!(*)
-#       dispatched << :notify_them!
-#     end
-#   end
-
-
-#   it do
-#     op = Create.({name: "Feelings", artist: {id: 1, full_name: "The Offspring"}})
-
-#     op["dispatched"].must_equal [:notify_me!]
-#     op["model"].name.must_equal "Feelings"
-#     op["model"].artist.id.must_equal 1
-#     op["model"].artist.full_name.must_be_nil # property not declared.
-#   end
-
-#   it do
-#     op = Update.({name: "Feelings", artist: {id: 1, full_name: "The Offspring"}})
-
-#     op["dispatched"].must_equal [:notify_me!, :notify_them!, :notify_you!]
-#     op["model"].name.must_equal "Feelings"
-#     op["model"].artist.id.must_equal 1
-#     op["model"].artist.full_name.must_equal "The Offspring" # property declared via Module.
-#   end
-# end

data/test/variables_test.rb

@@ -1,159 +0,0 @@
-require "test_helper"
-
-class VariablesTest < Minitest::Spec
-  # Nested op copies values and modifies/amplifies some of them.
-  class Whistleblower < Trailblazer::Operation
-    step ->(options, public_opinion:, **) { options["edward.public_opinion"] = public_opinion.upcase }        , id: "edward.public_opinion"
-    step ->(options, secret:, **)         { options["edward.secret"]         = secret }                       , id: "edward.secret"
-    step ->(options, rumours:, **)        { rumours.nil? ? rumours : options["edward.rumours"] = rumours*2 }  , id: "edward.test"
-    pass ->(options, **)                  { options["edward.public_knowledge"] = options["public_knowledge"] }, id: "edward.read.public_knowledge"
-  end
-
-=begin
-  Everything public. options are simply passed on.
-
-  Both Org and Edward write and read from the same Context instance.
-=end
-  class OpenOrganization < Trailblazer::Operation
-    step ->(options, **) { options["rumours"] = "Bla" }
-    step ->(options, **) { options["secret"]  = "Psst!" }
-
-    step Nested( Whistleblower )
-
-    step ->(options, **) { options["org.rumours"] = options["edward.rumours"] } # what can we see from Edward?
-    step ->(options, **) { options["org.secret"]  = options["edward.secret"] }  # what can we see from Edward?
-  end
-
-  it do
-    result = OpenOrganization.("public_opinion" => "Freedom!", "public_knowledge" => true)
-
-    result.inspect("public_opinion", "rumours", "secret", "edward.public_opinion", "edward.secret", "edward.rumours", "edward.public_knowledge").
-      must_equal %{<Result:true ["Freedom!", "Bla", "Psst!", "FREEDOM!", "Psst!", "BlaBla", true] >}
-  end
-
-  #---
-  #- simply passes on the context
-  class ConsideringButOpenOrganization < Trailblazer::Operation
-    step ->(options, **) { options["rumours"] = "Bla" }
-    step ->(options, **) { options["secret"]  = "Psst!" }
-
-    step Nested( Whistleblower, input: :input! )
-
-    step ->(options, **) { options["org.rumours"] = options["edward.rumours"] } # what can we see from Edward?
-    step ->(options, **) { options["org.secret"]  = options["edward.secret"] }  # what can we see from Edward?
-
-    def input!(options, **)
-      options
-    end
-  end
-
-  it do
-    result = ConsideringButOpenOrganization.("public_opinion" => "Freedom!")
-
-    result.inspect("public_opinion", "rumours", "secret", "edward.public_opinion", "edward.secret", "edward.rumours").
-      must_equal %{<Result:true ["Freedom!", "Bla", "Psst!", "FREEDOM!", "Psst!", "BlaBla"] >}
-  end
-
-=begin
-  Explicitely passes allowed variables, only.
-
-  Edward can only read those three variables and can't see "public_knowledge" or others.
-=end
-  class ProtectedOrganization < ConsideringButOpenOrganization
-    def input!(options, **)
-      {
-         "public_opinion" => options["public_opinion"],
-         "secret"         => 0,
-         "rumours"        => 0.0
-      }
-    end
-  end
-
-  it do
-    result = ProtectedOrganization.( {}, "public_opinion" => "Freedom!", "public_knowledge" => true )
-
-    result.inspect("public_opinion", "rumours", "secret", "edward.public_opinion", "edward.secret", "edward.rumours", "edward.public_knowledge").
-      must_equal %{<Result:true ["Freedom!", "Bla", "Psst!", "FREEDOM!", 0, 0.0, nil] >}
-  end
-
-  #---
-  #- new ctx
-=begin
-:input produces a differing value for an existing key "secret"
-this should only be visible in the nested activity, and the original
-"secret" must be what it was before (unless :output would change that.)
-
-NOTE: i decided it's better to not even allow Context#merge because it
-defeats the idea of hiding information via :input and overcomplicates
-the scoping.
-=end
-  class EncryptedOrganization < ConsideringButOpenOrganization
-    def input!(options, **)
-      options.merge( "secret" => options["secret"]+"XxX" )
-    end
-  end
-
-  it do
-    skip "no options.merge until we know we actually need it"
-    result = EncryptedOrganization.("public_opinion" => "Freedom!")
-
-    result.inspect("public_opinion", "rumours", "secret", "edward.public_opinion", "edward.secret", "edward.rumours").
-      must_equal %{<Result:true ["Freedom!", "Bla", "Psst!", "FREEDOM!", "Psst!XxX", "BlaBla"] >}
-  end
-
-  # TODO write to options and get error
-
-=begin
-  Simply passes on the context to Edward, but applies an :output filter,
-  so that Org can't see several nested values such as "edward.public_knowledge"
-  or "edward.rumours" (see steps in #read-section).
-=end
-  class DiscreetOrganization < Trailblazer::Operation
-    step ->(options, **) { options["rumours"] = "Bla" },    id: "set.rumours"
-    step ->(options, **) { options["secret"]  = "Psst!" },   id: "set.secret"
-
-    step Nested( Whistleblower, input: :input!, output: :output! )
-
-    #read-section
-    pass ->(options, **) { options["org.rumours"] = options["edward.rumours"] }, id: "read.edward.rumours" # what can we see from Edward?
-    step ->(options, **) { options["org.secret"]  = options["edward.secret"] },  id: "read.edward.secret"  # what can we see from Edward?
-
-    def input!(options, **)
-      options
-    end
-
-    def output!(options, **)
-      {
-        "out.keys"    => options.keys,
-        "out.rumours" => options["edward.rumours"].slice(0..2),
-        "out.secret"  => options["edward.secret"].reverse,
-      }
-    end
-  end
-
-  it do
-    result = DiscreetOrganization.("public_opinion" => "Freedom!", "public_knowledge" => true)
-
-    result.inspect("public_opinion", "rumours", "secret", "edward.public_opinion", "edward.secret", "edward.rumours", "out.keys", "out.rumours", "out.secret", "org.rumours", "org.secret", "public_knowledge", "edward.public_knowledge").
-      must_equal %{<Result:false [\"Freedom!\", \"Bla\", \"Psst!\", nil, nil, nil, [\"edward.public_opinion\", \"edward.secret\", \"edward.rumours\", \"edward.public_knowledge\", \"rumours\", \"secret\", \"public_opinion\", \"public_knowledge\"], \"Bla\", \"!tssP\", nil, nil, true, nil] >}
-  end
-
-  it "with tracing" do
-    result = DiscreetOrganization.trace("public_opinion" => "Freedom!")
-
-    result.wtf.gsub(/0x\w+/, "").gsub(/\d+/, "").must_equal %{`-- VariablesTest::DiscreetOrganization
-    |-- Start.default
-    |-- set.rumours
-    |-- set.secret
-    |-- Nested(VariablesTest::Whistleblower)
-    |   |-- Start.default
-    |   |-- edward.public_opinion
-    |   |-- edward.secret
-    |   |-- edward.test
-    |   |-- edward.read.public_knowledge
-    |   `-- End.success
-    |-- read.edward.rumours
-    |-- read.edward.secret
-    `-- End.failure}
-  end
-end