ae_declarative_authorization 0.10.1 → 0.10.2

data/test/schema.sql

@@ -1,60 +0,0 @@
-CREATE TABLE 'test_models' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'test_attr_through_id' INTEGER,
-  'content' text,
-  'country_id' integer,
-  'created_at' datetime, 
-  'updated_at' datetime
-);
-
-CREATE TABLE 'test_attrs' (
-  'id' INTEGER PRIMARY KEY NOT NULL, 
-  'test_model_id' integer,
-  'test_another_model_id' integer,
-  'test_a_third_model_id' integer,
-  'branch_id' integer,
-  'company_id' integer,
-  'test_attr_through_id' INTEGER,
-  'n_way_join_item_id' INTEGER,
-  'test_model_security_model_id' integer,
-  'attr' integer default 1
-);
-
-CREATE TABLE 'test_attr_throughs' (
-  'id' INTEGER PRIMARY KEY NOT NULL, 
-  'test_attr_id' integer
-);
-
-CREATE TABLE 'test_model_security_models' (
-  'id' INTEGER PRIMARY KEY NOT NULL, 
-  'attr' integer default 1, 
-  'attr_2' integer default 1,
-  'test_attr_id' integer
-);
-
-CREATE TABLE 'n_way_join_items' (
-  'id' INTEGER PRIMARY KEY NOT NULL
-);
-
-CREATE TABLE 'branches' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'company_id' integer,
-  'test_model_id' integer,
-  'name' text
-);
-
-CREATE TABLE 'companies' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'country_id' integer,
-  'type' text,
-  'name' text
-);
-
-CREATE TABLE 'countries' (
-  'id' INTEGER PRIMARY KEY NOT NULL,
-  'name' text
-);
-
-CREATE TABLE 'users' (
-  'id' INTEGER PRIMARY KEY NOT NULL
-);

data/test/test_helper.rb

@@ -1,117 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-
-require 'minitest/autorun'
-
-ENV['RAILS_ENV'] = 'test'
-
-require 'rails/all'
-require 'test_support/minitest_compatibility'
-
-DA_ROOT = Pathname.new(File.expand_path("..", File.dirname(__FILE__)))
-
-require DA_ROOT + File.join(%w{lib declarative_authorization authorization})
-require DA_ROOT + File.join(%w{lib declarative_authorization maintenance})
-require DA_ROOT + File.join(%w{lib declarative_authorization test helpers})
-
-class MockDataObject
-  def initialize(attrs = {})
-    attrs.each do |key, value|
-      instance_variable_set(:"@#{key}", value)
-      self.class.class_eval do
-        attr_reader key
-      end
-    end
-  end
-
-  def self.descends_from_active_record?
-    true
-  end
-
-  def self.table_name
-    name.tableize
-  end
-
-  def self.name
-    "Mock"
-  end
-
-  def self.find(*args)
-    raise StandardError, "Couldn't find #{self.name} with id #{args[0].inspect}" unless args[0]
-    new :id => args[0]
-  end
-
-  def self.find_or_initialize_by(args)
-    raise StandardError, "Syntax error: find_or_initialize by expects a hash: User.find_or_initialize_by(:id => @user.id)" unless args.is_a?(Hash)
-    new args
-  end
-end
-
-class MockUser < MockDataObject
-  def initialize(*roles)
-    options = roles.last.is_a?(::Hash) ? roles.pop : {}
-    super({:role_symbols => roles, :login => hash}.merge(options))
-  end
-
-  def initialize_copy(other)
-    @role_symbols = @role_symbols.clone
-  end
-end
-
-class User < ActiveRecord::Base
-  attr_accessor :role_symbols
-
-  scope :visible_by, ->(user) { where(id: user.id) }
-end
-
-module Test
-  module Unit
-    class TestCase < Minitest::Test
-      include Authorization::TestHelper
-    end
-  end
-end
-
-module ActiveSupport
-  class TestCase
-    include Authorization::TestHelper
-
-    def request!(user, action, reader, params = {})
-      action                           = action.to_sym if action.is_a?(String)
-      @controller.current_user         = user
-      @controller.authorization_engine = Authorization::Engine.new(reader)
-
-      ((params.delete(:clear) || []) + [:@authorized]).each do |var|
-        @controller.instance_variable_set(var, nil)
-      end
-
-      method = params.delete(:method) || :get
-
-      if Rails.version >= '5.0'
-        send method, action, params: params
-      else
-        send method, action, params
-      end
-    end
-
-    def setup
-      @routes = Rails.application.routes
-    end
-  end
-end
-
-require 'test_support/rails'
-
-begin
-  require 'grape'
-  require 'test_support/grape'
-rescue LoadError
-  # Grape is not defined in the gemspec so the Grape tests will not be run
-end

data/test/test_support/grape.rb

@@ -1,93 +0,0 @@
-require 'grape'
-require 'mocha/minitest'
-
-require DA_ROOT + File.join(%w{lib declarative_authorization controller grape})
-
-class ApiTestCase < ActiveSupport::TestCase
-  include Rack::Test::Methods
-  include Authorization::TestHelper
-
-  class << self
-    attr_accessor :api
-  end
-
-  attr_accessor :last_endpoint
-
-  def self.tests(api)
-    @api = api
-  end
-
-  def app
-    self.class.api
-  end
-
-  def request!(user, action, reader, params = {}, &block)
-    Grape::Endpoint.before_each do |endpoint|
-      self.last_endpoint = endpoint
-
-      engine = Authorization::Engine.new(reader)
-      endpoint.stubs(:current_user).returns(user)
-      endpoint.stubs(:authorization_engine).returns(engine)
-
-      ((params.delete(:clear) || []) + [:@authorized]).each do |var|
-        endpoint.instance_variable_set(var, nil)
-      end
-
-      yield endpoint if block_given?
-    end
-
-    method = params.delete(:method) || :get
-    send method, action #, params
-  end
-end
-
-class MocksAPI < Grape::API
-  include Authorization::Controller::Grape
-
-  helpers do
-    attr_accessor :authorized
-
-    def authorization_engine
-    end
-
-    def current_user
-    end
-
-    def authorized?
-      !!@authorized
-    end
-  end
-
-
-  def self.define_action_methods(*methods)
-    resource_name = name.to_param.underscore.gsub(/_api$/, '')
-    resources resource_name do
-      methods.each do |method|
-        get method do
-          @authorized = true
-          'nothing'
-        end
-      end
-    end
-  end
-
-  def self.define_resource_actions
-    define_action_methods :index, :show, :edit, :update, :new, :create, :destroy
-  end
-
-  def logger(*args)
-    Class.new do
-      def warn(*args)
-        #p args
-      end
-      alias_method :info, :warn
-      alias_method :debug, :warn
-      def warn?; end
-      alias_method :info?, :warn?
-      alias_method :debug?, :warn?
-    end.new
-  end
-end
-
-class ApplicationAPI < ActionController::Base
-end

data/test/test_support/minitest_compatibility.rb

@@ -1,27 +0,0 @@
-require 'minitest/assertions'
-
-module Minitest
-  module Assertions
-
-    # test/unit backwards compatibility methods
-    alias :assert_raise :assert_raises
-    alias :assert_not_empty :refute_empty
-    alias :assert_not_equal :refute_equal
-    alias :assert_not_in_delta :refute_in_delta
-    alias :assert_not_in_epsilon :refute_in_epsilon
-    alias :assert_not_includes :refute_includes
-    alias :assert_not_instance_of :refute_instance_of
-    alias :assert_not_kind_of :refute_kind_of
-    alias :assert_no_match :refute_match
-    alias :assert_not_nil :refute_nil
-    alias :assert_not_operator :refute_operator
-    alias :assert_not_predicate :refute_predicate
-    alias :assert_not_respond_to :refute_respond_to
-    alias :assert_not_same :refute_same
-
-  def assert_nothing_raised(*)
-    yield
-  end
-
-  end
-end

data/test/test_support/rails.rb

@@ -1,69 +0,0 @@
-require DA_ROOT + File.join(%w{lib declarative_authorization controller rails})
-
-if Rails.version < '4.2'
-  raise "Unsupported Rails version #{Rails.version}"
-end
-
-puts "Testing against rails #{Rails::VERSION::STRING}"
-
-if Rails.version >= '5.0'
-  require 'rails-controller-testing'
-  Rails::Controller::Testing.install
-end
-
-class TestApp
-  class Application < ::Rails::Application
-    config.eager_load                 = false
-    config.secret_key_base            = 'testingpurposesonly'
-    config.active_support.deprecation = :stderr
-    config.paths['config/database']   = File.expand_path('../../database.yml', __FILE__)
-    config.active_support.test_order  = :random
-    initialize!
-  end
-end
-
-class MocksController < ActionController::Base
-  attr_accessor :current_user
-  attr_writer :authorization_engine
-
-  def authorized?
-    !!@authorized
-  end
-
-  def self.define_action_methods(*methods)
-    methods.each do |method|
-      define_method method do
-        @authorized = true
-        render :plain => 'nothing'
-      end
-    end
-  end
-
-  def self.define_resource_actions
-    define_action_methods :index, :show, :edit, :update, :new, :create, :destroy
-  end
-
-  def logger(*args)
-    Class.new do
-      def warn(*args)
-        #p args
-      end
-      alias_method :info, :warn
-      alias_method :debug, :warn
-      def warn?; end
-      alias_method :info?, :warn?
-      alias_method :debug?, :warn?
-    end.new
-  end
-end
-
-class ApplicationController < ActionController::Base
-end
-
-Rails.application.routes.draw do
-  match '/name/spaced_things(/:action)' => 'name/spaced_things', via: [:get, :post, :put, :patch, :delete]
-  match '/deep/name_spaced/things(/:action)' => 'deep/name_spaced/things', via: [:get, :post, :put, :patch, :delete]
-  match '/:controller(/:action(/:id))', via: [:get, :post, :put, :patch, :delete]
-end
-
-ActionController::Base.send :include, Authorization::Controller::Rails