trailblazer 1.1.1 → 2.1.0

data/test/operation/dsl/contract_test.rb

@@ -1,104 +0,0 @@
-require "test_helper"
-
-# ::contract builds Reform::Form class
-class DslContractTest < MiniTest::Spec
-  module SongProcess
-    def process(params)
-      validate(params, @model = OpenStruct.new)
-    end
-  end
-
-  describe "inheritance across operations" do
-    # inheritance
-    class Operation < Trailblazer::Operation
-      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
-    end
-
-    # inherits subclassed Contract.
-    it { Operation.contract_class.wont_equal Operation::JSON.contract_class }
-
-    it do
-      form = Operation.contract_class.new(OpenStruct.new)
-      form.validate({})#.must_equal true
-      form.errors.to_s.must_equal "{}"
-
-      form = Operation::JSON.contract_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_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" do
-    it { Operation.contract.must_equal Operation.contract_class }
-  end
-
-  describe "Op.contract CommentForm" do
-    class SongForm < Reform::Form
-      property :songTitle, validates: {presence: true}
-    end
-
-    class OpWithExternalContract < Trailblazer::Operation
-      contract SongForm
-      include SongProcess
-    end
-
-    it { OpWithExternalContract.("songTitle"=> "Monsterparty").contract.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
-      contract DifferentSongForm
-      include SongProcess
-    end
-
-    class OpExtendingContract < Trailblazer::Operation
-      contract DifferentSongForm do
-        property :genre
-      end
-      include SongProcess
-    end
-
-    # this operation copies DifferentSongForm and shouldn't have `genre`.
-    it do
-      contract = OpNotExtendingContract.("songTitle"=>"Monsterparty", "genre"=>"Punk").contract
-      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.("songTitle"=>"Monsterparty", "genre"=>"Punk").contract
-      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
-end

data/test/operation/dsl/representer_test.rb

@@ -1,142 +0,0 @@
-require "test_helper"
-require "representable/json"
-require "trailblazer/operation/representer"
-
-class DslRepresenterTest < MiniTest::Spec
-  module SongProcess
-    def process(params)
-      @model = OpenStruct.new(params)
-    end
-
-    def represented
-      model
-    end
-  end
-
-  describe "inheritance across operations" do
-    class Operation < Trailblazer::Operation
-      include Representer
-      include SongProcess
-
-      representer do
-        property :title
-      end
-
-      class JSON < self
-        representer do
-          property :band
-        end
-      end
-    end
-
-    it { Operation.(title: "Nothing To Lose", band: "Gary Moore").to_json.must_equal %{{"title":"Nothing To Lose"}} }
-    # only the subclass must have the `band` field, even though it's set in the original operation.
-    it { Operation::JSON.(title: "Nothing To Lose", band: "Gary Moore").to_json.must_equal %{{"title":"Nothing To Lose","band":"Gary Moore"}} }
-  end
-
-  describe "Op.representer" do
-    it { Operation.representer.must_equal Operation.representer_class }
-  end
-
-  describe "Op.representer CommentRepresenter" do
-    class SongRepresenter < Representable::Decorator
-      include Representable::JSON
-      property :songTitle
-    end
-
-    class OpWithExternalRepresenter < Trailblazer::Operation
-      include Representer
-      include SongProcess
-      representer SongRepresenter
-    end
-
-    it { OpWithExternalRepresenter.("songTitle"=>"Listen To Your Heartbeat").to_json.must_equal %{{"songTitle":"Listen To Your Heartbeat"}} }
-  end
-
-  describe "Op.representer CommentRepresenter do .. end" do
-    class HitRepresenter < Representable::Decorator
-      include Representable::JSON
-      property :title
-    end
-
-    class OpNotExtendingRepresenter < Trailblazer::Operation
-      include Representer
-      include SongProcess
-      representer HitRepresenter
-    end
-
-    class OpExtendingRepresenter < Trailblazer::Operation
-      include Representer
-      include SongProcess
-      representer HitRepresenter do
-        property :genre
-      end
-    end
-
-    # this operation copies HitRepresenter and shouldn't have `genre`.
-    it do
-      OpNotExtendingRepresenter.("title"=>"Monsterparty", "genre"=>"Punk").to_json.must_equal %{{"title":"Monsterparty"}}
-    end
-
-    # # this operation copies HitRepresenter and extends it with the property `genre`.
-    it do
-      OpExtendingRepresenter.("title"=>"Monsterparty", "genre"=>"Punk").to_json.must_equal %{{"title":"Monsterparty","genre":"Punk"}}
-    end
-
-    # # of course, the original representer wasn't modified, either.
-    it do
-      HitRepresenter.new(OpenStruct.new(title: "Monsterparty", genre: "Punk")).to_json.must_equal %{{"title":"Monsterparty"}}
-    end
-  end
-
-  describe "Op.representer (inferring)" do
-    class OpWithContract < Trailblazer::Operation
-      include Representer
-      include SongProcess
-
-      contract do
-        property :songTitle
-      end
-    end
-
-    class OpWithContract2 < Trailblazer::Operation
-      include Representer
-      include SongProcess
-
-      contract OpWithContract.contract
-      representer do
-        property :genre
-      end
-    end
-
-    it { OpWithContract.("songTitle"=>"Monsterparty", "genre"=>"Punk").to_json.must_equal %{{"songTitle":"Monsterparty"}} }
-    # this representer block extends the inferred from contract.
-    it { OpWithContract2.("songTitle"=>"Monsterparty", "genre"=>"Punk").to_json.must_equal %{{"songTitle":"Monsterparty","genre":"Punk"}} }
-  end
-
-  describe "Op.representer_class" do
-    class PlayRepresenter < Representable::Decorator
-      include Representable::JSON
-      property :title
-    end
-
-    class OpSettingRepresenter < Trailblazer::Operation
-      include Representer
-      include SongProcess
-      self.representer_class= PlayRepresenter
-    end
-
-    class OpExtendRepresenter < Trailblazer::Operation
-      include Representer
-      include SongProcess
-      self.representer_class= PlayRepresenter
-      representer do
-        property :genre
-      end
-    end
-
-    # both operations produce the same as the representer is shared, not copied.
-    it { OpSettingRepresenter.("title"=>"Monsterparty", "genre"=>"Punk").to_json.must_equal %{{"title":"Monsterparty","genre":"Punk"}} }
-    it { OpExtendRepresenter.("title"=>"Monsterparty", "genre"=>"Punk").to_json.must_equal %{{"title":"Monsterparty","genre":"Punk"}} }
-  end
-end

data/test/operation/external_model_test.rb

@@ -1,71 +0,0 @@
-require "test_helper"
-require "trailblazer/operation/model/external"
-
-class ExternalModelTest < MiniTest::Spec
-   Song = Struct.new(:title, :id) do
-    class << self
-      attr_accessor :find_result # TODO: eventually, replace with AR test.
-      attr_accessor :all_records
-
-      def find(id)
-        find_result.tap do |song|
-          song.id = id
-        end
-      end
-    end
-  end # FIXME: use from CrudTest.
-
-
-
-
-  class Bla < Trailblazer::Operation
-    include Model::External
-    model Song, :update
-
-    def process(params)
-    end
-  end
-
-  let (:song) { Song.new("Numbers") }
-
-  before do
-    Song.find_result = song
-  end
-
-  # ::model!
-  it do
-    Bla.model!(id: 1).must_equal song
-    song.id.must_equal 1
-  end
-
-  # call style.
-  it do
-    Bla.(id: 2).model.must_equal song
-    song.id.must_equal 2
-  end
-
-  # #present.
-  it do
-    Bla.present({}).model.must_equal song
-  end
-
-
-  class OpWithBuilder < Bla
-    class A < self
-    end
-
-    builds -> (model, params) do
-      return A if model.id == 1 and params[:user] == 2
-    end
-  end
-
-  describe "::builds args" do
-    it do
-      OpWithBuilder.(id: 1, user: "different").must_be_instance_of OpWithBuilder
-    end
-
-    it do
-      OpWithBuilder.(id: 1, user: 2).must_be_instance_of OpWithBuilder::A
-    end
-  end
-end

data/test/operation/guard_test.rb

@@ -1,152 +0,0 @@
-require "test_helper"
-require "trailblazer/operation/policy"
-
-class OpPolicyGuardTest < MiniTest::Spec
-  Song = Struct.new(:name)
-
-  class Create < Trailblazer::Operation
-    include Policy::Guard
-
-    def model!(*)
-      Song.new
-    end
-
-    policy do |params|
-      model.is_a?(Song) and params[:valid]
-    end
-
-    def process(*)
-    end
-  end
-
-  # valid.
-  it do
-    op = Create.(valid: true)
-  end
-
-  # invalid.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      op = Create.(valid: false)
-    end
-  end
-
-
-  describe "inheritance" do
-    class Update < Create
-      policy do |params|
-        params[:valid] == "correct"
-      end
-    end
-
-    class Delete < Create
-    end
-
-    it do
-      Create.(valid: true).wont_equal nil
-      Delete.(valid: true).wont_equal nil
-      Update.(valid: "correct").wont_equal nil
-    end
-  end
-
-
-  describe "no policy defined, but included" do
-    class Show < Trailblazer::Operation
-      include Policy::Guard
-
-      def process(*)
-      end
-    end
-
-    it { Show.({}).wont_equal nil }
-  end
-
-
-  describe "#params!" do
-    class Index < Trailblazer::Operation
-      include Policy::Guard
-
-      # make sure the guard receives the correct params.
-      policy { |params| params[:valid] == "true" }
-
-      def params!(params)
-        { valid: params }
-      end
-
-      def process(*)
-      end
-    end
-
-    it { Index.("true").wont_equal nil }
-    it { assert_raises(Trailblazer::NotAuthorizedError) { Index.(false).wont_equal nil } }
-  end
-
-  describe "with Callable" do
-    class Find < Trailblazer::Operation
-      include Policy::Guard
-
-      class Guardian
-        include Uber::Callable
-
-        def call(context, params)
-          params == "true"
-        end
-      end
-
-      policy Guardian.new
-
-      def process(*)
-      end
-    end
-
-    it { Find.("true").wont_equal nil }
-    it { assert_raises(Trailblazer::NotAuthorizedError) { Find.(false).wont_equal nil } }
-  end
-
-  describe "with Proc" do
-    class Follow < Trailblazer::Operation
-      include Policy::Guard
-
-      policy ->(params) { params == "true" } # TODO: is this really executed in op context?
-
-      def process(*)
-      end
-    end
-
-    it { Follow.("true").wont_equal nil }
-    it { assert_raises(Trailblazer::NotAuthorizedError) { Follow.(false).wont_equal nil } }
-  end
-end
-
-class OpBuilderDenyTest < MiniTest::Spec
-  Song = Struct.new(:name)
-
-  class Create < Trailblazer::Operation
-    include Deny
-
-    builds do |params|
-      deny! unless params[:valid]
-    end
-
-    def process(params)
-    end
-  end
-
-  class Update < Create
-    builds -> (params) do
-      deny! unless params[:valid]
-    end
-  end
-
-  # valid.
-  it do
-    op = Create.(valid: true)
-  end
-
-  # invalid.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      op = Create.(valid: false)
-    end
-  end
-end

data/test/operation/policy_test.rb

@@ -1,97 +0,0 @@
-require "test_helper"
-require "trailblazer/operation/policy"
-
-
-class OpPunditPolicyTest < MiniTest::Spec
-  Song = Struct.new(:name)
-  User = Struct.new(:name)
-
-  class BlaPolicy
-    def initialize(user, song)
-      @user = user
-      @song = song
-    end
-
-    def create?
-      @user.is_a?(User) and @song.is_a?(Song)
-    end
-
-    def edit?
-      "yepp"
-    end
-  end
-
-  class BlaOperation < Trailblazer::Operation
-    include Policy
-    policy BlaPolicy, :create?
-
-    def model!(*)
-      Song.new
-    end
-
-    def process(*)
-    end
-  end
-
-  # valid.
-  it do
-    op = BlaOperation.({current_user: User.new})
-
-    # #policy provides the Policy instance.
-    op.policy.edit?.must_equal "yepp"
-  end
-
-  # invalid.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      op = BlaOperation.({current_user: nil})
-    end
-  end
-
-
-  # no policy set
-  class NoPolicyOperation < Trailblazer::Operation
-    include Policy
-    # no policy.
-
-    def process(*)
-      @model = Song.new
-    end
-
-    class Delete < self
-    end
-
-
-    class LocalPolicy
-      def initialize(user, song)
-        @user = user
-        @song = song
-      end
-
-      def update?; false end
-    end
-
-    class Update < self
-      policy LocalPolicy, :update?
-    end
-  end
-
-  # valid.
-  it do
-    op = NoPolicyOperation.({})
-    op.model.must_be_instance_of Song
-  end
-
-  # inherited without config works.
-  it do
-    op = NoPolicyOperation::Delete.({})
-    op.model.must_be_instance_of Song
-  end
-
-  # inherited can override.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      op = NoPolicyOperation::Update.({})
-    end
-  end
-end

data/test/operation/reject_test.rb

@@ -1,34 +0,0 @@
-require "test_helper"
-
-class OperationRejectTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
-    def process(params)
-      invalid! if params == false
-    end
-  end
-
-  it do
-    run = nil
-    Operation.run(true) { run = true }
-    run.must_equal true
-  end
-
-  it do
-    run = nil
-    Operation.run(false) { run = true }
-    run.must_equal nil
-  end
-
-  it do
-    run = nil
-    op = Operation.reject(true) { run = true }
-    run.must_equal nil
-    op.must_be_instance_of Operation
-  end
-
-  it do
-    run = nil
-    Operation.reject(false) { run = true }
-    run.must_equal true
-  end
-end

data/test/operation/resolver_test.rb

@@ -1,83 +0,0 @@
-require "test_helper"
-require "trailblazer/operation/resolver"
-
-class ResolverTest < MiniTest::Spec
-  Song = Struct.new(:title)
-  User = Struct.new(:name)
-
-  class MyKitchenRules
-    def initialize(user, song)
-      @user = user
-      @song = song
-    end
-
-    def create?
-      @user.is_a?(User) and @song.is_a?(Song)
-    end
-
-    def admin?
-      @user && @user.name == "admin" && @song.is_a?(Song)
-    end
-
-    def true?
-      true
-    end
-  end
-
-  class Create < Trailblazer::Operation
-    include Resolver
-    model Song, :create
-    policy MyKitchenRules, :create?
-
-    builds-> (model, policy, params) do
-      return ForGaryMoore if model.title == "Friday On My Mind"
-      return Admin if policy.admin?
-      return SignedIn if params[:current_user] && params[:current_user].name
-    end
-
-    def self.model!(params)
-      Song.new(params[:title])
-    end
-
-    def process(*)
-    end
-
-    class Admin < self
-    end
-    class SignedIn < self
-    end
-  end
-
-   # valid.
-  it { Create.({current_user: User.new}).must_be_instance_of Create }
-  it { Create.({current_user: User.new("admin")}).must_be_instance_of Create::Admin }
-  it { Create.({current_user: User.new("kenneth")}).must_be_instance_of Create::SignedIn }
-
-  # invalid.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      Create.({})
-    end
-  end
-
-
-  describe "passes policy into operation" do
-    class Update < Trailblazer::Operation
-      include Resolver
-      model Song, :create
-      policy MyKitchenRules, :true?
-
-      builds-> (model, policy, params) do
-        policy.instance_eval { def whoami; "me!" end }
-        nil
-      end
-
-      def process(*)
-      end
-    end
-
-    it do
-      Update.({}).policy.whoami.must_equal "me!"
-    end
-  end
-end