shoulda-matchers 3.1.3 → 4.0.0.rc1

data/spec/unit/shoulda/matchers/active_record/have_secure_token_matcher_spec.rb

@@ -0,0 +1,169 @@
+require 'unit_spec_helper'
+
+# rubocop:disable Metrics/BlockLength
+describe Shoulda::Matchers::ActiveRecord::HaveSecureTokenMatcher,
+  type: :model do
+
+  if active_record_supports_has_secure_token?
+    describe '#description' do
+      it 'returns the message including the name of the default column' do
+        matcher = have_secure_token
+        expect(matcher.description).
+          to eq('have :token as a secure token')
+      end
+
+      it 'returns the message including the name of a provided column' do
+        matcher = have_secure_token(:special_token)
+        expect(matcher.description).
+          to eq('have :special_token as a secure token')
+      end
+    end
+
+    it 'matches when the subject configures has_secure_token with the db' do
+      create_table(:users) do |t|
+        t.string :token
+        t.index :token, unique: true
+      end
+
+      valid_model = define_model_class(:User) { has_secure_token }
+
+      expect(valid_model.new).to have_secure_token
+    end
+
+    it 'matches when the subject configures has_secure_token with the db for ' \
+       'a custom attribute' do
+      create_table(:users) do |t|
+        t.string :auth_token
+        t.index :auth_token, unique: true
+      end
+
+      valid_model = define_model_class(:User) { has_secure_token(:auth_token) }
+      expect(valid_model.new).to have_secure_token(:auth_token)
+    end
+
+    it 'does not match when missing an token index' do
+      create_table(:users) do |t|
+        t.string :token
+      end
+
+      invalid_model = define_model_class(:User) { has_secure_token }
+      expected_message =
+        'Expected User to have :token as a secure token but the following ' \
+        'errors were found: missing unique index for users.token'
+
+      aggregate_failures do
+        expect(invalid_model.new).not_to have_secure_token
+        expect { expect(invalid_model.new).to have_secure_token }.
+          to fail_with_message(expected_message)
+      end
+    end
+
+    it 'does not match when missing a token column' do
+      create_table(:users)
+      invalid_model = define_model_class(:User) { has_secure_token }
+
+      expected_message =
+        'Expected User to have :token as a secure token but the following ' \
+        'errors were found: missing expected class and instance methods, ' \
+        'missing correct column token:string, missing unique index for ' \
+        'users.token'
+
+      aggregate_failures do
+        expect(invalid_model.new).not_to have_secure_token
+        expect { expect(invalid_model.new).to have_secure_token }.
+          to fail_with_message(expected_message)
+      end
+    end
+
+    it 'does not match when when lacking has_secure_token' do
+      create_table(:users) do |t|
+        t.string :token
+        t.index :token
+      end
+
+      invalid_model = define_model_class(:User)
+
+      expected_message =
+        'Expected User to have :token as a secure token but the following ' \
+        'errors were found: missing expected class and instance methods, ' \
+        'missing unique index for users.token'
+
+      aggregate_failures do
+        expect(invalid_model.new).not_to have_secure_token
+        expect { expect(invalid_model.new).to have_secure_token }.
+          to fail_with_message(expected_message)
+      end
+    end
+
+    it 'does not match when missing an index for a custom attribute' do
+      create_table(:users) do |t|
+        t.string :auth_token
+      end
+
+      invalid_model = define_model_class(:User) do
+        has_secure_token(:auth_token)
+      end
+
+      expected_message =
+        'Expected User to have :auth_token as a secure token but the ' \
+        'following errors were found: missing unique index for ' \
+        'users.auth_token'
+
+      aggregate_failures do
+        expect(invalid_model.new).not_to have_secure_token(:auth_token)
+        expect { expect(invalid_model.new).to have_secure_token(:auth_token) }.
+          to fail_with_message(expected_message)
+      end
+    end
+
+    it 'does not match when missing a column for a custom attribute' do
+      create_table(:users)
+      invalid_model = define_model_class(:User) do
+        has_secure_token(:auth_token)
+      end
+
+      expected_message =
+        'Expected User to have :auth_token as a secure token but the ' \
+        'following errors were found: missing expected class and instance '  \
+        'methods, missing correct column auth_token:string, missing unique ' \
+        'index for users.auth_token'
+
+      aggregate_failures do
+        expect(invalid_model.new).not_to have_secure_token(:auth_token)
+        expect { expect(invalid_model.new).to have_secure_token(:auth_token) }.
+          to fail_with_message(expected_message)
+      end
+    end
+
+    it 'does not match when when lacking has_secure_token for the attribute' do
+      create_table(:users) do |t|
+        t.string :auth_token
+        t.index :auth_token, unique: true
+      end
+
+      invalid_model = define_model_class(:User)
+      expected_message =
+        'Expected User to have :auth_token as a secure token but the ' \
+        'following errors were found: missing expected class and instance ' \
+        'methods'
+
+      aggregate_failures do
+        expect(invalid_model.new).not_to have_secure_token(:auth_token)
+        expect { expect(invalid_model.new).to have_secure_token(:auth_token) }.
+          to fail_with_message(expected_message)
+      end
+    end
+
+    it 'fails with the appropriate message when negated' do
+      create_table(:users) do |t|
+        t.string :token
+        t.index :token, unique: true
+      end
+
+      valid_model = define_model_class(:User) { has_secure_token }
+
+      expect { expect(valid_model.new).not_to have_secure_token }.
+        to fail_with_message('Did not expect User to have secure token :token')
+    end
+  end
+end

data/spec/unit/shoulda/matchers/active_record/validate_uniqueness_of_matcher_spec.rb

@@ -82,8 +82,9 @@ describe Shoulda::Matchers::ActiveRecord::ValidateUniquenessOfMatcher, type: :mo
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :scope1, :scope2, and :other.
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :scope1, :scope2, and :other, but this could not be
+proved.
   Expected the validation to be scoped to :scope1, :scope2, and :other,
   but it was scoped to :scope1 and :scope2 instead.
         MESSAGE
@@ -108,8 +109,8 @@ within the scope of :scope1, :scope2, and :other.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :scope1.
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :scope1, but this could not be proved.
   Expected the validation to be scoped to :scope1, but it was scoped to
   :scope1 and :scope2 instead.
         MESSAGE
@@ -131,8 +132,8 @@ within the scope of :scope1.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :scope.
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :scope, but this could not be proved.
   Expected the validation to be scoped to :scope, but it was scoped to
   :other instead.
         MESSAGE
@@ -152,7 +153,8 @@ within the scope of :scope.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique.
+Expected Example to validate that :attr is case-sensitively unique, but
+this could not be proved.
   Expected the validation not to be scoped to anything, but it was
   scoped to :scope instead.
         MESSAGE
@@ -171,7 +173,8 @@ Example did not properly validate that :attr is case-sensitively unique.
           end
 
           message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique.
+Expected Example to validate that :attr is case-sensitively unique, but
+this could not be proved.
   Expected the validation not to be scoped to anything, but it was
   scoped to :scope instead.
           MESSAGE
@@ -193,8 +196,8 @@ Example did not properly validate that :attr is case-sensitively unique.
           end
 
           message = <<-MESSAGE.strip
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :non_existent.
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :non_existent, but this could not be proved.
   :non_existent does not seem to be an attribute on Example.
           MESSAGE
 
@@ -216,8 +219,9 @@ within the scope of :non_existent.
           end
 
           message = <<-MESSAGE.strip
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :non_existent1 and :non_existent2.
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :non_existent1 and :non_existent2, but this could
+not be proved.
   :non_existent1 and :non_existent2 do not seem to be attributes on
   Example.
           MESSAGE
@@ -334,7 +338,8 @@ within the scope of :non_existent1 and :non_existent2.
       end
 
       message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique.
+Expected Example to validate that :attr is case-sensitively unique, but
+this could not be proved.
   Given an existing Example whose :attr is ‹"value"›, after making a new
   Example and setting its :attr to ‹"value"› as well, the matcher
   expected the new Example to be invalid, but it was valid instead.
@@ -356,6 +361,17 @@ Example did not properly validate that :attr is case-sensitively unique.
       end
     end
 
+    context 'when the attribute is of integer type' do
+      it 'accepts' do
+        record = build_record_validating_uniqueness(
+          attribute_type: :integer,
+          attribute_options: { limit: 4 },
+        )
+
+        expect(record).to validate_uniqueness
+      end
+    end
+
     context 'when the existing record was created beforehand' do
       context 'when the subject is a new record' do
         it 'accepts' do
@@ -518,8 +534,8 @@ Example did not properly validate that :attr is case-sensitively unique.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :other.
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :other, but this could not be proved.
   Expected the validation to be scoped to :other, but it was not scoped
   to anything.
         MESSAGE
@@ -541,7 +557,8 @@ within the scope of :other.
           end
 
           message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique.
+Expected Example to validate that :attr is case-sensitively unique, but
+this could not be proved.
   After taking the given Example, whose :attr is ‹"some value"›, and
   saving it as the existing record, then making a new Example and
   setting its :attr to ‹"some value"› as well, the matcher expected the
@@ -571,8 +588,9 @@ Example did not properly validate that :attr is case-sensitively unique.
             end
 
             message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-producing a custom validation error on failure.
+Expected Example to validate that :attr is case-sensitively unique,
+producing a custom validation error on failure, but this could not be
+proved.
   After taking the given Example, whose :attr is ‹"some value"›, and
   saving it as the existing record, then making a new Example and
   setting its :attr to ‹"some value"› as well, the matcher expected the
@@ -614,8 +632,9 @@ producing a custom validation error on failure.
             end
 
             message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-producing a custom validation error on failure.
+Expected Example to validate that :attr is case-sensitively unique,
+producing a custom validation error on failure, but this could not be
+proved.
   After taking the given Example, whose :attr is ‹"some value"›, and
   saving it as the existing record, then making a new Example and
   setting its :attr to ‹"some value"› as well, the matcher expected the
@@ -652,7 +671,8 @@ producing a custom validation error on failure.
           default_value: 'some value',
           changing_values_with: :next_value,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that :attr is case-sensitively unique.
+Expected Example to validate that :attr is case-sensitively unique, but
+this could not be proved.
   After taking the given Example, whose :attr is ‹"some valuf"›, and
   saving it as the existing record, then making a new Example and
   setting its :attr to ‹"some valuf"› (read back as ‹"some valug"›) as
@@ -672,6 +692,28 @@ Example did not properly validate that :attr is case-sensitively unique.
         }
       }
     )
+
+    it 'fails when used in the negative' do
+      assertion = lambda do
+        record = build_record_validating_uniqueness(
+          attribute_type: :string,
+          attribute_options: { limit: 1 }
+        )
+
+        expect(record).not_to validate_uniqueness
+      end
+
+      message = <<-MESSAGE
+Expected Example not to validate that :attr is case-sensitively unique,
+but this could not be proved.
+  After taking the given Example, setting its :attr to ‹"x"›, and saving
+  it as the existing record, then making a new Example and setting its
+  :attr to a different value, ‹"X"›, the matcher expected the new
+  Example to be invalid, but it was valid instead.
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
+    end
   end
 
   context 'when the model has a scoped uniqueness validation' do
@@ -721,60 +763,59 @@ Example did not properly validate that :attr is case-sensitively unique.
       include_context 'it supports scoped attributes of a certain type',
         column_type: :integer
 
-      if active_record_supports_enum?
-        context 'when one of the scoped attributes is an enum' do
-          it 'accepts' do
+      context 'when one of the scoped attributes is an enum' do
+        it 'accepts' do
+          record = build_record_validating_scoped_uniqueness_with_enum(
+            enum_scope: :scope
+          )
+          expect(record).to validate_uniqueness.scoped_to(:scope)
+        end
+
+        context 'when too narrow of a scope is specified' do
+          it 'rejects with an appropriate failure message' do
             record = build_record_validating_scoped_uniqueness_with_enum(
-              enum_scope: :scope
+              enum_scope: :scope1,
+              additional_scopes: [:scope2],
+              additional_attributes: [:other]
             )
-            expect(record).to validate_uniqueness.scoped_to(:scope)
-          end
 
-          context 'when too narrow of a scope is specified' do
-            it 'rejects with an appropriate failure message' do
-              record = build_record_validating_scoped_uniqueness_with_enum(
-                enum_scope: :scope1,
-                additional_scopes: [:scope2],
-                additional_attributes: [:other]
-              )
-
-              assertion = lambda do
-                expect(record).
-                  to validate_uniqueness.
-                  scoped_to(:scope1, :scope2, :other)
-              end
+            assertion = lambda do
+              expect(record).
+                to validate_uniqueness.
+                scoped_to(:scope1, :scope2, :other)
+            end
 
-              message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :scope1, :scope2, and :other.
+            message = <<-MESSAGE
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :scope1, :scope2, and :other, but this could not be
+proved.
   Expected the validation to be scoped to :scope1, :scope2, and :other,
   but it was scoped to :scope1 and :scope2 instead.
-              MESSAGE
+            MESSAGE
 
-              expect(&assertion).to fail_with_message(message)
-            end
+            expect(&assertion).to fail_with_message(message)
           end
+        end
 
-          context 'when too broad of a scope is specified' do
-            it 'rejects with an appropriate failure message' do
-              record = build_record_validating_scoped_uniqueness_with_enum(
-                enum_scope: :scope1,
-                additional_scopes: [:scope2]
-              )
+        context 'when too broad of a scope is specified' do
+          it 'rejects with an appropriate failure message' do
+            record = build_record_validating_scoped_uniqueness_with_enum(
+              enum_scope: :scope1,
+              additional_scopes: [:scope2]
+            )
 
-              assertion = lambda do
-                expect(record).to validate_uniqueness.scoped_to(:scope1)
-              end
+            assertion = lambda do
+              expect(record).to validate_uniqueness.scoped_to(:scope1)
+            end
 
-              message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique
-within the scope of :scope1.
+            message = <<-MESSAGE
+Expected Example to validate that :attr is case-sensitively unique
+within the scope of :scope1, but this could not be proved.
   Expected the validation to be scoped to :scope1, but it was scoped to
   :scope1 and :scope2 instead.
-              MESSAGE
+            MESSAGE
 
-              expect(&assertion).to fail_with_message(message)
-            end
+            expect(&assertion).to fail_with_message(message)
           end
         end
       end
@@ -808,7 +849,11 @@ within the scope of :scope1.
       end
     end
 
-    if database_supports_array_columns? && active_record_supports_array_columns?
+    if (
+      database_supports_array_columns? &&
+      active_record_supports_array_columns? &&
+      active_record_uniqueness_supports_array_columns?
+    )
       context 'when one of the scoped attributes is a array-of-string column' do
         include_examples 'it supports scoped attributes of a certain type',
           column_type: :string,
@@ -898,8 +943,8 @@ within the scope of :scope1.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-insensitively
-unique.
+Expected Example to validate that :attr is case-insensitively unique,
+but this could not be proved.
   After taking the given Example, whose :attr is ‹"some value"›, and
   saving it as the existing record, then making a new Example and
   setting its :attr to a different value, ‹"SOME VALUE"›, the matcher
@@ -924,12 +969,13 @@ unique.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique.
-  After taking the given Example, setting its :attr to ‹"an arbitrary
-  value"›, and saving it as the existing record, then making a new
-  Example and setting its :attr to a different value, ‹"AN ARBITRARY
-  VALUE"›, the matcher expected the new Example to be valid, but it was
-  invalid instead, producing these validation errors:
+Expected Example to validate that :attr is case-sensitively unique, but
+this could not be proved.
+  After taking the given Example, setting its :attr to ‹"dummy value"›,
+  and saving it as the existing record, then making a new Example and
+  setting its :attr to a different value, ‹"DUMMY VALUE"›, the matcher
+  expected the new Example to be valid, but it was invalid instead,
+  producing these validation errors:
 
   * attr: ["has already been taken"]
         MESSAGE
@@ -957,8 +1003,8 @@ Example did not properly validate that :attr is case-sensitively unique.
             default_value: 'some value',
             changing_values_with: :next_value,
             expected_message: <<-MESSAGE.strip
-Example did not properly validate that :attr is case-insensitively
-unique.
+Expected Example to validate that :attr is case-insensitively unique,
+but this could not be proved.
   After taking the given Example, whose :attr is ‹"some valuf"›, and
   saving it as the existing record, then making a new Example and
   setting its :attr to ‹"some valuf"› (read back as ‹"some valug"›) as
@@ -1038,8 +1084,8 @@ unique.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-but only if it is not nil.
+Expected Example to validate that :attr is case-sensitively unique as
+long as it is not nil, but this could not be proved.
   After taking the given Example, setting its :attr to ‹nil›, and saving
   it as the existing record, then making a new Example and setting its
   :attr to ‹nil› as well, the matcher expected the new Example to be
@@ -1062,8 +1108,8 @@ but only if it is not nil.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-but only if it is not nil.
+Expected Example to validate that :attr is case-sensitively unique as
+long as it is not nil, but this could not be proved.
   Given an existing Example, after setting its :attr to ‹nil›, then
   making a new Example and setting its :attr to ‹nil› as well, the
   matcher expected the new Example to be valid, but it was invalid
@@ -1167,8 +1213,8 @@ but only if it is not nil.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-but only if it is not blank.
+Expected Example to validate that :attr is case-sensitively unique as
+long as it is not blank, but this could not be proved.
   After taking the given Example, setting its :attr to ‹""›, and saving
   it as the existing record, then making a new Example and setting its
   :attr to ‹""› as well, the matcher expected the new Example to be
@@ -1191,8 +1237,8 @@ but only if it is not blank.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-but only if it is not blank.
+Expected Example to validate that :attr is case-sensitively unique as
+long as it is not blank, but this could not be proved.
   Given an existing Example, after setting its :attr to ‹""›, then
   making a new Example and setting its :attr to ‹""› as well, the
   matcher expected the new Example to be valid, but it was invalid
@@ -1217,8 +1263,8 @@ but only if it is not blank.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-but only if it is not blank.
+Expected Example to validate that :attr is case-sensitively unique as
+long as it is not blank, but this could not be proved.
   After taking the given Example, setting its :attr to ‹""›, and saving
   it as the existing record, then making a new Example and setting its
   :attr to ‹""› as well, the matcher expected the new Example to be
@@ -1243,8 +1289,8 @@ but only if it is not blank.
         end
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is case-sensitively unique,
-but only if it is not blank.
+Expected Example to validate that :attr is case-sensitively unique as
+long as it is not blank, but this could not be proved.
   Given an existing Example, after setting its :attr to ‹""›, then
   making a new Example and setting its :attr to ‹""› as well, the
   matcher expected the new Example to be valid, but it was invalid
@@ -1266,7 +1312,10 @@ but only if it is not blank.
         favoriteable_type: { type: :string, options: { null: false } }
       }
       favorite_model = define_model 'Favorite', favorite_columns do
-        attr_accessible :favoriteable
+        if respond_to?(:attr_accessible)
+          attr_accessible :favoriteable
+        end
+
         belongs_to :favoriteable, polymorphic: true
         validates :favoriteable, presence: true
         validates :favoriteable_id, uniqueness: { scope: :favoriteable_type }
@@ -1291,7 +1340,10 @@ but only if it is not blank.
           favoriteable_type: { type: :string, options: { null: false } }
         }
         favorite_model = define_model 'Models::Favorite', favorite_columns do
-          attr_accessible :favoriteable
+          if respond_to?(:attr_accessible)
+            attr_accessible :favoriteable
+          end
+
           belongs_to :favoriteable, polymorphic: true
           validates :favoriteable, presence: true
           validates :favoriteable_id, uniqueness: { scope: :favoriteable_type }
@@ -1317,7 +1369,8 @@ but only if it is not blank.
       end
 
       message = <<-MESSAGE.strip
-Example did not properly validate that :attr is case-sensitively unique.
+Expected Example to validate that :attr is case-sensitively unique, but
+this could not be proved.
   :attr does not seem to be an attribute on Example.
       MESSAGE
 
@@ -1344,13 +1397,14 @@ Example did not properly validate that :attr is case-sensitively unique.
           end
 
           message = <<-MESSAGE.strip
-Example did not properly validate that :name is case-sensitively unique.
-  After taking the given Example, setting its :name to ‹"an arbitrary
-  value"› (read back as ‹"AN ARBITRARY VALUE"›), and saving it as the
-  existing record, then making a new Example and setting its :name to
-  ‹"an arbitrary value"› (read back as ‹"AN ARBITRARY VALUE"›) as well,
-  the matcher expected the new Example to be valid, but it was invalid
-  instead, producing these validation errors:
+Expected Example to validate that :name is case-sensitively unique, but
+this could not be proved.
+  After taking the given Example, setting its :name to ‹"dummy value"›
+  (read back as ‹"DUMMY VALUE"›), and saving it as the existing record,
+  then making a new Example and setting its :name to ‹"dummy value"›
+  (read back as ‹"DUMMY VALUE"›) as well, the matcher expected the new
+  Example to be valid, but it was invalid instead, producing these
+  validation errors:
 
   * name: ["has already been taken"]
 
@@ -1409,6 +1463,18 @@ Example did not properly validate that :name is case-sensitively unique.
     end
   end
 
+  context 'when the column is a boolean column' do
+    it 'accepts (and does not print a warning)' do
+      record = build_record_validating_uniqueness(attribute_type: :boolean)
+      running_validation = -> { expect(record).to validate_uniqueness }
+      message =
+        'You attempted to assign a value which is not explicitly `true` or ' +
+        '`false`'
+
+      expect(&running_validation).not_to print_warning_including(message)
+    end
+  end
+
   let(:model_attributes) { {} }
 
   def default_attribute
@@ -1547,8 +1613,10 @@ Example did not properly validate that :name is case-sensitively unique.
       m.validates_uniqueness_of attribute_name,
         validation_options.merge(scope: scope_attribute_names)
 
-      attributes.each do |attr|
-        m.attr_accessible(attr[:name])
+      if m.respond_to?(:attr_accessible)
+        attributes.each do |attr|
+          m.attr_accessible(attr[:name])
+        end
       end
 
       block.call(m) if block
@@ -1591,7 +1659,9 @@ Example did not properly validate that :name is case-sensitively unique.
 
   def define_model_without_validation
     define_model(:example, attribute_name => :string) do |model|
-      model.attr_accessible(attribute_name)
+      if model.respond_to?(:attr_accessible)
+        model.attr_accessible(attribute_name)
+      end
     end
   end