active_scaffold 3.7.12 → 4.0.0.rc1

data/test/misc/attribute_params_test.rb

@@ -1,460 +0,0 @@
-require 'test_helper'
-
-class AttributeParamsTest < Minitest::Test
-  def setup
-    @controller = Controller.new
-  end
-
-  def test_saving_simple_record
-    model = update_record_from_params(Person.new, :create, :first_name, :last_name, :first_name => 'First', :last_name => '')
-    assert_equal 'First', model.first_name
-    assert_nil model.last_name
-    assert model.buildings.blank?
-    assert model.save
-
-    model.buildings.create(:name => '1st building')
-    model = update_record_from_params(model, :update, :first_name, :last_name, :first_name => 'Name', :last_name => 'Last')
-    assert_equal 'Name', model.first_name
-    assert_equal 'Last', model.last_name
-    assert model.buildings.present?, 'buildings should not be cleared'
-    assert model.save
-    assert_equal 1, model.buildings_count
-  end
-
-  def test_saving_unexpected_column_is_ignored
-    model = Person.new(:first_name => 'First', :last_name => 'Last')
-    model.buildings.build(:name => '1st building')
-    assert model.save
-
-    model = update_record_from_params(model, :update, :first_name, :first_name => 'Name', :last_name => 'Surname')
-    assert_equal 'Name', model.first_name
-    assert_equal 'Last', model.last_name
-    assert model.buildings.present?, 'buildings should not be cleared'
-    assert model.save
-  end
-
-  def test_saving_multiparameter_attribute
-    model = update_record_from_params(Contact.new, :update, :first_name, :birthday, :first_name => 'Diego', :last_name => 'Velazquez', 'birthday(1i)' => '1599', 'birthday(2i)' => '6', 'birthday(3i)' => '6')
-    assert_equal 'Diego', model.first_name
-    assert_equal Date.new(1599, 6, 6), model.birthday
-  end
-
-  def test_saving_has_many_select
-    buildings = Array.new(2) { Building.create }
-    model = update_record_from_params(Person.new, :create, :first_name, :last_name, :buildings, :first_name => 'First', :last_name => '', :buildings => ['', *buildings.map { |b| b.id.to_s }]) # checkbox_list always add a hidden tag with empty value
-    assert_equal 'First', model.first_name
-    assert_nil model.last_name
-    assert_equal buildings.map(&:id), model.building_ids
-    assert_equal buildings.map(&:id), model.buildings.map(&:id)
-    assert_equal model, model.buildings[0].owner
-    assert model.save
-    assert_equal 2, model.reload.buildings_count
-
-    model = update_record_from_params(model, :update, :first_name, :last_name, :buildings, :first_name => 'Name', :last_name => 'Last', :buildings => ['']) { raise ActiveRecord::Rollback }
-    assert_equal 'Name', model.first_name
-    assert_equal 'Last', model.last_name
-    assert_equal [model.id] * 2, buildings.map { |b| b.reload.owner_id }, 'owners should not be saved'
-    assert model.building_ids.blank?, 'buildings should be cleared'
-    assert model.buildings.blank?, 'buildings should be cleared'
-    assert_equal 0, model.buildings.size
-    assert_equal 2, model.reload.buildings_count
-
-    model = update_record_from_params(model, :update, :first_name, :last_name, :buildings, :first_name => 'Name', :last_name => 'Last', :buildings => [''])
-    assert_equal 'Name', model.first_name
-    assert_equal 'Last', model.last_name
-    assert model.building_ids.blank?, 'buildings should be cleared'
-    assert model.buildings.blank?, 'buildings should be cleared'
-    assert_equal [nil] * 2, buildings.map { |b| b.reload.owner_id }, 'buildings should be saved'
-    assert model.save
-    assert_equal 0, model.reload.buildings_count
-  end
-
-  def test_saving_belongs_to_select_for_has_one_reverse
-    person = Person.create
-    assert person.persisted?
-    assert_equal 0, person.floors_count
-
-    model = update_record_from_params(Floor.new, :create, :number, :tenant, :number => '1', :tenant => person.id.to_s)
-    assert_equal 1, model.number
-    assert_equal person.id, model.tenant_id
-    assert_equal person, model.tenant
-    assert model.save
-    assert_equal 1, person.reload.floors_count
-
-    model = update_record_from_params(model, :update, :number, :tenant, :number => '1', :tenant => '')
-    assert_equal 1, model.number
-    assert_nil model.tenant_id, 'tenant should be cleared'
-    assert_nil model.tenant, 'tenant should be cleared'
-    assert_equal person.id, Floor.find(model.id).tenant_id, 'floor should not be saved yet'
-    assert model.save
-    assert_nil Floor.find(model.id).tenant_id, 'floor should be saved'
-    assert_equal 0, person.reload.floors_count
-
-    model = update_record_from_params(model, :create, :number, :tenant, :number => '1', :tenant => person.id.to_s)
-    assert_equal 1, model.number
-    assert_equal person.id, model.tenant_id
-    assert_equal person, model.tenant
-    assert model.save
-    assert_equal 1, person.reload.floors_count
-  end
-
-  def test_saving_belongs_to_select_for_has_many_reverse
-    person = Person.create
-    assert person.persisted?
-    assert_equal 0, person.buildings_count
-
-    model = update_record_from_params(Building.new, :create, :name, :owner, :name => 'Tower', :owner => person.id.to_s)
-    assert_equal 'Tower', model.name
-    assert_equal person.id, model.owner_id
-    assert_equal person, model.owner
-    assert model.save
-    assert_equal 1, person.reload.buildings_count
-
-    model = update_record_from_params(model, :update, :name, :owner, :name => 'Tower', :owner => '')
-    assert_equal 'Tower', model.name
-    assert_nil model.owner_id, 'owner should be cleared'
-    assert_nil model.owner, 'owner should be cleared'
-    assert_equal person.id, Building.find(model.id).owner_id, 'building should not be saved yet'
-    assert model.save
-    assert_nil Building.find(model.id).owner_id, 'building should be saved'
-    assert_equal 0, person.reload.buildings_count
-
-    model = update_record_from_params(model, :create, :name, :owner, :name => 'Tower', :owner => person.id.to_s)
-    assert_equal 'Tower', model.name
-    assert_equal person.id, model.owner_id
-    assert_equal person, model.owner
-    assert model.save
-    assert_equal 1, person.reload.buildings_count
-  end
-
-  def test_saving_has_one_select
-    floor = Floor.create
-    assert floor.persisted?
-
-    model = update_record_from_params(Person.new, :create, :first_name, :floor, :first_name => 'Name', :floor => floor.id.to_s)
-    assert_equal 'Name', model.first_name
-    assert model.floor.present?
-    assert_equal floor.id, model.floor.id
-    assert_equal model, model.floor.tenant
-    assert_nil floor.reload.tenant_id, 'tenant_id should not be saved yet'
-    assert model.save
-    assert_equal model.id, floor.reload.tenant_id, 'tenant_id should be saved'
-
-    model = update_record_from_params(model, :update, :first_name, :floor, :first_name => 'First', :floor => '') { raise ActiveRecord::Rollback }
-    assert_equal 'First', model.first_name
-    assert_equal model.id, floor.reload.tenant_id, 'previous car should not be saved and nullified'
-    assert_nil model.floor, 'floor should be cleared'
-
-    model.reload
-    model = update_record_from_params(model, :update, :first_name, :floor, :first_name => 'First', :floor => '')
-    assert_equal 'First', model.first_name
-    assert_nil floor.reload.tenant_id, 'previous car should be saved and nullified'
-    assert_nil model.floor, 'floor should be cleared'
-    assert model.save
-  end
-
-  def test_saving_has_one_through_select
-    building = Building.create
-    assert building.persisted?
-    assert building.floors.create(:number => 2)
-
-    model = update_record_from_params(Person.new, :create, :first_name, :home, :first_name => 'Name', :home => building.id.to_s)
-    assert_equal 'Name', model.first_name
-    assert model.home.present?
-    assert model.floor.present?
-    assert_equal [nil], building.floors.reload.map(&:tenant_id), 'floor should not be saved yet'
-    assert model.save
-    assert_equal model.id, model.floor.tenant_id, 'tenant_id should be saved'
-    assert_equal [nil, model.id], building.floors.reload.map(&:tenant_id)
-
-    model = update_record_from_params(model, :update, :first_name, :home, :first_name => 'First', :home => '') { raise ActiveRecord::Rollback }
-    assert_equal 'First', model.first_name
-    assert_equal [nil, model.id], building.floors.reload.map(&:tenant_id), 'previous floor should not be deleted'
-    assert_nil model.home, 'home should be cleared'
-
-    model.reload
-    model = update_record_from_params(model, :update, :first_name, :home, :first_name => 'First', :home => '')
-    assert_equal 'First', model.first_name
-    assert_equal [nil], building.floors.reload.map(&:tenant_id), 'previous floor should be deleted'
-    assert_nil model.home, 'home should be cleared'
-    assert model.save
-  end
-
-  def test_saving_has_many_through_select
-    people = Array.new(2) { Person.create }
-    assert people.all?(&:persisted?)
-
-    model = update_record_from_params(Building.new, :create, :name, :tenants, :name => 'Tower', :tenants => ['', *people.map { |b| b.id.to_s }]) # checkbox_list always add a hidden tag with empty value
-    assert_equal 'Tower', model.name
-    assert model.tenants.present?
-    assert_equal [nil] * 2, people.map { |p| p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true) }, 'floor should not be saved yet'
-    assert model.save
-    assert_equal [model.id] * 2, model.floors.map(&:building_id)
-    assert_equal [model.id] * 2, people.map { |p| (p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true)).building_id }, 'floor should be saved'
-
-    model = update_record_from_params(model, :update, :name, :tenants, :name => 'Skyscrapper', :tenants => ['']) { raise ActiveRecord::Rollback }
-    assert_equal 'Skyscrapper', model.name
-    assert_equal [model.id] * 2, people.map { |p| (p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true)).building_id }, 'previous floor should not be deleted'
-    assert model.tenants.empty?, 'tenants should be cleared'
-
-    model.reload
-    model = update_record_from_params(model, :update, :name, :tenants, :name => 'Skyscrapper', :tenants => [''])
-    assert_equal 'Skyscrapper', model.name
-    assert_equal [nil] * 2, people.map { |p| p.respond_to?(:reload_floor) ? p.reload_floor : p.floor(true) }, 'previous floor should be deleted'
-    assert model.tenants.empty?, 'tenants should be cleared'
-    assert model.save
-  end
-
-  def test_saving_has_many_crud_with_error
-    building = Building.create(:name => 'First')
-    key = Time.now.to_i.to_s
-    floors = {'0' => '', key => {:number => '', 'tenant' => '', :number_required => true}}
-    model = update_record_from_params(building, :create, :name, :floors, :name => 'First', :floors => floors)
-    assert_equal 'First', model.name
-    assert_equal 1, model.floors.size
-    assert model.floors.first.errors.present?
-    refute model.floors.first.persisted?
-  end
-
-  def test_saving_has_many_crud_and_belongs_to_select
-    floor = Floor.create
-    people = Array.new(2) { Person.create }
-    key = Time.now.to_i.to_s
-    floors = {'0' => '', floor.id.to_s => {:number => '1', :tenant => '', :id => floor.id.to_s}, key => {:number => '2', 'tenant' => people.first.id.to_s}, key.succ => {:number => '4', 'tenant' => people.last.id.to_s}, key.succ.succ => {:number => '', 'tenant' => ''}}
-    model = update_record_from_params(Building.new, :create, :name, :floors, :name => 'First', :floors => floors)
-    assert_equal 'First', model.name
-    assert_equal 3, model.floors.size
-    assert_equal floor.id, model.floors.first.id
-    assert_equal [nil, *people.map(&:id)], model.floors.map(&:tenant_id)
-    assert_equal model, model.floors[0].building
-    assert model.save
-    assert_equal [1, 1], people.map(&:reload).map(&:floors_count)
-    assert_equal 3, model.reload.floors_count
-
-    last_floor = model.floors.last
-    floors = {'0' => '', floor.id.to_s => {:number => '1', :tenant => '', :id => floor.id.to_s}, last_floor.id.to_s => {:number => '4', 'tenant' => people.last.id.to_s, :id => last_floor.id.to_s}}
-    model = update_record_from_params(model, :create, :name, :floors, :name => 'First', :floors => floors)
-    assert_equal 'First', model.name
-    assert_equal 2, model.floors.size
-    assert_equal floor.id, model.floors.first.id
-    assert_equal [nil, last_floor.tenant_id], model.floors.map(&:tenant_id)
-    assert model.save
-    assert_equal 2, model.reload.floors_count
-
-    floors = {'0' => '', floor.id.to_s => {:number => '1', :tenant => '', :id => floor.id.to_s}}
-    new_model = update_record_from_params(Building.create, :create, :name, :floors, :name => 'Last', :floors => floors)
-    assert_equal 'Last', new_model.name
-    assert_equal 1, new_model.floors.size
-    assert_equal floor.id, new_model.floors.first.id
-    assert_equal [nil], new_model.floors.map(&:tenant_id)
-    assert new_model.save
-    assert_equal 1, new_model.reload.floors_count
-    assert_equal 1, model.reload.floors_count
-
-    model = update_record_from_params(model, :update, :name, :floors, :name => 'Tower', :floors => {'0' => ''})
-    assert_equal 'Tower', model.name
-    assert model.floors.blank?, 'floors should be cleared'
-    assert model.save
-    assert_equal 0, model.reload.floors_count
-  end
-
-  def test_saving_belongs_to_crud
-    person = Person.create
-    assert person.persisted?
-
-    model = update_record_from_params(Car.new, :create, :brand, :person, :brand => 'Ford', :person => {:first_name => 'First'})
-    assert_equal 'Ford', model.brand
-    assert model.person.present?
-    assert model.person.new_record?
-    assert model.save
-    assert model.person.persisted?
-
-    model = update_record_from_params(model, :update, :brand, :person, :brand => 'Ford', :person => {:first_name => 'First', :id => person.id.to_s})
-    assert_equal 'Ford', model.brand
-    assert model.person.present?
-    assert_equal person.id, model.person.id
-    assert model.save
-
-    model = update_record_from_params(model, :update, :brand, :person, :brand => 'Mercedes', :person => {:first_name => ''})
-    assert_equal 'Mercedes', model.brand
-    assert_nil model.person
-    assert model.save
-  end
-
-  def test_saving_belongs_to_crud_with_boolean
-    model = update_record_from_params(Car.new, :create, :brand, :person, :brand => 'Ford', :person => {:first_name => '', :adult => '0'})
-    assert_equal 'Ford', model.brand
-    assert model.save
-    assert_nil model.person
-
-    model = update_record_from_params(model, :update, :brand, :person, :brand => 'Mercedes', :person => {:first_name => '', :adult => '1'})
-    assert_equal 'Mercedes', model.brand
-    assert model.person.present?
-    assert model.save
-    assert model.person.persisted?
-  end
-
-  def test_saving_has_one_crud
-    car = Car.create :brand => 'Renault'
-    assert car.persisted?
-
-    model = update_record_from_params(Person.new, :create, :first_name, :car, :first_name => 'First', :car => {:brand => 'Ford'})
-    assert_equal 'First', model.first_name
-    assert model.car.present?
-    assert model.car.new_record?
-    assert_equal model, model.car.person
-    assert model.save
-    assert model.car.persisted?
-
-    model = update_record_from_params(Person.new, :create, :first_name, :car, :first_name => 'First', :car => {:brand => 'Peugeot', :id => car.id.to_s})
-    assert_equal 'First', model.first_name
-    assert model.car.present?
-    assert_equal car.id, model.car.id
-    assert_nil car.reload.person_id, 'person_id should not be saved yet'
-    assert_equal 'Peugeot', model.car.brand
-    assert_equal 'Renault', car.reload.brand, 'brand should not be saved yet'
-    assert model.save
-    assert_equal model.id, car.reload.person_id, 'person_id should be saved'
-
-    model = update_record_from_params(model, :update, :first_name, :car, :first_name => 'First', :car => {:brand => 'Mercedes', :id => car.id.to_s})
-    assert_equal 'First', model.first_name
-    assert model.car.present?
-    assert_equal 'Mercedes', model.car.brand
-    assert model.save
-    assert model.save_associated
-    assert_equal 'Mercedes', car.reload.brand, 'brand should be saved'
-
-    model = update_record_from_params(model, :update, :first_name, :car, :first_name => 'First', :car => {:brand => 'Mercedes'})
-    assert_equal 'First', model.first_name
-    assert_nil Car.where(:id => car.id).first, 'previous car should be deleted'
-    assert model.car.present?
-    refute_equal car.id, model.car.id
-    assert model.save
-
-    car = model.car.reload
-    model = update_record_from_params(model, :update, :first_name, :car, :first_name => 'Name', :car => {:brand => ''})
-    assert_equal 'Name', model.first_name
-    assert_nil Car.where(:id => car.id).first, 'previous car should be deleted'
-    assert_nil model.car
-    assert model.save
-  end
-
-  def test_saving_belongs_to_polymorphic_select
-    person = Person.create
-    assert person.persisted?
-
-    model = update_record_from_params(Contact.new, :create, :first_name, :contactable_type, :contactable, :first_name => 'First', :contactable_type => person.class.name, :contactable => person.id.to_s)
-    assert_equal 'First', model.first_name
-    assert_equal person.class.name, model.contactable_type
-    assert_equal person.id, model.contactable_id
-    assert_equal person, model.contactable
-    assert model.save
-    assert_equal 1, person.reload.contacts_count
-
-    model = update_record_from_params(model, :update, :first_name, :contactable_type, :contactable, :first_name => 'Name', :contactable_type => person.class.name, :contactable => '')
-    assert_equal 'Name', model.first_name
-    assert_nil model.contactable_id, 'contactable should be cleared'
-    assert_nil model.contactable, 'contactable should be cleared'
-    assert_equal person.id, Contact.find(model.id).contactable_id, 'contact should not be saved yet'
-    assert model.save
-    assert_nil Contact.find(model.id).contactable_id, 'contact should be saved'
-    assert_equal 0, person.reload.contacts_count
-  end
-
-  def test_saving_has_many_polymorphic_select
-    contacts = Array.new(2) { Contact.create }
-
-    model = update_record_from_params(Person.new, :create, :first_name, :contacts, :first_name => 'Me', :contacts => ['', contacts.first.id.to_s])
-    assert_equal 'Me', model.first_name
-    assert model.contacts.present?
-    assert model.save
-    assert_equal [model.id], model.contacts.map(&:contactable_id)
-    assert_equal model.id, contacts.first.reload.contactable.id, 'contactable should be saved'
-    assert_equal 1, model.reload.contacts_count
-
-    model = update_record_from_params(model, :update, :first_name, :contacts, :first_name => 'Name', :contacts => ['', *contacts.map { |c| c.id.to_s }])
-    assert_equal 'Name', model.first_name
-    assert model.contacts.present?
-    assert model.save
-    assert_equal [model.id] * 2, model.contacts.map(&:contactable_id)
-    assert_equal [model.id] * 2, contacts.map { |c| c.reload.contactable.id }, 'contactable should be saved'
-    assert_equal 2, model.reload.contacts_count
-
-    model = update_record_from_params(model, :update, :first_name, :contacts, :first_name => 'Name', :contacts => [''])
-    assert_equal 'Name', model.first_name
-    assert model.contacts.empty?
-    assert model.save
-    assert_equal [nil] * 2, contacts.map { |c| c.reload.contactable }, 'contactable should be saved'
-    assert_equal 0, model.reload.contacts_count
-  end
-
-  def test_saving_habtm_select
-    roles = Array.new(2) { Role.create }
-
-    model = update_record_from_params(Person.new, :create, :first_name, :roles, :first_name => 'Me', :roles => ['', roles.first.id.to_s])
-    assert_equal 'Me', model.first_name
-    assert model.roles.present?
-    assert model.save
-    assert_equal [[model.id]], model.roles.map(&:person_ids)
-    assert_equal [model.id], roles.first.reload.person_ids, 'role should be saved'
-
-    model = update_record_from_params(model, :update, :first_name, :roles, :first_name => 'Name', :roles => ['', *roles.map { |c| c.id.to_s }])
-    assert_equal 'Name', model.first_name
-    assert model.roles.present?
-    assert model.save
-    assert_equal [[model.id]] * 2, model.roles.map(&:person_ids)
-    assert_equal [[model.id]] * 2, roles.map { |r| r.reload.person_ids }, 'roles should be saved'
-
-    model = update_record_from_params(model, :update, :first_name, :roles, :first_name => 'Name', :roles => [''])
-    assert_equal 'Name', model.first_name
-    assert model.roles.empty?
-    assert model.save
-    assert roles.all? { |r| r.reload.people.empty? }, 'roles should be saved'
-  end
-
-  protected
-
-  def update_record_from_params(record, action, *columns, &block)
-    params = columns.extract_options!.with_indifferent_access
-    new_record = nil
-    record.class.transaction do
-      record = record.class.find(record.id) if record.persisted?
-      new_record = @controller.update_record_from_params(record, build_action_columns(record, action, columns), params)
-      yield if block_given?
-      ActiveScaffold::Registry.constraint_columns.clear
-    end
-    new_record
-  end
-
-  def build_action_columns(record, action, *columns)
-    config = @controller.active_scaffold_config_for(record.class)
-    config.build_action_columns(action, columns)
-  end
-end
-
-class Controller
-  def self.helper_method(*); end
-
-  def self.before_action(*); end
-
-  include ActiveScaffold::Core
-  include ActiveScaffold::Helpers::ControllerHelpers
-  include ActiveScaffold::AttributeParams
-  public :update_record_from_params
-
-  def logger
-    @logger ||= Logger.new(STDOUT)
-  end
-
-  def flash
-    @flash ||= ActionDispatch::Flash::FlashHash.new
-  end
-
-  def params_hash?(value)
-    value.is_a? Hash
-  end
-
-  def params_hash(value)
-    value
-  end
-end

data/test/misc/calculation_test.rb

@@ -1,39 +0,0 @@
-require 'test_helper'
-require 'class_with_finder'
-
-class CalculationTest < Minitest::Test
-  def setup
-    @buildings = []
-    @buildings << Building.create { |b| b.build_owner(:first_name => 'foo') }
-    @buildings << Building.create(:name => 'foo bar')
-    @buildings << Building.create
-
-    @klass = ClassWithFinder.new
-    @klass.active_scaffold_config.stubs(:model).returns(Building)
-  end
-
-  def teardown
-    @buildings.each(&:destroy).map(&:owner).compact.each(&:destroy)
-  end
-
-  def test_calculation_with_conditions
-    @klass.expects(:conditions_for_collection).returns(['"buildings"."name" LIKE ? OR "people"."first_name" LIKE ?', '%foo%', '%foo%'])
-    @klass.expects(:active_scaffold_references).returns([:owner])
-    @klass.active_scaffold_config.expects(:list).returns(mock.tap { |m| m.stubs(:count_includes).returns(nil) })
-
-    column = mock.tap { |m| m.stubs(:field).returns('"buildings"."id"') }
-    @klass.active_scaffold_config.expects(:columns).returns(mock.tap { |m| m.stubs(:"[]").returns(column) })
-    query = @klass.send :calculate_query
-    assert_equal 2, query.count
-  end
-
-  def test_calculation_without_conditions
-    @klass.stubs(:active_scaffold_references).returns([:owner])
-    @klass.active_scaffold_config.expects(:list).returns(mock.tap { |m| m.stubs(:count_includes).returns(nil) })
-
-    column = mock.tap { |m| m.stubs(:field).returns('"buildings"."id"') }
-    @klass.active_scaffold_config.expects(:columns).returns(mock.tap { |m| m.stubs(:"[]").returns(column) })
-    query = @klass.send :calculate_query
-    assert_equal Building.count, query.count
-  end
-end

data/test/misc/configurable_test.rb

@@ -1,97 +0,0 @@
-require 'test_helper'
-
-class ConfigurableClass
-  FOO = 'bar'.freeze
-  def foo; FOO end
-
-  def self.foo; FOO end
-end
-
-class IncludedClass < ConfigurableClass
-  include ActiveScaffold::Configurable
-end
-
-class ExtendedClass < ConfigurableClass
-  extend ActiveScaffold::Configurable
-end
-
-class ConfigurableTest < Minitest::Test
-  ##
-  ## constants and methods for tests to check against
-  ##
-  def hello; 'world' end
-  HELLO = 'world'.freeze
-
-  def test_instance_configuration
-    configurable_class = IncludedClass.new
-
-    ##
-    ## sanity checks
-    ##
-    # make sure the configure method is available
-    assert configurable_class.respond_to?(:configure)
-    # make sure real functions still work
-    assert_equal 'bar', configurable_class.foo
-    # make sure other functions still don't work
-    assert_raises NoMethodError do
-      configurable_class.i_do_not_exist
-    end
-
-    ##
-    ## test normal block behaviors
-    ##
-    # functions
-    assert_equal hello, (configurable_class.configure { hello })
-    # variables
-    assert_equal configurable_class, (configurable_class.configure { configurable_class })
-    # constants
-    assert_equal ConfigurableTest::HELLO, (configurable_class.configure { ConfigurableTest::HELLO })
-
-    ##
-    ## test extra "localized" block behavior
-    ##
-    # functions
-    assert_equal configurable_class.foo, (configurable_class.configure { foo })
-    # constants - not working
-    #    assert_equal configurable_class.FOO, configurable_class.configure {FOO}
-  end
-
-  def test_class_configuration
-    ##
-    ## sanity checks
-    ##
-    # make sure the configure method is available
-    assert ExtendedClass.respond_to?(:configure)
-    # make sure real functions still work
-    assert_equal 'bar', ExtendedClass.foo
-    # make sure other functions still don't work
-    assert_raises NoMethodError do
-      ExtendedClass.i_do_not_exist
-    end
-
-    ##
-    ## test normal block behaviors
-    ##
-    # functions
-    assert_equal hello, (ExtendedClass.configure { hello })
-    # variables
-    assert_equal ExtendedClass, (ExtendedClass.configure { ExtendedClass })
-    # constants
-    assert_equal ConfigurableTest::HELLO, (ExtendedClass.configure { ConfigurableTest::HELLO })
-
-    ##
-    ## test extra "localized" block behavior
-    ##
-    # functions
-    assert_equal ExtendedClass.foo, (ExtendedClass.configure { foo })
-    # constants - not working
-    #    assert_equal ExtendedClass.FOO, ExtendedClass.configure {FOO}
-  end
-
-  def test_arity
-    # this is the main style
-    assert_equal 'foo', (ExtendedClass.configure { 'foo' })
-    # but we want to let people accept the configurable class as the first argument, too
-    assert_equal 'bar', (ExtendedClass.configure { |a| a.foo }) # rubocop:disable Style/SymbolProc
-  end
-end