trailblazer 1.0.0.rc2 → 1.0.0

data/test/rails/fake_app/song/operations.rb

@@ -1,144 +0,0 @@
-require 'trailblazer/autoloading'
-
-class Song < ActiveRecord::Base
-  class Create < Trailblazer::Operation
-    include Model
-    include Responder
-    model Song, :create
-
-
-    contract do
-      property :title, validates: {presence: true}
-      property :length
-    end
-
-    def process(params)
-      validate(params[:song]) do
-        contract.save
-      end
-    end
-
-
-    class Json < Create
-      def process(params)
-        @model = Song.create(JSON.parse(params[:song]))
-      end
-    end
-  end
-
-
-  class Delete < Create
-    action :find
-
-    def process(params)
-      model.destroy
-      self
-    end
-  end
-end
-
-class Band < ActiveRecord::Base
-  class Create < Trailblazer::Operation
-    include Model, Responder#, Representer
-    model Band, :create
-
-    contract do
-      include Reform::Form::ActiveModel
-      model Band
-
-      property :name, validates: {presence: true}
-      property :locality, prepopulator: ->(*) { self.locality = "Sydney" }
-
-      # class: Song #=> always create new song
-      # instance: { Song.find(params[:id]) or Song.new } # same as find_or_create ?
-      # this is what i want:
-      # maybe make populate_if_empty a representable feature?
-      collection :songs, populate_if_empty: Song do
-        property :title
-      end
-    end
-
-    def process(params)
-      validate(params[:band]) do
-        contract.save
-      end
-    end
-
-    require "representable/json"
-    class JSON < self
-      include Representer
-
-      representer do
-        collection :songs, inherit: true, render_empty: false # tested in ControllerPresentTest.
-      end
-    end
-
-    class Admin < self
-      def process(params)
-        res = super
-        model.update_attribute :name, "#{model.name} [ADMIN]"
-        res
-      end
-    end
-
-    # TODO: wait for uber 0.0.10 and @dutow.
-    # builds -> (params) do
-    #   return JSON if params[:format] == "json"
-    #   return Admin if params[:admin]
-    # end
-    builds do |params|
-      if params[:format] == "json"
-        JSON
-      elsif params[:admin]
-        Admin
-      end
-    end
-  end
-
-  class Update < Create
-    action :update
-
-    # TODO: infer stuff per default.
-    class JSON < self
-      include Representer
-      self.contract_class = Create::JSON.contract_class
-      self.representer_class = Create::JSON.representer_class
-    end
-
-    builds do |params|
-      JSON if params[:format] == "json"
-    end
-  end
-
-  class Index < Trailblazer::Operation
-    include Collection
-
-    def model!(params)
-      Band.all
-    end
-
-    builds do |params|
-      JSON if params[:format] == "json"
-    end
-
-    class JSON < self
-      include Representer
-
-      module BandRepresenter
-        include Representable::JSON
-        property :name
-        property :locality
-      end
-
-      self.representer_class = BandRepresenter
-    end
-  end
-end
-
-class Tenant < ActiveRecord::Base
-  class Show < Trailblazer::Operation
-    include Model
-    model Tenant, :update
-  end
-end
-

data/test/rails/fake_app/views/bands/index.html.erb

@@ -1 +0,0 @@
-bands/index.html: <% @collection.each do |element| %><%= "#{element.name} " %><% end %>

data/test/rails/fake_app/views/songs/another_view.html.erb

@@ -1,2 +0,0 @@
-OTHER SONG
-<%= @form.errors.to_s %>

data/test/rails/fake_app/views/songs/new.html.erb

@@ -1 +0,0 @@
-<%= @form.errors.to_s %>

data/test/rails/respond_test.rb

@@ -1,95 +0,0 @@
-require "test_helper"
-
-class ResponderRespondTest < ActionController::TestCase
-  tests SongsController
-
-  # HTML
-  # #respond Create [valid]
-  test "Create [html/valid]" do
-    post :create, {song: {title: "You're Going Down"}}
-    assert_redirected_to song_path(Song.last)
-  end
-
-  test "Create [html/valid/location]" do
-    post :other_create, {song: {title: "You're Going Down"}}
-    assert_redirected_to other_create_songs_path
-  end
-
-  test "Create [html/invalid]" do
-    post :create, {song: {title: ""}}
-    assert_response 200
-    assert_equal @response.body, "{:title=&gt;[&quot;can&#39;t be blank&quot;]}"
-  end
-
-  test "Create [html/invalid/action]" do
-    post :other_create, {song: {title: ""}}
-    assert_response 200
-    assert_equal @response.body, "OTHER SONG\n{:title=&gt;[&quot;can&#39;t be blank&quot;]}\n"
-    assert_template "songs/another_view"
-  end
-
-  test "Delete [html/valid]" do
-    song = Song::Create[song: {title: "You're Going Down"}].model
-    delete :destroy, id: song.id
-    assert_redirected_to songs_path
-    # assert that model is deleted.
-  end
-
-  test "respond with block [html/valid]" do
-    post :create_with_block, {song: {title: "You're Going Down"}}
-    assert_response 200
-    assert_equal "block run, valid: true", response.body
-  end
-
-  test "respond with block [html/invalid]" do
-    post :create_with_block, {song: {title: ""}}
-    assert_response 200
-    assert_equal "block run, valid: false", response.body
-  end
-
-  # JSON
-  test "Delete [json/valid]" do
-    song = Song::Create[song: {title: "You're Going Down"}].model
-    delete :destroy, id: song.id, format: :json
-    assert_response 204 # no content.
-  end
-
-  # JS
-  test "Delete [js/valid]" do
-    song = Song::Create[song: {title: "You're Going Down"}].model
-    assert_raises ActionView::MissingTemplate do
-      # js wants to render destroy.js.erb
-      delete :destroy, id: song.id, format: :js
-    end
-  end
-
-  test "Delete with formats [js/valid]" do
-    song = Song::Create[song: {title: "You're Going Down"}].model
-
-    delete :destroy_with_formats, id: song.id, format: :js
-    assert_response 200
-    assert_equal "Song slayer!", response.body
-  end
-end
-
-class ResponderRespondWithJSONTest < ActionController::TestCase
-  tests BandsController
-
-  # JSON
-  test "Create [JSON/valid]" do
-    post :create, {name: "SNFU"}.to_json, format: :json
-    assert_response 201
-    assert_equal "SNFU", Band.last.name
-  end
-end
-
-# TODO: merge with above tests on SongsController.
-class ControllerRespondTest < ActionController::TestCase
-  tests BandsController
-
-  test "#respond with builds" do
-    post :create, band: {name: "SNFU"}, admin: true
-    assert_response 302
-    assert_equal "SNFU [ADMIN]", Band.last.name
-  end
-end

data/test/rails/test_helper.rb

@@ -1,9 +0,0 @@
-require 'trailblazer'
-require 'minitest/autorun'
-
-require "reform/form/active_model/validations"
-Reform::Form.class_eval do
-  include Reform::Form::ActiveModel::Validations
-end
-
-require 'fake_app/rails_app.rb'

data/test/responder_test.rb

@@ -1,75 +0,0 @@
-require 'test_helper'
-require 'trailblazer/operation/responder'
-
-class Song
-  extend ActiveModel::Naming
-
-  class Operation < Trailblazer::Operation
-    include Model
-    model Song
-    include Responder
-
-    def process(params)
-      invalid! if params == false
-    end
-  end
-end
-
-module MyApp
-  class Song
-    extend ActiveModel::Naming
-
-    class Operation < Trailblazer::Operation
-      include Model
-      include Responder
-      model Song
-
-      def process(params)
-        invalid! if params == false
-      end
-    end
-  end
-end
-
-class ResponderTestForModelWithoutNamespace < MiniTest::Spec
-
-  # test ::model_name
-  it { Song::Operation.model_name.name.must_equal "Song" }
-  it { Song::Operation.model_name.singular.must_equal "song" }
-  it { Song::Operation.model_name.plural.must_equal "songs" }
-  it { Song::Operation.model_name.element.must_equal "song" }
-  it { Song::Operation.model_name.human.must_equal "Song" }
-  it { Song::Operation.model_name.collection.must_equal "songs" }
-  it { Song::Operation.model_name.param_key.must_equal "song" }
-  it { Song::Operation.model_name.i18n_key.must_equal :"song" }
-  it { Song::Operation.model_name.route_key.must_equal "songs" }
-  it { Song::Operation.model_name.singular_route_key.must_equal "song" }
-
-  # #errors
-  it { Song::Operation.(true).errors.must_equal [] }
-  it { Song::Operation.(false).errors.must_equal [1] } # TODO: since we don't want responder to render anything, just return _one_ error. :)
-
-  # TODO: integration test with Controller.
-end
-
-
-class ResponderTestForModelWitNamespace < MiniTest::Spec
-
-    # test ::model_name
-    it { MyApp::Song::Operation.model_name.name.must_equal "MyApp::Song" }
-    it { MyApp::Song::Operation.model_name.singular.must_equal "my_app_song" }
-    it { MyApp::Song::Operation.model_name.plural.must_equal "my_app_songs" }
-    it { MyApp::Song::Operation.model_name.element.must_equal "song" }
-    it { MyApp::Song::Operation.model_name.human.must_equal "Song" }
-    it { MyApp::Song::Operation.model_name.collection.must_equal "my_app/songs" }
-    it { MyApp::Song::Operation.model_name.param_key.must_equal "my_app_song" } # "song" for AR.
-    it { MyApp::Song::Operation.model_name.i18n_key.must_equal :"my_app/song" }
-    it { MyApp::Song::Operation.model_name.route_key.must_equal "my_app_songs" } # "songs" for AR.
-    it { MyApp::Song::Operation.model_name.singular_route_key.must_equal "my_app_song" } # "song" for AR.
-
-    # #errors
-    it { MyApp::Song::Operation.(true).errors.must_equal [] }
-    it { MyApp::Song::Operation.(false).errors.must_equal [1] } # TODO: since we don't want responder to render anything, just return _one_ error. :)
-
-    # TODO: integration test with Controller.
-end

data/test/uploaded_file_test.rb

@@ -1,85 +0,0 @@
-require 'test_helper'
-require 'trailblazer/operation/uploaded_file'
-
-class TempfileTest < MiniTest::Spec
-
-end
-
-class UploadedFileTest < MiniTest::Spec
-  let (:image) { File.open("test/fixtures/apotomo.png") }
-  let (:tempfile) { tmp = Tempfile.new("bla")
-    tmp.write image.read
-    tmp
-   }
-
-  let (:upload) { ActionDispatch::Http::UploadedFile.new(
-    tempfile: tempfile,
-    filename: "apotomo.png",
-    type: "image/png")
-  }
-
-  describe "#to_hash" do
-    before {
-      @uploaded_path = upload.tempfile.path
-      @subject = Trailblazer::Operation::UploadedFile.new(upload).to_hash
-     }
-
-    it { @subject[:filename].must_equal "apotomo.png" }
-    it { @subject[:type].must_equal "image/png" }
-    it { @subject[:tempfile_path].must_match /\w+_trailblazer_upload$/ }
-
-
-    # Rails upload file must be removed.
-    it {
-      File.exists?(@uploaded_path).must_equal false }
-
-    it { File.exists?(@subject[:tempfile_path]).must_equal true }
-    it { File.size(@subject[:tempfile_path]).must_equal image.size }
-  end
-
-  describe "::from_hash" do
-    let (:data) { Trailblazer::Operation::UploadedFile.new(upload).to_hash }
-    subject { Trailblazer::Operation::UploadedFile.from_hash(data) }
-
-
-    it { subject.original_filename.must_equal "apotomo.png" }
-    it { subject.content_type.must_equal "image/png" }
-    it { subject.tempfile.must_be_kind_of File }
-    it { subject.size.must_equal image.size }
-
-    # params is not modified.
-    it { params = data.clone and subject; data.must_equal params }
-
-    # Tempfile must have proper extension for further processing (sidekiq/imagemagick, etc).
-    it { subject.tempfile.path.must_match /\.png$/ }
-
-    # Tempfile must be unlinked after process is finished.
-    it do
-      @subject = Trailblazer::Operation::UploadedFile.from_hash(data)
-
-      processable_file = @subject.tempfile.path
-      File.exists?(processable_file).must_equal true # this file must be GCed since it's a Tempfile, that's the whole point.
-      # @subject = nil
-      # GC.start
-      # File.exists?(processable_file).must_equal false
-    end
-  end
-
-
-  describe "with custom tmp directory" do
-    describe "#to_hash" do
-      before {
-        @uploaded = Trailblazer::Operation::UploadedFile.new(upload, tmp_dir: tmp_dir)
-        @subject  = @uploaded.to_hash[:tempfile_path]
-      }
-
-      it { @subject.must_match /\w+_trailblazer_upload$/ }
-      it { @subject.must_match /^\/tmp\/uploads\// }
-
-      it { File.exists?(@subject).must_equal true }
-      it { File.size(@subject).must_equal image.size }
-
-      it { @uploaded.instance_variable_get(:@with_tmp_dir).path.must_equal nil }
-    end
-  end
-end

data/test/worker_test.rb

@@ -1,124 +0,0 @@
-# make sure #run always returns model
-
-# in test with sidekiq/testing
-# Operation.run #=> call perform_one and return [result, model] (model?)
-
-require 'test_helper'
-require 'trailblazer/operation'
-require 'trailblazer/operation/worker'
-require 'sidekiq/testing'
-
-
-class WorkerTest < MiniTest::Spec
-  class Operation < Trailblazer::Operation
-    include Worker
-
-    def process(params)
-      with_symbol = params[:title]
-      with_string = params["title"]
-      @model = "I was working hard on #{params.inspect}. title:#{with_symbol} \"title\"=>#{with_string}"
-    end
-  end
-
-  class NoBackgroundOperation < Operation
-    def self.background?
-      false
-    end
-  end
-
-  # test basic worker functionality.
-  describe "with sidekiq ss" do
-    it do
-      res = Operation.run(title: "Dragonfly")
-
-      res.kind_of?(String).must_equal true # for now, we return the job from sidekiq
-      Operation.jobs[0]["args"].must_equal([{"title"=>"Dragonfly"}])
-      Operation.perform_one.last.model.must_equal "I was working hard on {\"title\"=>\"Dragonfly\"}. title:Dragonfly \"title\"=>Dragonfly"
-    end
-  end
-
-  # without sidekiq, we don't have indifferent_access automatically.
-  it { NoBackgroundOperation.run(title: "Dragonfly").last.model.must_equal "I was working hard on {:title=>\"Dragonfly\"}. title:Dragonfly \"title\"=>" }
-
-
-  # test manual serialisation (to be done with UploadedFile etc automatically).
-  class SerializingOperation < Operation
-    include Worker
-
-    def self.serializable(params)
-      {wrap: params}
-    end
-
-    def deserializable(params)
-      params[:wrap]
-    end
-  end
-
-  describe "with serialization in sidekiq" do
-    before { @res = SerializingOperation.run(title: "Dragonfly") }
-
-    it { @res.kind_of?(String).must_equal true } # for now, we return the job from sidekiq.
-    it { SerializingOperation.jobs[0]["args"].must_equal([{"wrap"=>{"title"=>"Dragonfly"}}]) }
-    it { SerializingOperation.perform_one.last.model.must_equal "I was working hard on {\"title\"=>\"Dragonfly\"}. title:Dragonfly \"title\"=>Dragonfly" }
-  end
-end
-
-
-require "trailblazer/operation/uploaded_file"
-require "action_dispatch/http/upload"
-class WorkerFileMarshallerTest < MiniTest::Spec
-  def uploaded_file(name)
-    tmp = Tempfile.new("bla")
-    tmp.write File.open("test/fixtures/#{name}").read
-
-    ActionDispatch::Http::UploadedFile.new(
-    tempfile: tmp,
-    filename: name,
-    type: "image/png")
-  end
-
-  class Operation < Trailblazer::Operation
-    contract do
-      property :title
-      property :image, file: true
-
-      property :album do
-        property :image, file: true
-      end
-    end
-
-    include Worker
-    include Worker::FileMarshaller # should be ContractFileMarshaller
-
-    def process(params)
-      @params = params
-    end
-
-    attr_reader :params
-  end
-
-  # TODO: no image
-
-  # with image serializes the file for later retrieval.
-  it do
-    Operation.run(title: "Dragonfly", image: uploaded_file("apotomo.png"), album: {image: uploaded_file("cells.png")})
-
-    args = Operation.jobs[0]["args"].first
-    args["title"].must_equal("Dragonfly")
-    args["image"]["filename"].must_equal "apotomo.png"
-    args["image"]["tempfile_path"].must_match /trailblazer_upload/
-
-    args["album"]["image"]["filename"].must_equal "cells.png"
-
-    _, op = Operation.perform_one # deserialize.
-
-    params = op.params
-
-    params["title"].must_equal("Dragonfly")
-    params[:title].must_equal("Dragonfly") # must allow indifferent_access.
-    params["image"].must_be_kind_of ActionDispatch::Http::UploadedFile
-    params["image"].original_filename.must_equal "apotomo.png"
-    params["album"]["image"].must_be_kind_of ActionDispatch::Http::UploadedFile
-    params["album"]["image"].original_filename.must_equal "cells.png"
-  end
-end