rails_ops 1.4.2 → 1.4.4

data/test/unit/rails_ops/generators/operation_generator_test.rb

@@ -32,6 +32,104 @@ class OperationGeneratorTest < Rails::Generators::TestCase
     assert_routes
   end
 
+  def test_no_index_action
+    run_generator ['User', '--skip-index']
+
+    # Check that the index view is not created
+    assert_no_file 'app/views/users/index.html.haml'
+
+    # Check that the index route is not created
+    assert_file 'config/routes.rb' do |routes|
+      assert_match(/resources :users, except: \[:index\]/, routes)
+    end
+
+    # Check that the controller action is not created
+    assert_file 'app/controllers/users_controller.rb' do |controller|
+      assert_no_match(/def index/, controller)
+    end
+  end
+
+  def test_no_show_action
+    run_generator ['User', '--skip-show']
+
+    # Check that the show view is not created
+    assert_no_file 'app/views/users/show.html.haml'
+
+    # Check that the show route is not created
+    assert_file 'config/routes.rb' do |routes|
+      assert_match(/resources :users, except: \[:show\]/, routes)
+    end
+
+    # Check that the controller action is not created
+    assert_file 'app/controllers/users_controller.rb' do |controller|
+      assert_no_match(/def show/, controller)
+    end
+
+    # Check that the load operation is not created
+    assert_no_file 'app/operations/users/load.rb'
+  end
+
+  def test_no_create_action
+    run_generator ['User', '--skip-create']
+
+    # Check that the new and create view are not created
+    assert_no_file 'app/views/users/new.html.haml'
+    assert_no_file 'app/views/users/create.html.haml'
+
+    # Check that the new, create route is not created
+    assert_file 'config/routes.rb' do |routes|
+      assert_match(/resources :users, except: \[:new, :create\]/, routes)
+    end
+
+    # Check that the controller actions are not created
+    assert_file 'app/controllers/users_controller.rb' do |controller|
+      assert_no_match(/def new/, controller)
+      assert_no_match(/def create/, controller)
+    end
+
+    # Check that the load operation is not created
+    assert_no_file 'app/operations/users/create.rb'
+  end
+
+  def test_no_update_action
+    run_generator ['User', '--skip-update']
+
+    # Check that the edit and update view are not created
+    assert_no_file 'app/views/users/edit.html.haml'
+    assert_no_file 'app/views/users/update.html.haml'
+
+    # Check that the edit, update route is not created
+    assert_file 'config/routes.rb' do |routes|
+      assert_match(/resources :users, except: \[:edit, :update\]/, routes)
+    end
+
+    # Check that the controller actions are not created
+    assert_file 'app/controllers/users_controller.rb' do |controller|
+      assert_no_match(/def edit/, controller)
+      assert_no_match(/def update/, controller)
+    end
+
+    # Check that the load operation is not created
+    assert_no_file 'app/operations/users/update.rb'
+  end
+
+  def test_no_destory_action
+    run_generator ['User', '--skip-destroy']
+
+    # Check that the destroy view is not created
+    assert_no_file 'app/views/users/destroy.html.haml'
+
+    # Check that the destroy route is not created
+    assert_file 'config/routes.rb' do |routes|
+      assert_match(/resources :users, except: \[:destroy\]/, routes)
+    end
+
+    # Check that the controller action is not created
+    assert_file 'app/controllers/users_controller.rb' do |controller|
+      assert_no_match(/def destroy/, controller)
+    end
+  end
+
   def test_no_views
     run_generator ['User', '--skip-views']
 

data/test/unit/rails_ops/hookup_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+class RailsOps::HookupTest < ActiveSupport::TestCase
+  include TestHelper
+
+  class RailsOps::HookupTest::HookupStarter < RailsOps::Operation::Model::Create
+    model ::Group
+  end
+
+  class RailsOps::HookupTest::HookupTarget < RailsOps::Operation
+    def perform
+      Group.find_by(name: 'hookup_test_group').update({ color: 'blue' })
+    end
+  end
+
+  def test_hooked_op
+    group = RailsOps::HookupTest::HookupStarter.run!(group: { name: 'hookup_test_group' }).model
+    group.reload
+    assert_equal 'blue', group.color
+  end
+
+  def test_recursive_hookup_raises
+    RailsOps.hookup.instance_variable_set(:@drawn, false)
+    RailsOps.hookup.instance_variable_set(:@config_loaded, false)
+    assert_raises SystemStackError do
+      RailsOps.hookup.draw do
+        run 'RailsOps::HookupTest::HookupTarget' do
+          on 'RailsOps::HookupTest::HookupStarter'
+        end
+
+        run 'RailsOps::HookupTest::HookupStarter' do
+          on 'RailsOps::HookupTest::HookupTarget'
+        end
+      end
+    end
+    RailsOps.hookup.load_config
+  end
+
+  def test_dont_draw_twice
+    assert_raises_with_message RuntimeError, "Hooks can't be drawn twice." do
+      RailsOps.hookup.draw do
+        run 'RailsOps::HookupTest::HookupTarget' do
+          on 'RailsOps::HookupTest::HookupStarter'
+        end
+      end
+    end
+  end
+
+  def test_missing_hookup_op
+    RailsOps.hookup.load_config
+    RailsOps.hookup.instance_variable_set(:@drawn, false)
+    RailsOps.hookup.draw do
+      run 'RailsOps::HookupTest::HookupIllusiveTarget' do
+        on 'RailsOps::HookupTest::HookupStarter'
+      end
+    end
+
+    assert_raises_with_message RuntimeError, 'Could not find hook target operation RailsOps::HookupTest::HookupIllusiveTarget.' do
+      RailsOps::HookupTest::HookupStarter.run!(group: { name: 'group' })
+    end
+
+    RailsOps.hookup.instance_variable_set(:@drawn, false)
+    RailsOps.hookup.instance_variable_set(:@config_loaded, false)
+    RailsOps.hookup.load_config
+  end
+
+  def test_missing_config_file
+    orig_path = RailsOps::Hookup::CONFIG_PATH
+    RailsOps::Hookup.const_set(:CONFIG_PATH, '/def/doesnt/exist')
+    RailsOps.hookup.instance_variable_set(:@drawn, false)
+    RailsOps.hookup.instance_variable_set(:@config_loaded, false)
+    assert_nothing_raised do
+      RailsOps.hookup.load_config
+    end
+    assert_equal({}, RailsOps.hookup.hooks)
+
+    RailsOps::Hookup.const_set(:CONFIG_PATH, orig_path)
+    RailsOps.hookup.instance_variable_set(:@drawn, false)
+    RailsOps.hookup.instance_variable_set(:@config_loaded, false)
+    RailsOps.hookup.load_config
+  end
+end

data/test/unit/rails_ops/mixins/controller_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+require 'cancancan'
+
+class RailsOps::Mixins::ControllerTest < ActionDispatch::IntegrationTest
+  include TestHelper
+
+  def test_controller_op
+    group = Group.create(name: 'group')
+    get group_url(group), as: :json
+    assert_equal 'group', JSON.parse(@response.body)['name']
+  end
+
+  def test_controller_op_run
+    group = Group.create(name: 'group')
+    patch group_url(group), params: { name: 'group2' }, as: :json
+    assert_equal 'group2', JSON.parse(@response.body)['name']
+
+    group.reload
+    assert_equal 'group2', group.name
+  end
+end

data/test/unit/rails_ops/mixins/model/deep_nesting_test.rb

@@ -92,6 +92,67 @@ class RailsOps::Mixins::Model::DeepNestingTest < ActiveSupport::TestCase
     assert_equal 'CPU', model.mainboard.cpu.name
   end
 
+  def test_without_asoc
+    assert_raises_with_message RuntimeError, 'Association cat could not be found for Animal.' do
+      Class.new(RailsOps::Operation::Model::Create) do
+        model Animal
+
+        nest_model_op :cat, Class.new(RailsOps::Operation::Model::Create) do
+          model Cat
+        end
+      end
+    end
+  end
+
+  def test_wrong_asoc_type
+    assert_raises_with_message RuntimeError,
+                               'Method nest_model_op only supports :belongs_to associations, but association dogs of model Animal is a has_many association.' do
+      Class.new(RailsOps::Operation::Model::Create) do
+        model Animal
+
+        nest_model_op :dogs, Class.new(RailsOps::Operation::Model::Create) do
+          model Dog
+        end
+      end
+    end
+  end
+
+  def test_autosave_on
+    assert_raises_with_message RuntimeError, 'Association bird of Animal has :autosave turned on. This is not supported by nest_model_op.' do
+      Class.new(RailsOps::Operation::Model::Create) do
+        model Animal
+
+        nest_model_op :bird, Class.new(RailsOps::Operation::Model::Create) do
+          model Bird
+        end
+      end
+    end
+  end
+
+  def test_validation_off
+    assert_raises_with_message RuntimeError, 'Association phoenix of Animal has :validate turned off. This is not supported by nest_model_op.' do
+      Class.new(RailsOps::Operation::Model::Create) do
+        model Animal
+
+        nest_model_op :phoenix, Class.new(RailsOps::Operation::Model::Create) do
+          model Phoenix
+        end
+      end
+    end
+  end
+
+  def test_inverse_autosave_on
+    assert_raises_with_message RuntimeError, 'Association phoenix of Bird has :autosave turned on. This is not supported by nest_model_op.' do
+      Class.new(RailsOps::Operation::Model::Create) do
+        model Phoenix
+
+        nest_model_op :bird, Class.new(RailsOps::Operation::Model::Create) do
+          model Bird
+        end
+      end
+    end
+  end
+
   def test_create_computer_level_1_validation_error
     op = COMPUTER_CREATION_OP.new(
       computer: {
@@ -197,7 +258,6 @@ class RailsOps::Mixins::Model::DeepNestingTest < ActiveSupport::TestCase
     )
 
     refute update_op.run
-    assert_equal :name, update_op.model.mainboard.errors.first.attribute
-    assert_equal :blank, update_op.model.mainboard.errors.first.type
+    assert update_op.model.mainboard.errors.added?(:name, :blank)
   end
 end

data/test/unit/rails_ops/mixins/model/marshalling_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class RailsOps::Mixins::Model::MarshallingTest < ActiveSupport::TestCase
+  include TestHelper
+
+  class RailsOps::Mixins::Model::MarshallingTest::ParentOp < RailsOps::Operation::Model::Create
+    model Group
+    attr_reader :loaded_child_class
+    attr_reader :loaded_child_parent_op
+
+    def perform
+      sub_op = run_sub! RailsOps::Mixins::Model::MarshallingTest::ChildOp
+
+      dump_res = Marshal.dump(sub_op)
+      # rubocop:disable Security/MarshalLoad
+      load_res = Marshal.load(dump_res)
+      # rubocop:enable Security/MarshalLoad
+
+      @loaded_child_class = load_res.class
+      @loaded_child_parent_op = load_res.model.parent_op
+    end
+  end
+
+  class RailsOps::Mixins::Model::MarshallingTest::ChildOp < RailsOps::Operation::Model::Create
+    model Group
+    def perform; end
+  end
+
+  def test_marshal_dump_and_load
+    assert_nothing_raised do
+      op_res = RailsOps::Mixins::Model::MarshallingTest::ParentOp.run!
+      assert_equal RailsOps::Mixins::Model::MarshallingTest::ChildOp, op_res.loaded_child_class
+      assert_nil op_res.loaded_child_parent_op
+    end
+  end
+end

data/test/unit/rails_ops/operation/auth_test.rb

@@ -0,0 +1,120 @@
+require 'test_helper'
+require 'rails_ops/authorization_backend/can_can_can'
+require 'cancancan'
+
+class RailsOps::Operation::AuthTest < ActiveSupport::TestCase
+  include TestHelper
+
+  LOAD_OP = Class.new(RailsOps::Operation::Model::Load) do
+    model ::Group
+  end
+
+  LOAD_OP_WITHOUT_AUTH = Class.new(RailsOps::Operation::Model::Load) do
+    model ::Group
+    without_authorization
+  end
+
+  UPDATE_OP = Class.new(RailsOps::Operation::Model::Update) do
+    model ::Group
+  end
+
+  CREATE_OP = Class.new(RailsOps::Operation::Model::Create) do
+    model ::Group
+  end
+
+  DESTROY_OP = Class.new(RailsOps::Operation::Model::Destroy) do
+    model ::Group
+  end
+
+  ABILITY = Class.new do
+    include CanCan::Ability
+
+    def initialize(read: false, update: false, create: false, destroy: false)
+      super()
+
+      can :read, Group if read
+      can :update, Group if update
+      can :create, Group if create
+      can :destroy, Group if destroy
+    end
+  end
+
+  setup do
+    Group.create!(id: 1, name: 'Group')
+    RailsOps.config.authorization_backend = 'RailsOps::AuthorizationBackend::CanCanCan'
+  end
+
+  def test_unpermitted_read
+    ctx = RailsOps::Context.new(ability: ABILITY.new)
+    assert_raises CanCan::AccessDenied do
+      LOAD_OP.new(ctx, id: 1)
+    end
+  end
+
+  def test_unpermitted_read_without_auth
+    ctx = RailsOps::Context.new(ability: ABILITY.new)
+    assert_nothing_raised do
+      LOAD_OP_WITHOUT_AUTH.new(ctx, id: 1)
+    end
+  end
+
+  def test_permitted_read
+    ctx = RailsOps::Context.new(ability: ABILITY.new(read: true))
+    assert_nothing_raised do
+      res = LOAD_OP.new(ctx, id: 1)
+      assert_equal 'Group', res.model.name
+    end
+  end
+
+  def test_unpermitted_update
+    ctx = RailsOps::Context.new(ability: ABILITY.new(read: true))
+    assert_raises CanCan::AccessDenied do
+      op = UPDATE_OP.new(ctx, id: 1, group: { name: 'Group2' })
+      res = op.run!
+      assert_equal 'Group', res.model.name
+    end
+  end
+
+  def test_permitted_update
+    ctx = RailsOps::Context.new(ability: ABILITY.new(read: true, update: true))
+    assert_nothing_raised do
+      op = UPDATE_OP.new(ctx, id: 1, group: { name: 'Group2' })
+      res = op.run!
+      assert_equal 'Group2', res.model.name
+    end
+  end
+
+  def test_unpermitted_create
+    ctx = RailsOps::Context.new(ability: ABILITY.new(read: true))
+    assert_raises CanCan::AccessDenied do
+      op = CREATE_OP.new(ctx, id: 2, group: { name: 'Group2' })
+      op.run!
+    end
+  end
+
+  def test_permitted_create
+    ctx = RailsOps::Context.new(ability: ABILITY.new(read: true, create: true))
+    assert_nothing_raised do
+      op = CREATE_OP.new(ctx, id: 2, group: { name: 'Group2' })
+      op.run!
+      res = LOAD_OP.new(id: 2)
+      assert_equal 'Group2', res.model.name
+    end
+  end
+
+  def test_unpermitted_destroy
+    ctx = RailsOps::Context.new(ability: ABILITY.new(read: true))
+    assert_raises CanCan::AccessDenied do
+      op = DESTROY_OP.new(ctx, id: 1)
+      op.run!
+    end
+  end
+
+  def test_permitted_destroy
+    ctx = RailsOps::Context.new(ability: ABILITY.new(read: true, destroy: true))
+    assert_nothing_raised do
+      op = DESTROY_OP.new(ctx, id: 1)
+      op.run!
+    end
+  end
+end

data/test/unit/rails_ops/operation/model/destroy_test.rb

@@ -0,0 +1,31 @@
+class RailsOps::Operation::Model::DestroyTest < ActiveSupport::TestCase
+  include TestHelper
+
+  BASIC_OP = Class.new(RailsOps::Operation::Model::Destroy) do
+    model Group
+  end
+
+  def test_basic
+    g = Group.create
+    op = BASIC_OP.new(id: g.id)
+    assert_equal g, op.model
+    assert_equal Group, op.model.class
+    op.run!
+    assert op.model.destroyed?
+  end
+
+  def test_not_deletable
+    g = Group.create
+    cls = Class.new(RailsOps::Operation::Model::Destroy) do
+      model Group, 'NotDeletableGroup' do
+        def deleteable?
+          false
+        end
+      end
+    end
+    op = cls.new(id: g.id)
+    assert_raises RailsOps::Exceptions::ModelNotDeleteable do
+      op.run!
+    end
+  end
+end

data/test/unit/rails_ops/operation/model/load_test.rb

@@ -51,4 +51,13 @@ class RailsOps::Operation::Model::LoadTest < ActiveSupport::TestCase
     g = Group.create(name: 'g1')
     assert_equal g, cls.new(name: 'g1').model
   end
+
+  def test_too_many_authorization_actions
+    assert_raises_with_message ArgumentError, 'Too many arguments' do
+      Class.new(RailsOps::Operation::Model::Load) do
+        model Group
+        model_authorization_action :read, :update
+      end
+    end
+  end
 end

data/test/unit/rails_ops/operation/model_test.rb

@@ -47,6 +47,21 @@ class RailsOps::Operation::ModelTest < ActiveSupport::TestCase
     assert_equal 'Example', cls.model.virtual_model_name
   end
 
+  def test_virtual_model_write_attribute
+    cls = Class.new(RailsOps::Operation::Model) do
+      model RailsOps::VirtualModel, 'Example' do
+        attribute :name, default: 'name'
+      end
+    end
+
+    assert_equal 'name', cls.model.new.read_attribute(:name)
+    assert_nothing_raised do
+      obj = cls.model.new
+      obj.write_attribute(:name, 'name2')
+      assert_equal 'name2', obj.read_attribute(:name)
+    end
+  end
+
   def test_default_model_class
     cls = Class.new(RailsOps::Operation::Model) do
       model do
@@ -64,4 +79,13 @@ class RailsOps::Operation::ModelTest < ActiveSupport::TestCase
       end
     end
   end
+
+  def test_lazy_model
+    cls = Class.new(RailsOps::Operation::Model::Create) do
+      lazy_model 'Group'
+    end
+
+    assert_not cls.model.class < Group
+    assert cls.new.model.class < Group
+  end
 end

data/test/unit/rails_ops/operation_test.rb

@@ -40,6 +40,16 @@ class RailsOps::OperationTest < ActiveSupport::TestCase
     assert BASIC_OP.new.run!.done
   end
 
+  def test_run_without_perform
+    cls = Class.new(RailsOps::Operation)
+    assert_nothing_raised do
+      cls.new
+    end
+    assert_raises NotImplementedError do
+      cls.run!
+    end
+  end
+
   def test_non_validation_error
     assert_raises_with_message RuntimeError, 'Standard exception' do
       BASIC_OP.run(exception: 'Standard exception')
@@ -146,6 +156,17 @@ class RailsOps::OperationTest < ActiveSupport::TestCase
     assert op.performed?
   end
 
+  def test_check_performed
+    op = BASIC_OP.new
+    assert_raises_with_message RuntimeError, 'Operation has not yet been performed.' do
+      op.check_performed!
+    end
+    op.run!
+    assert_nothing_raised do
+      op.check_performed!
+    end
+  end
+
   def test_inspect
     assert_equal 'RailsOps::OperationTest::BASIC_OP ({"foo"=>:bar})',
                  BASIC_OP.new(foo: :bar).inspect
@@ -155,4 +176,104 @@ class RailsOps::OperationTest < ActiveSupport::TestCase
     assert_equal 'RailsOps::OperationTest::BASIC_OP ({1=>2})',
                  BASIC_OP.new(1 => 2).inspect
   end
+
+  def test_with_rollback_on_exception
+    op = Class.new(RailsOps::Operation) do
+      def perform
+        with_rollback_on_exception do
+          fail 'Rollback please'
+        end
+      end
+    end.new
+    assert_raises RailsOps::Exceptions::RollbackRequired do
+      op.run
+    end
+  end
+
+  def test_op_with_schema3(use_default: false)
+    op = Class.new(RailsOps::Operation) do
+      schema_block = proc do
+        int! :id
+        hsh! :hash do
+          int? :number
+          int! :required_number
+        end
+      end
+      if use_default
+        schema(&schema_block)
+      else
+        schema3(&schema_block)
+      end
+    end
+
+    assert_nothing_raised do
+      op.new(id: 1, hash: { required_number: 1 })
+    end
+    assert_raises Schemacop::Exceptions::ValidationError do
+      op.new(id: 1, hash: {})
+    end
+  end
+
+  def test_op_with_schema2(use_default: false)
+    op = Class.new(RailsOps::Operation) do
+      schema_block = proc do
+        req :id, :integer
+        req :hash, :hash do
+          opt :number, :integer
+          req :required_number, :integer
+        end
+      end
+
+      if use_default
+        schema(&schema_block)
+      else
+        schema2(&schema_block)
+      end
+    end
+
+    assert_nothing_raised do
+      op.new(id: 1, hash: { required_number: 1 })
+    end
+    assert_raises Schemacop::Exceptions::ValidationError do
+      op.new(id: 1, hash: {})
+    end
+  end
+
+  def test_op_with_schema_default
+    RailsOps.config.default_schemacop_version = 3
+    test_op_with_schema3(use_default: true)
+
+    RailsOps.config.default_schemacop_version = 2
+    test_op_with_schema2(use_default: true)
+
+    RailsOps.config.default_schemacop_version = -50
+    assert_raises_with_message RuntimeError, 'Schemacop schema versions supported are 2 and 3.' do
+      test_op_with_schema3(use_default: true)
+    end
+    RailsOps.config.default_schemacop_version = 3
+  end
+
+  def test_require_context
+    op = Class.new(RailsOps::Operation) do
+      require_context :user, :session
+    end
+
+    ctx = RailsOps::Context.new(user: Class.new, session: Class.new)
+    assert_raises_with_message RailsOps::Exceptions::MissingContextAttribute, 'This operation requires the context attribute :user to be present.' do
+      op.new
+    end
+    assert_nothing_raised do
+      op.new(ctx, foo: :bar)
+    end
+  end
+
+  def test_run_through_context
+    op = Class.new(RailsOps::Operation) do
+      def perform; end
+    end
+    ctx = RailsOps::Context.new(user: Class.new, session: Class.new)
+    assert_nothing_raised do
+      ctx.run! op, foo: :bar
+    end
+  end
 end

data/test/unit/rails_ops/profiler_test.rb

@@ -0,0 +1,11 @@
+class RailsOps::ProfilerTest < ActiveSupport::TestCase
+  include TestHelper
+
+  def test_time
+    assert_output(/Test - 1\d\.\dms elapsed./) do
+      RailsOps::Profiler.time 'Test' do
+        sleep 0.010
+      end
+    end
+  end
+end