trailblazer 1.1.2 → 2.0.0.beta1

data/test/operation/present_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+require "trailblazer/operation/present"
+
+class PresentTest < Minitest::Spec
+  class Create < Trailblazer::Operation
+    include Test::ReturnCall
+    include Present
+
+    include Model::Builder
+    def model!(*); Object end
+
+    def call(params)
+      "#call run!"
+    end
+  end
+
+  it do
+    result = Create.present
+    result["model"].must_equal Object
+  end
+
+  it { Create.().must_equal "#call run!" }
+end

data/test/operation/pundit_test.rb

@@ -0,0 +1,104 @@
+require "test_helper"
+require "trailblazer/operation/policy"
+
+class PolicyTest < Minitest::Spec
+  Song = Struct.new(:id) do
+    def self.find(id); new(id) end
+  end
+
+  class Auth
+    def initialize(user, model); @user, @model = user, model end
+    def only_user?; @user == Module && @model.nil? end
+    def user_object?; @user == Object end
+    def user_and_model?; @user == Module && @model.class == Song end
+    def inspect; "<Auth: user:#{@user.inspect}, model:#{@model.inspect}>" end
+  end
+
+  #---
+  # Instance-level: Only policy, no model
+  class Create < Trailblazer::Operation
+    self.| Policy::Pundit( Auth, :only_user? )
+    self.| :process
+
+    def process(*)
+      self["process"] = true
+    end
+  end
+
+  # successful.
+  it do
+    result = Create.({}, "current_user" => Module)
+    result["process"].must_equal true
+    #- result object, policy
+    result["result.policy.default"].success?.must_equal true
+    result["result.policy.default"]["message"].must_equal nil
+    # result[:valid].must_equal nil
+    result["policy.default"].inspect.must_equal %{<Auth: user:Module, model:nil>}
+  end
+  # breach.
+  it do
+    result = Create.({}, "current_user" => nil)
+    result["process"].must_equal nil
+    #- result object, policy
+    result["result.policy.default"].success?.must_equal false
+    result["result.policy.default"]["message"].must_equal "Breach"
+  end
+  # inject different policy.Condition  it { Create.({}, "current_user" => Object, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))["process"].must_equal true }
+  it { Create.({}, "current_user" => Module, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_object?))["process"].must_equal nil }
+
+
+  #---
+  # inheritance, adding Model
+  class Show < Create
+    self.| Model( Song, :new ), before: "policy.default.eval"
+  end
+
+  it { Show["pipetree"].inspect.must_equal %{[>>operation.new,&model.build,&policy.default.eval,>process]} }
+
+  # invalid because user AND model.
+  it do
+    result = Show.({}, "current_user" => Module)
+    result["process"].must_equal nil
+    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
+    # result["policy"].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
+  end
+
+  # valid because new policy.
+  it do
+    # puts Show["pipetree"].inspect
+    result = Show.({}, "current_user" => Module, "policy.default.eval" => Trailblazer::Operation::Policy::Pundit::Condition.new(Auth, :user_and_model?))
+    result["process"].must_equal true
+    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=nil>}
+    result["policy.default"].inspect.must_equal %{<Auth: user:Module, model:#<struct PolicyTest::Song id=nil>>}
+  end
+
+  ##--
+  # TOOOODOOO: Policy and Model before Build ("External" or almost Resolver)
+  class Edit < Trailblazer::Operation
+    self.| Model Song, :update
+    self.| Policy::Pundit( Auth, :user_and_model? )
+    self.| :process
+
+    def process(*); self["process"] = true end
+  end
+
+  # successful.
+  it do
+    result = Edit.({ id: 1 }, "current_user" => Module)
+    result["process"].must_equal true
+    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=1>}
+    result["result.policy.default"].success?.must_equal true
+    result["result.policy.default"]["message"].must_equal nil
+    # result[:valid].must_equal nil
+    result["policy.default"].inspect.must_equal %{<Auth: user:Module, model:#<struct PolicyTest::Song id=1>>}
+  end
+
+  # breach.
+  it do
+    result = Edit.({ id: 4 }, "current_user" => nil)
+    result["model"].inspect.must_equal %{#<struct PolicyTest::Song id=4>}
+    result["process"].must_equal nil
+    result["result.policy.default"].success?.must_equal false
+    result["result.policy.default"]["message"].must_equal "Breach"
+  end
+end

data/test/{representer_test.rb → operation/representer_test.rb}

@@ -1,5 +1,4 @@
 require "test_helper"
-
 require "representable/json"
 
 class RepresenterTest < MiniTest::Spec
@@ -7,8 +6,10 @@ class RepresenterTest < MiniTest::Spec
   Artist = Struct.new(:name)
 
   class Create < Trailblazer::Operation
-    require "trailblazer/operation/representer"
+    include Contract::Explicit
     include Representer
+    include Representer::InferFromContract
+    attr_reader :model # FIXME: all we want is #model.
 
     contract do
       property :title
@@ -19,18 +20,19 @@ class RepresenterTest < MiniTest::Spec
       end
     end
 
-    def process(params)
-      @model = Album.new # NO artist!!!
-      validate(params[:album], @model)
+    def call(params)
+      self["model"] = Album.new # NO artist!!!
+      validate(params[:album], model: self["model"])
+      self
     end
   end
 
 
   # Infers representer from contract, no customization.
   class Show < Create
-    def process(params)
-      @model = Album.new("After The War", Artist.new("Gary Moore"))
-      @contract = @model
+    def call(params)
+      self["model"] = Album.new("After The War", Artist.new("Gary Moore"))
+      self
     end
   end
 
@@ -46,36 +48,32 @@ class RepresenterTest < MiniTest::Spec
   end
 
   class HypermediaShow < HypermediaCreate
-    def process(params)
-      @model = Album.new("After The War", Artist.new("Gary Moore"))
-      @contract = @model
+    def call(params)
+      self["model"] = Album.new("After The War", Artist.new("Gary Moore"))
+      self
     end
   end
 
 
   # rendering
   # generic contract -> representer
-  it do
-    res, op = Show.run({})
-    op.to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"}}}
-  end
+  it { Show.().to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"}}} }
 
   # contract -> representer with hypermedia
   it do
-    res, op = HypermediaShow.run({})
-    op.to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"},"_links":{"self":{"href":"//album/After The War"}}}}
+    HypermediaShow.().to_json.must_equal %{{"title":"After The War","artist":{"name":"Gary Moore"},"_links":{"self":{"href":"//album/After The War"}}}}
   end
 
 
   # parsing
   it do
-    res, op = Create.run(album: %{{"title":"Run For Cover","artist":{"name":"Gary Moore"}}})
+    op = Create.(album: %{{"title":"Run For Cover","artist":{"name":"Gary Moore"}}})
     op.contract.title.must_equal "Run For Cover"
     op.contract.artist.name.must_equal "Gary Moore"
   end
 
   it do
-    res, op = HypermediaCreate.run(album: %{{"title":"After The War","artist":{"name":"Gary Moore"},"_links":{"self":{"href":"//album/After The War"}}}})
+    op = HypermediaCreate.(album: %{{"title":"After The War","artist":{"name":"Gary Moore"},"_links":{"self":{"href":"//album/After The War"}}}})
     op.contract.title.must_equal "After The War"
     op.contract.artist.name.must_equal "Gary Moore"
   end
@@ -87,7 +85,9 @@ class RepresenterTest < MiniTest::Spec
   # explicit representer set with ::representer_class=.
   require "roar/decorator"
   class JsonApiCreate < Trailblazer::Operation
+    include Contract::Explicit
     include Representer
+    attr_reader :model
 
     contract do # we still need contract as the representer writes to the contract twin.
       property :title
@@ -97,31 +97,33 @@ class RepresenterTest < MiniTest::Spec
       include Roar::JSON
       property :title
     end
-    self.representer_class = AlbumRepresenter
 
-    def process(params)
-      @model = Album.new # NO artist!!!
-      validate(params[:album], @model)
+    # FIXME: this won't inherit, of course.
+    # self["representer.class"] = AlbumRepresenter
+    representer AlbumRepresenter
+
+    def call(params)
+      self["model"] = Album.new # NO artist!!!
+      validate(params[:album], model: self["model"])
+      self
     end
   end
 
   class JsonApiShow < JsonApiCreate
-    def process(params)
-      @model = Album.new("After The War", Artist.new("Gary Moore"))
-      @contract = @model
+    def call(params)
+      self["model"] = Album.new("After The War", Artist.new("Gary Moore"))
+      self
     end
   end
 
   # render.
   it do
-    res, op = JsonApiShow.run({})
-    op.to_json.must_equal %{{"title":"After The War"}}
+    JsonApiShow.().to_json.must_equal %{{"title":"After The War"}}
   end
 
   # parse.
   it do
-    res, op = JsonApiCreate.run(album: %{{"title":"Run For Cover"}})
-    op.contract.title.must_equal "Run For Cover"
+    JsonApiCreate.(album: %{{"title":"Run For Cover"}}).contract.title.must_equal "Run For Cover"
   end
 end
 
@@ -130,26 +132,35 @@ class InternalRepresenterAPITest < MiniTest::Spec
 
   describe "#represented" do
     class Show < Trailblazer::Operation
+      include Contract::Explicit
       include Representer, Model
       model Song, :create
 
       representer do
         property :class
       end
+
+      def call(*)
+        self
+      end
+
+      def model # FIXME.
+        self["model"]
+      end
     end
 
     it "uses #model as represented, per default" do
-      Show.present({}).to_json.must_equal '{"class":"InternalRepresenterAPITest::Song"}'
+      Show.({}).to_json.must_equal '{"class":"InternalRepresenterAPITest::Song"}'
     end
 
     class ShowContract < Show
       def represented
-        contract
+        "Object"
       end
     end
 
     it "can be overriden to use the contract" do
-      ShowContract.present({}).to_json.must_equal %{{"class":"#{ShowContract.contract_class}"}}
+      ShowContract.({}).to_json.must_equal %{{"class":"String"}}
     end
   end
 
@@ -163,16 +174,17 @@ class InternalRepresenterAPITest < MiniTest::Spec
       end
 
       def to_json(*)
-        super(@params)
+        super(self["params"])
       end
 
-      def model!(params)
+      include Model::Builder
+      def model!(*)
         Song.new(1)
       end
     end
 
     it "allows to pass options to #to_json" do
-      OptionsShow.present(include: [:id]).to_json.must_equal '{"id":1}'
+      OptionsShow.(include: [:id]).to_json.must_equal %{{"id":1}}
     end
   end
 end
@@ -182,6 +194,7 @@ class DifferentParseAndRenderingRepresenterTest < MiniTest::Spec
 
   # rendering
   class Create < Trailblazer::Operation
+    include Contract::Explicit
     extend Representer::DSL
     include Representer::Rendering # no Deserializer::Hash here or anything.
 
@@ -193,11 +206,12 @@ class DifferentParseAndRenderingRepresenterTest < MiniTest::Spec
       property :title, as: :Title
     end
 
-    def process(params)
-      @model = Album.new
+    def call(params)
+      self["model"] = Album.new
       validate(params) do
         contract.sync
       end
+      self
     end
   end
 
@@ -207,6 +221,7 @@ class DifferentParseAndRenderingRepresenterTest < MiniTest::Spec
 
   # parsing
   class Update < Trailblazer::Operation
+    include Contract::Explicit
     extend Representer::DSL
     include Representer::Deserializer::Hash # no Rendering.
 
@@ -218,17 +233,18 @@ class DifferentParseAndRenderingRepresenterTest < MiniTest::Spec
       property :title
     end
 
-
-    def process(params)
-      @model = Album.new
+    def call(params)
+      self["model"] = Album.new
 
       validate(params) do
         contract.sync
       end
+
+      self
     end
 
     def to_json(*)
-      %{{"title": "#{model.title}"}}
+      %{{"title": "#{self["model"].title}"}}
     end
   end
 

data/test/operation/resolver_test.rb

@@ -1,83 +1,47 @@
 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
+class ResolverTest < Minitest::Spec
+  Song = Struct.new(:id) do
+    def self.find(id); new(id) 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
+  class Auth
+    def initialize(*args); @user, @model = *args end
+    def only_user?; @user == Module && @model.nil? end
+    def user_object?; @user == Object end
+    def user_and_model?; @user == Module && @model.class == Song end
+    def inspect; "<Auth: user:#{@user.inspect}, model:#{@model.inspect}>" end
+  end
 
-    def self.model!(params)
-      Song.new(params[:title])
-    end
+  class A < Trailblazer::Operation
+    extend Builder::DSL
+    builds ->(options) {
+      return P if options["params"] == { some: "params", id:1 }
+      return B if options["policy.default"].inspect == %{<Auth: user:Module, model:#<struct ResolverTest::Song id=3>>} # both user and model:id are set!
+      return M if options["model"].inspect == %{#<struct ResolverTest::Song id=9>}
+    }
 
-    def process(*)
-    end
+    self.| Model( Song, :update ), before: "operation.new"
+    self.| Policy::Pundit( Auth, :user_and_model? ), before: "operation.new"
+    require "trailblazer/operation/resolver"
+    self.| Resolver(), before: "operation.new"
 
-    class Admin < self
-    end
-    class SignedIn < self
-    end
-  end
+    self.| :process
 
-   # 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 }
+    class P < self; end
+    class B < self; end
+    class M < self; end
 
-  # invalid.
-  it do
-    assert_raises Trailblazer::NotAuthorizedError do
-      Create.({})
-    end
+    def process(*); self["x"] = self.class end
   end
 
+  it { A["pipetree"].inspect.must_equal %{[&model.build,&policy.default.eval,>>builder.call,>>operation.new,>process]} }
 
-  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
+  it { r=A.({ some: "params", id: 1 }, { "current_user" => Module })
+    puts r.inspect
 
-      def process(*)
-      end
-    end
-
-    it do
-      Update.({}).policy.whoami.must_equal "me!"
-    end
-  end
-end
+     }
+  it { A.({ some: "params", id: 1 }, { "current_user" => Module })["x"].must_equal A::P }
+  it { A.({                 id: 3 }, { "current_user" => Module })["x"].must_equal A::B }
+  it { A.({                 id: 9 }, { "current_user" => Module })["x"].must_equal A::M }
+end