active_scaffold 3.7.12 → 4.0.0.rc1

data/test/misc/constraints_test.rb

@@ -1,209 +0,0 @@
-require 'test_helper'
-
-module ModelStubs
-  class ModelStub < ActiveRecord::Base
-    self.abstract_class = true
-    def self.columns; @columns ||= [ColumnMock.new('foo', '', 'string')] end
-
-    def self.columns_hash; @hash ||= Hash[@columns.map { |c| [c.name, c] }] end
-
-    if respond_to? :type_for_attribute
-      def self.type_for_attribute(column_name)
-        defined?(ActiveModel::Type) ? ActiveModel::Type::String.new : super
-      end
-    end
-
-    def self.table_name
-      @table_name || to_s.split('::').last.underscore.pluralize
-    end
-    self.store_full_sti_class = false
-    def self.load_schema; end
-  end
-
-  ##
-  ## Standard associations
-  ##
-
-  class Address < ModelStub
-    belongs_to :addressable, :polymorphic => true
-  end
-
-  class User < ModelStub
-    has_and_belongs_to_many :roles
-    has_one :subscription
-    has_one :address, :as => :addressable
-  end
-
-  class Service < ModelStub
-    has_many :subscriptions
-    has_many :users, :through => :subscriptions
-  end
-
-  class Subscription < ModelStub
-    belongs_to :service
-    belongs_to :user
-  end
-
-  class Role < ModelStub
-    has_and_belongs_to_many :users
-  end
-
-  ##
-  ## These versions of the associations require extra configuration to work properly
-  ##
-
-  class OtherAddress < ModelStub
-    self.table_name = 'addresses'
-    belongs_to :other_addressable, :polymorphic => true
-  end
-
-  class OtherUser < ModelStub
-    self.table_name = 'users'
-    has_and_belongs_to_many :other_roles, :class_name => 'ModelStubs::OtherRole', :foreign_key => 'user_id', :association_foreign_key => 'role_id', :join_table => 'roles_users'
-    has_one :other_subscription, :class_name => 'ModelStubs::OtherSubscription', :foreign_key => 'user_id'
-    has_one :other_address, :as => :other_addressable, :class_name => 'ModelStubs::OtherAddress', :foreign_key => 'addressable_id'
-  end
-
-  class OtherService < ModelStub
-    self.table_name = 'services'
-    has_many :other_subscriptions, :class_name => 'ModelStubs::OtherSubscription', :foreign_key => 'service_id'
-    has_many :other_users, :through => :other_subscriptions # :class_name and :foreign_key are ignored for :through
-  end
-
-  class OtherSubscription < ModelStub
-    self.table_name = 'subscriptions'
-    belongs_to :other_service, :class_name => 'ModelStubs::OtherService', :foreign_key => 'service_id'
-    belongs_to :other_user, :class_name => 'ModelStubs::OtherUser', :foreign_key => 'user_id'
-  end
-
-  class OtherRole < ModelStub
-    self.table_name = 'roles'
-    has_and_belongs_to_many :other_users, :class_name => 'ModelStubs::OtherUser', :foreign_key => 'role_id', :association_foreign_key => 'user_id', :join_table => 'roles_users'
-  end
-
-  class PrimaryKeyUser < ModelStub
-    has_many :locations, :class_name => 'PrimaryKeyLocation', :foreign_key => :username, :primary_key => :name
-  end
-
-  class PrimaryKeyLocation < ModelStub
-    belongs_to :user, :class_name => 'PrimaryKeyUser', :foreign_key => :username, :primary_key => :name
-  end
-end
-
-class ConstraintsTestObject
-  # stub out what the mixin expects to find ...
-  def self.before_action(*); end
-
-  def self.helper_method(*); end
-  attr_accessor :active_scaffold_preload
-  attr_accessor :active_scaffold_references
-  attr_accessor :active_scaffold_habtm_joins
-  attr_accessor :active_scaffold_config
-  attr_accessor :params
-  def merge_conditions(old, new)
-    [old, new].compact.flatten
-  end
-
-  # mixin the constraint code
-  include ActiveScaffold::Constraints
-
-  # make the constraints read-write, instead of coming from the session
-  attr_accessor :active_scaffold_constraints
-
-  def initialize
-    @active_scaffold_preload = []
-    @active_scaffold_references = []
-    @active_scaffold_habtm_joins = []
-    @params = {}
-  end
-
-  def params_hash?(value)
-    value.is_a? Hash
-  end
-end
-
-class ConstraintsTest < Minitest::Test
-  def setup
-    @test_object = ConstraintsTestObject.new
-  end
-
-  def test_constraint_conditions_for_default_associations
-    @test_object.active_scaffold_config = config_for('user')
-    # has_one (vs belongs_to)
-    assert_constraint_condition({:subscription => 5}, [{'subscriptions' => {'id' => 5}}], 'find the user with subscription #5')
-    # habtm (vs habtm)
-    assert_constraint_condition({:roles => 4}, [{'roles' => {'id' => 4}}], 'find all users with role #4')
-    # has_one (vs polymorphic)
-    assert_constraint_condition({:address => 11}, [{'addresses' => {'id' => 11}}], 'find the user with address #11')
-    # reverse of a has_many :through
-    assert_constraint_condition({:subscription => {:service => 5}}, [{'services' => {'id' => 5}}], 'find all users subscribed to service #5')
-    assert(@test_object.active_scaffold_references.include?(:subscription => :service), 'multi-level association include')
-
-    @test_object.active_scaffold_config = config_for('subscription')
-    # belongs_to (vs has_one)
-    assert_constraint_condition({:user => 2}, [{'subscriptions' => {'user_id' => 2}}], 'find the subscription for user #2')
-    # belongs_to (vs has_many)
-    assert_constraint_condition({:service => 1}, [{'subscriptions' => {'service_id' => 1}}], 'find all subscriptions for service #1')
-
-    @test_object.active_scaffold_config = config_for('service')
-    # has_many (vs belongs_to)
-    assert_constraint_condition({:subscriptions => 10}, [{'subscriptions' => {'id' => 10}}], 'find the service with subscription #10')
-    # has_many :through (through has_many)
-    assert_constraint_condition({:users => 7}, [{'users' => {'id' => 7}}], 'find the service with user #7')
-
-    @test_object.active_scaffold_config = config_for('address')
-    # belongs_to :polymorphic => true
-    assert_constraint_condition({:addressable => ['ModelStubs::User', 14]}, [{'addresses' => {'addressable_id' => 14, 'addressable_type' => 'ModelStubs::User'}}], 'find all addresses for user #14')
-  end
-
-  def test_constraint_conditions_for_configured_associations
-    @test_object.active_scaffold_config = config_for('other_user')
-    # has_one (vs belongs_to)
-    assert_constraint_condition({:other_subscription => 5}, [{'subscriptions' => {'id' => 5}}], 'find the user with subscription #5')
-    # habtm (vs habtm)
-    assert_constraint_condition({:other_roles => 4}, [{'roles' => {'id' => 4}}], 'find all users with role #4')
-    # has_one (vs polymorphic)
-    assert_constraint_condition({:other_address => 11}, [{'addresses' => {'id' => 11}}], 'find the user with address #11')
-    # reverse of a has_many :through
-    assert_constraint_condition({:other_subscription => {:other_service => 5}}, [{'services' => {'id' => 5}}], 'find all users subscribed to service #5')
-
-    @test_object.active_scaffold_config = config_for('other_subscription')
-    # belongs_to (vs has_one)
-    assert_constraint_condition({:other_user => 2}, [{'subscriptions' => {'user_id' => 2}}], 'find the subscription for user #2')
-    # belongs_to (vs has_many)
-    assert_constraint_condition({:other_service => 1}, [{'subscriptions' => {'service_id' => 1}}], 'find all subscriptions for service #1')
-
-    @test_object.active_scaffold_config = config_for('other_service')
-    # has_many (vs belongs_to)
-    assert_constraint_condition({:other_subscriptions => 10}, [{'subscriptions' => {'id' => 10}}], 'find the service with subscription #10')
-    # has_many :through (through has_many)
-    assert_constraint_condition({:other_users => 7}, [{'users' => {'id' => 7}}], 'find the service with user #7')
-
-    @test_object.active_scaffold_config = config_for('other_address')
-    # belongs_to :polymorphic => true
-    assert_constraint_condition({:other_addressable => ['ModelStubs::OtherUser', 14]}, [{'addresses' => {'other_addressable_id' => 14, 'other_addressable_type' => 'ModelStubs::OtherUser'}}], 'find all addresses for user #14')
-  end
-
-  def test_constraint_conditions_for_normal_attributes
-    @test_object.active_scaffold_config = config_for('user')
-    assert_constraint_condition({'foo' => 'bar'}, [['"users"."foo" = ?', 'bar']], 'normal column-based constraint')
-  end
-
-  def test_constraint_conditions_for_associations_with_primary_key_option
-    @test_object.active_scaffold_config = config_for('primary_key_location')
-    # user = ModelStubs::PrimaryKeyUser.new(:id => 1, :name => 'User Name')
-    ModelStubs::PrimaryKeyUser.expects(:find).with(1).returns(stub(:id => 1, :name => 'User Name'))
-    assert_constraint_condition({'user' => 1}, [{'primary_key_locations' => {'username' => 'User Name'}}], 'association with primary-key constraint')
-  end
-
-  protected
-
-  def assert_constraint_condition(constraint, condition, message = nil)
-    @test_object.active_scaffold_constraints = constraint
-    assert_equal condition, @test_object.send(:conditions_from_constraints), message
-  end
-
-  def config_for(klass, namespace = nil)
-    super(klass, 'model_stubs/')
-  end
-end

data/test/misc/convert_numbers_format_test.rb

@@ -1,171 +0,0 @@
-require 'test_helper'
-require 'active_scaffold_config_mock'
-
-class NumberModel < ActiveRecord::Base
-  include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Model
-  def self.columns
-    @columns ||= [ColumnMock.new('id', '', 'int(11)'), ColumnMock.new('number', '', 'double(10,2)')]
-  end
-
-  def self.columns_hash
-    @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
-  end
-
-  def self.load_schema!
-    columns_hash.each do |name, column|
-      define_attribute(
-        name,
-        connection.lookup_cast_type_from_column(column),
-        default: column.default
-      )
-    end
-  end
-end
-
-class ConvertNumbersFormatTest < Minitest::Test
-  include ActiveScaffoldConfigMock
-  include ActiveScaffold::AttributeParams
-  include ActiveScaffold::Finder
-  include ActiveScaffold::Helpers::ControllerHelpers
-
-  def setup
-    NumberModel.load_schema! if Rails.version >= '5.0'
-    I18n.backend.store_translations :en, :number => {:format => {
-      :delimiter => ',',
-      :separator => '.'
-    }}
-    I18n.backend.store_translations :es, :number => {:format => {
-      :delimiter => '.',
-      :separator => ','
-    }}
-    I18n.backend.store_translations :ru, :number => {:currency => {
-      :format => {
-        :separator => ',',
-        :delimiter => ''
-      }
-    }}
-
-    @config = config_for('number_model')
-    @config.columns[:number].form_ui = nil
-  end
-
-  def teardown
-    I18n.locale = :en
-  end
-
-  def test_english_format_with_decimal_separator_using_english_language
-    I18n.locale = :en
-    assert_equal 0.1, convert_number('.1')
-    assert_equal 0.1, convert_number('.100')
-    assert_equal 0.1, convert_number('0.1')
-    assert_equal 0.345, convert_number('0.345')
-    assert_equal 0.345, convert_number('+0.345')
-    assert_equal(-0.345, convert_number('-0.345'))
-    assert_equal 9.345, convert_number('9.345')
-    assert_equal 9.1, convert_number('9.1')
-    assert_equal 90.1, convert_number('90.1')
-  end
-
-  def test_english_format_with_thousand_delimiter_using_english_language
-    I18n.locale = :en
-    assert_equal 1000, convert_number('1,000')
-    assert_equal 1000, convert_number('+1,000')
-    assert_equal(-1000, convert_number('-1,000'))
-    assert_equal 1_000_000, convert_number('1,000,000')
-  end
-
-  def test_english_format_with_separator_and_delimiter_using_english_language
-    I18n.locale = :en
-    assert_equal 1234.1, convert_number('1,234.1')
-    assert_equal 1234.1, convert_number('1,234.100')
-    assert_equal 1234.345, convert_number('+1,234.345')
-    assert_equal(-1234.345, convert_number('-1,234.345'))
-    assert_equal 1_234_000.1, convert_number('1,234,000.100')
-  end
-
-  def test_english_format_with_decimal_separator_using_spanish_language
-    I18n.locale = :es
-    assert_equal 0.1, convert_number('.1')
-    assert_equal 0.1, convert_number('0.1')
-    assert_equal 0.12, convert_number('+0.12')
-    assert_equal(-0.12, convert_number('-0.12'))
-    assert_equal 9.1, convert_number('9.1')
-    assert_equal 90.1, convert_number('90.1')
-  end
-
-  def test_spanish_format_with_decimal_separator_using_spanish_language
-    I18n.locale = :es
-    assert_equal 0.1, convert_number(',1')
-    assert_equal 0.1, convert_number(',100')
-    assert_equal 0.1, convert_number('0,1')
-    assert_equal 0.345, convert_number('0,345')
-    assert_equal 0.345, convert_number('+0,345')
-    assert_equal(-0.345, convert_number('-0,345'))
-    assert_equal 9.1, convert_number('9,1')
-    assert_equal 90.1, convert_number('90,1')
-    assert_equal 9.1, convert_number('9,100')
-  end
-
-  def test_spanish_format_with_thousand_delimiter_using_spanish_language
-    I18n.locale = :es
-    assert_equal 1000, convert_number('1.000')
-    assert_equal 1000, convert_number('+1.000')
-    assert_equal(-1000, convert_number('-1.000'))
-    assert_equal 1_000_000, convert_number('1.000.000')
-  end
-
-  def test_spanish_format_with_separator_and_decimal_using_spanish_language
-    I18n.locale = :es
-    assert_equal 1230.1, convert_number('1.230,1')
-    assert_equal 1230.1, convert_number('1.230,100')
-    assert_equal 1234.345, convert_number('+1.234,345')
-    assert_equal(-1234.345, convert_number('-1.234,345'))
-    assert_equal 1_234_000.1, convert_number('1.234.000,100')
-  end
-
-  def test_english_currency_format_with_decimal_separator_using_russian_language
-    I18n.locale = :ru
-    assert_equal 0.1, convert_number('.1', :currency)
-    assert_equal 0.1, convert_number('0.1', :currency)
-    assert_equal 0.12, convert_number('+0.12', :currency)
-    assert_equal(-0.12, convert_number('-0.12', :currency))
-    assert_equal 9.1, convert_number('9.1', :currency)
-    assert_equal 90.1, convert_number('90.1', :currency)
-  end
-
-  def test_russian_currency_format_with_decimal_separator_using_russian_language
-    I18n.locale = :ru
-    assert_equal 0.1, convert_number(',1', :currency)
-    assert_equal 0.1, convert_number(',100', :currency)
-    assert_equal 0.1, convert_number('0,1', :currency)
-    assert_equal 0.345, convert_number('0,345', :currency)
-    assert_equal 0.345, convert_number('+0,345', :currency)
-    assert_equal(-0.345, convert_number('-0,345', :currency))
-    assert_equal 9.1, convert_number('9,1', :currency)
-    assert_equal 90.1, convert_number('90,1', :currency)
-    assert_equal 9.1, convert_number('9,100', :currency)
-  end
-
-  def test_english_format_with_decimal_separator_with_no_localized_format
-    I18n.locale = :ru
-    assert_equal 0.1, convert_number('.1')
-    assert_equal 0.1, convert_number('0.1')
-  end
-
-  private
-
-  def convert_number(value, format = nil)
-    record = NumberModel.new
-    @config.columns[:number].options[:format] = format unless format.nil?
-    update_record_from_params(record, @config.create.columns, HashWithIndifferentAccess.new(:number => value))
-    record.number
-  end
-
-  def params_hash?(value)
-    value.is_a? Hash
-  end
-
-  def params_hash(value)
-    value
-  end
-end

data/test/misc/finder_test.rb

@@ -1,124 +0,0 @@
-require 'test_helper'
-require 'class_with_finder'
-
-class FinderTest < Minitest::Test
-  def setup
-    @klass = ClassWithFinder.new
-    @klass.active_scaffold_config.stubs(model: ModelStub)
-  end
-
-  def test_create_conditions_for_columns
-    columns = [
-      ActiveScaffold::DataStructures::Column.new(:a, ModelStub),
-      ActiveScaffold::DataStructures::Column.new(:b, ModelStub)
-    ]
-    tokens = %w[foo bar]
-
-    expected_conditions = [
-      ['"model_stubs"."a" LIKE ? OR "model_stubs"."b" LIKE ?', '%foo%', '%foo%'],
-      ['"model_stubs"."a" LIKE ? OR "model_stubs"."b" LIKE ?', '%bar%', '%bar%']
-    ]
-    assert_equal expected_conditions, ClassWithFinder.conditions_for_columns(tokens, columns)
-
-    expected_conditions = [
-      '"model_stubs"."a" LIKE ? OR "model_stubs"."b" LIKE ?',
-      '%foo%', '%foo%'
-    ]
-    assert_equal [expected_conditions], ClassWithFinder.conditions_for_columns('foo', columns)
-
-    assert_nil ClassWithFinder.conditions_for_columns('foo', [])
-  end
-
-  def test_method_sorting
-    column = ActiveScaffold::DataStructures::Column.new('a', ModelStub)
-    column.sort_by :method => proc { self }
-
-    collection = [16_000, 2853, 98_765, 6188, 4]
-    assert_equal collection.sort, @klass.send(:sort_collection_by_column, collection, column, 'asc')
-    assert_equal collection.sort.reverse, @klass.send(:sort_collection_by_column, collection, column, 'desc')
-
-    collection = ['a', nil, 'b']
-    result = @klass.send(:sort_collection_by_column, collection, column, 'asc')
-    assert_equal [nil, 'a', 'b'], result
-
-    column.sort_by :method => 'self'
-    collection = [3, 1, 2]
-    assert_equal collection.sort, @klass.send(:sort_collection_by_column, collection, column, 'asc')
-  end
-
-  def test_count_with_group
-    @klass.expects(:custom_finder_options).returns(:group => :a)
-    relation_class.any_instance.expects(:count).returns('foo' => 5, 'bar' => 4)
-    relation_class.any_instance.expects(:limit).with(20).returns(ModelStub.where(nil))
-    relation_class.any_instance.expects(:offset).with(0).returns(ModelStub.where(nil))
-    page = @klass.send :find_page, :per_page => 20, :pagination => true
-    page.items
-
-    assert_kind_of Integer, page.pager.count
-    assert_equal 2, page.pager.count
-    assert_equal 1, page.pager.number_of_pages
-  end
-
-  def test_disabled_pagination
-    relation_class.any_instance.expects(:count).never
-    relation_class.any_instance.expects(:limit).never
-    relation_class.any_instance.expects(:offset).never
-    ModelStub.expects(:count).never
-    page = @klass.send :find_page, :per_page => 20, :pagination => false
-    page.items
-  end
-
-  def test_infinite_pagination
-    ModelStub.expects(:count).never
-    @klass.send :find_page, :pagination => :infinite
-  end
-
-  def test_condition_for_column
-    column = ActiveScaffold::DataStructures::Column.new('adult', Person)
-    assert_equal ['"people"."adult" = ?', false], ClassWithFinder.condition_for_column(column, '0', :full, {})
-  end
-
-  def test_condition_for_polymorphic_column
-    column = ActiveScaffold::DataStructures::Column.new('addressable', Address)
-    column.search_sql = [{subquery: [Building, 'name']}]
-    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
-    assert_equal Building.where(['name LIKE ?', '%test search%']).select(:id).to_sql, condition[1].to_sql
-    assert_equal '"addresses"."addressable_id" IN (?) AND "addresses"."addressable_type" = ?', condition[0]
-    assert_equal ['Building'], condition[2..-1]
-  end
-
-  def test_condition_for_polymorphic_column_with_relation
-    column = ActiveScaffold::DataStructures::Column.new('contactable', Contact)
-    column.search_sql = [{subquery: [Person.joins(:buildings), 'first_name', 'last_name']}]
-    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
-    assert_equal Person.joins(:buildings).where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
-    assert_equal '"contacts"."contactable_id" IN (?) AND "contacts"."contactable_type" = ?', condition[0]
-    assert_equal ['Person'], condition[2..-1]
-  end
-
-  def test_subquery_condition_for_association_with_condition
-    column = ActiveScaffold::DataStructures::Column.new('owner', Building)
-    column.search_sql = [{subquery: [Person, 'first_name', 'last_name'], conditions: ['floor_count > 0']}]
-    column.search_ui = :text
-    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
-    assert_equal Person.where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
-    assert_equal '"buildings"."owner_id" IN (?) AND floor_count > 0', condition[0]
-    assert_equal [], condition[2..-1]
-  end
-
-  def test_subquery_condition_for_association_with_conditions
-    column = ActiveScaffold::DataStructures::Column.new('owner', Building)
-    column.search_sql = [{subquery: [Person, 'first_name', 'last_name'], conditions: ['floor_count > 0 AND name != ?', '']}]
-    column.search_ui = :text
-    condition = ClassWithFinder.condition_for_column(column, 'test search', :full, {})
-    assert_equal Person.where(['first_name LIKE ? OR last_name LIKE ?', '%test search%', '%test search%']).select(:id).to_sql, condition[1].to_sql
-    assert_equal '"buildings"."owner_id" IN (?) AND floor_count > 0 AND name != ?', condition[0]
-    assert_equal [''], condition[2..-1]
-  end
-
-  private
-
-  def relation_class
-    @klass.active_scaffold_config.model.send(:relation).class
-  end
-end

data/test/misc/lang_test.rb

@@ -1,10 +0,0 @@
-require 'test_helper'
-
-class LocalizationTest < Minitest::Test
-  def test_localization
-    assert_equal 'Dutch', as_(:dutch)
-    assert_equal 'dutch', as_('dutch')
-    I18n.backend.store_translations :en, :active_scaffold => {:create_model => 'Create %<model>s'}
-    assert_equal 'Create Test', as_(:create_model, :model => 'Test')
-  end
-end

data/test/misc/parse_datetime_test.rb

@@ -1,159 +0,0 @@
-require 'test_helper'
-require 'active_scaffold_config_mock'
-
-class DateTimeModel < ActiveRecord::Base
-  include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Model
-  def self.columns
-    @columns ||= [ColumnMock.new('id', '', 'int(11)'), ColumnMock.new('run_at', '', 'datetime')]
-  end
-
-  def self.columns_hash
-    @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
-  end
-
-  def self.load_schema!
-    columns_hash.each do |name, column|
-      define_attribute(
-        name,
-        connection.lookup_cast_type_from_column(column),
-        default: column.default
-      )
-    end
-  end
-end
-
-class ParseDatetimeTest < Minitest::Test
-  include ActiveScaffoldConfigMock
-  include ActiveScaffold::AttributeParams
-  include ActiveScaffold::Finder
-
-  def setup
-    DateTimeModel.load_schema! if Rails.version >= '5.0'
-    spanish = {
-      time: {
-        formats: {picker: '%a, %d %b %Y %H:%M:%S'}
-      },
-      date: {
-        day_names: %w[Domingo Lunes Martes Miércoles Jueves Viernes Sábado],
-        abbr_day_names: %w[Dom Lun Mar Mié Jue Vie Sáb],
-        month_names: [nil, 'Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre'],
-        abbr_month_names: [nil, 'Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic'],
-        formats: {default: '%Y-%m-%d', long: '%d de %B de %Y'}
-      }
-    }
-    I18n.backend.store_translations :es, spanish
-
-    @config = config_for('date_time_model')
-  end
-
-  def teardown
-    I18n.locale = :en
-  end
-
-  def test_translate_to_english
-    I18n.locale = :es
-    assert_equal 'Mon, 03 Apr 2017 16:30:26', translate_datetime('Lun, 03 Abr 2017 16:30:26')
-    assert_equal 'Fri, 24 Mar 2017 16:30:26', translate_datetime('Vie, 24 Mar 2017 16:30:26')
-    assert_equal 'Tue, 28 Mar 2017 16:30:26', translate_datetime('Mar, 28 Mar 2017 16:30:26')
-  end
-
-  def test_translate_to_english_with_different_order
-    I18n.locale = :es
-    format = '%d %b %Y, %a, %H:%M:%S'
-    assert_equal '03 Apr 2017, Mon, 16:30:26', translate_datetime('03 Abr 2017, Lun, 16:30:26', format)
-    assert_equal '24 Mar 2017, Fri, 16:30:26', translate_datetime('24 Mar 2017, Vie, 16:30:26', format)
-    assert_equal '28 Mar 2017, Tue, 16:30:26', translate_datetime('28 Mar 2017, Mar, 16:30:26', format)
-  end
-
-  def test_translate_to_english_with_words
-    I18n.locale = :es
-    format = '%A, %d de %B %Y, %H:%M:%S'
-    assert_equal 'Monday, 03 de April de 2017, 16:30:26', translate_datetime('Lunes, 03 de Abril de 2017, 16:30:26', format)
-    assert_equal 'Friday, 24 de March de 2017, 16:30:26', translate_datetime('Viernes, 24 de Marzo de 2017, 16:30:26', format)
-    assert_equal 'Tuesday, 28 de March de 2017, 16:30:26', translate_datetime('Martes, 28 de Marzo de 2017, 16:30:26', format)
-  end
-
-  def test_condition_for_spanish_datetime
-    with_js_framework :jquery do
-      I18n.locale = :es
-      assert_equal Time.zone.local(2017, 4, 3, 16, 30, 26), condition_value('Lun, 03 Abr 2017 16:30:26')
-      assert_equal Time.zone.local(2017, 3, 24, 16, 30, 26), condition_value('Vie, 24 Mar 2017 16:30:26')
-      assert_equal Time.zone.local(2017, 3, 28, 16, 30, 26), condition_value('Mar, 28 Mar 2017 16:30:26')
-    end
-  end
-
-  def test_condition_for_english_datetime
-    with_js_framework :jquery do
-      assert_equal Time.zone.local(2017, 4, 3, 16, 30, 26), condition_value('Mon, 03 Apr 2017 16:30:26')
-      assert_equal Time.zone.local(2017, 3, 24, 16, 30, 26), condition_value('Fri, 24 Mar 2017 16:30:26')
-      assert_equal Time.zone.local(2017, 3, 28, 16, 30, 26), condition_value('Tue, 28 Mar 2017 16:30:26')
-    end
-  end
-
-  def test_condition_for_english_datetime_without_time
-    with_js_framework :jquery do
-      assert_equal Time.zone.local(2017, 4, 3, 0, 0, 0), condition_value('Mon, 03 Apr 2017')
-      assert_equal Time.zone.local(2017, 3, 24, 0, 0, 0), condition_value('Fri, 24 Mar 2017')
-      assert_equal Time.zone.local(2017, 3, 28, 0, 0, 0), condition_value('Tue, 28 Mar 2017')
-    end
-  end
-
-  def test_condition_for_default_datetime_without_time
-    assert_equal Time.zone.local(2017, 4, 3, 0, 0, 0), condition_value('2017-04-03')
-    assert_equal Time.zone.local(2017, 3, 24, 0, 0, 0), condition_value('2017-03-24')
-    assert_equal Time.zone.local(2017, 3, 28, 0, 0, 0), condition_value('2017-03-28')
-  end
-
-  def test_condition_for_english_datetime_without_seconds
-    with_js_framework :jquery do
-      assert_equal Time.zone.local(2017, 4, 3, 16, 30), condition_value('Mon, 03 Apr 2017 16:30')
-      assert_equal Time.zone.local(2017, 3, 24, 16, 30), condition_value('Fri, 24 Mar 2017 16:30')
-      assert_equal Time.zone.local(2017, 3, 28, 16, 30), condition_value('Tue, 28 Mar 2017 16:30')
-    end
-  end
-
-  def test_condition_for_default_datetime_without_seconds
-    assert_equal Time.zone.local(2017, 4, 3, 16, 30, 0), condition_value('2017-04-03 16:30')
-    assert_equal Time.zone.local(2017, 3, 24, 16, 30, 0), condition_value('2017-03-24 16:30')
-    assert_equal Time.zone.local(2017, 3, 28, 16, 30, 0), condition_value('2017-03-28 16:30')
-  end
-
-  def test_condition_for_time
-    assert_equal Time.current.change(hour: 16, min: 30), condition_value('16:30')
-    assert_equal Time.current.change(hour: 16, min: 30, sec: 26), condition_value('16:30:26')
-  end
-
-  def test_condition_for_datetime_with_zone
-    assert_equal ActiveSupport::TimeZone[3].local(2017, 4, 8, 16, 30, 0), condition_value('2017-04-08 16:30 +0300')
-  end
-
-  def test_condition_for_spanish_date
-    @config.columns[:run_at].options[:format] = :long
-    I18n.locale = :es
-    assert_equal Date.new(2017, 4, 3), condition_value('03 de Abril de 2017', :to_date)
-    assert_equal Date.new(2017, 3, 24), condition_value('24 de Marzo de 2017', :to_date)
-    assert_equal Date.new(2017, 3, 28), condition_value('28 de Marzo de 2017', :to_date)
-  end
-
-  def test_condition_for_english_date
-    @config.columns[:run_at].options[:format] = :long
-    assert_equal Date.new(2017, 4, 3), condition_value('April 03, 2017', :to_date)
-    assert_equal Date.new(2017, 3, 24), condition_value('March 24, 2017', :to_date)
-    assert_equal Date.new(2017, 3, 28), condition_value('March 28, 2017', :to_date)
-  end
-
-  private
-
-  def translate_datetime(value, format = nil)
-    format ||= I18n.t('time.formats.picker')
-    self.class.translate_days_and_months(value, format)
-  end
-
-  def condition_value(value, conversion = nil)
-    self.class.condition_value_for_datetime(@config.columns[:run_at], value, conversion || :to_time)
-  end
-
-  def params_hash?(value)
-    value.is_a? Hash
-  end
-end

data/test/misc/render_test.rb

@@ -1,9 +0,0 @@
-require 'test_helper'
-
-class RenderTest < ActionController::TestCase
-  tests AddressesController
-  test 'render activescaffold views' do
-    get :index
-    assert_select 'div.active-scaffold'
-  end
-end