active_attr 0.7.0 → 0.8.0

data/spec/functional/active_attr/chainable_initialization_spec.rb

@@ -4,12 +4,12 @@ require "active_support/concern"
 
 module ActiveAttr
   describe ChainableInitialization do
-    subject { model_class.new("arg") }
+    subject(:model) { model_class.new("arg") }
 
     shared_examples "chained initialization" do
       describe "#initialize" do
-        it { expect { subject }.not_to raise_error }
-        it { subject.initialized?.should be_true }
+        it { expect { model }.not_to raise_error }
+        it { model.initialized?.should be_true }
       end
     end
 

data/spec/functional/active_attr/mass_assignment_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+require "active_attr/mass_assignment"
+require "active_model"
+require "active_model/mass_assignment_security"
+
+module ActiveAttr
+  describe MassAssignment, :mass_assignment do
+    context "integrating with protected_attributes" do
+      before do
+        model_class.class_eval do
+          include MassAssignment
+          include ActiveModel::MassAssignmentSecurity
+          attr_accessor :age
+        end
+      end
+
+      shared_examples "secure mass assignment method", :secure_mass_assignment_method => true do
+        include_examples "mass assignment method"
+
+        it "ignores assigning an attribute protected by role-based security", :active_model_version => ">= 3.1.0" do
+          person = mass_assign_attributes(:age => 21)
+          person.age.should be_nil
+        end
+
+        it "ignores assigning a protected attribute" do
+          person = mass_assign_attributes(:first_name => "Chris")
+          person.age.should be_nil
+        end
+      end
+
+      shared_examples "secure mass assignment method with options", :secure_mass_assignment_method_with_options => true do
+        it "supports role-based mass assignment security", :active_model_version => ">= 3.1.0" do
+          person = mass_assign_attributes_with_options({ :age => 21 }, :as => :admin)
+          person.age.should == 21
+        end
+
+        it "skips security if passed the :without_protection option" do
+          person = mass_assign_attributes_with_options({ :age => 21 }, :without_protection => true)
+          person.age.should == 21
+        end
+      end
+
+      context "white listing attributes" do
+        before do
+          model_class.class_eval do
+            attr_accessible :first_name, :last_name, :name
+            attr_accessible :age, :as => :admin
+          end
+        end
+
+        describe "#assign_attributes", :assign_attributes, :secure_mass_assignment_method, :secure_mass_assignment_method_with_options
+        describe "#attributes=", :attributes=, :secure_mass_assignment_method
+        describe "#initialize", :initialize, :secure_mass_assignment_method, :secure_mass_assignment_method_with_options
+      end
+
+      context "black listing attributes" do
+        before do
+          model_class.class_eval do
+            attr_protected :age
+            attr_protected :as => :admin
+          end
+        end
+
+        describe "#assign_attributes", :assign_attributes, :secure_mass_assignment_method, :secure_mass_assignment_method_with_options
+        describe "#attributes=", :attributes=, :secure_mass_assignment_method
+        describe "#initialize", :initialize, :secure_mass_assignment_method, :secure_mass_assignment_method_with_options
+      end
+    end
+
+    context "integrating with strong_parameters", :active_model_version => ">= 3.2.0" do
+      let(:rails3) { Gem::Requirement.create("~> 3.2.0").satisfied_by?(Gem::Version.new(ActiveModel::VERSION::STRING)) }
+
+      before do
+        if rails3
+          require "strong_parameters"
+
+          model_class.class_eval do
+            include ActiveAttr::MassAssignment
+            include ActiveModel::MassAssignmentSecurity
+            include ActiveModel::ForbiddenAttributesProtection
+            attr_accessor :age
+          end
+        else
+          require "action_controller"
+
+          model_class.class_eval do
+            include ActiveAttr::MassAssignment
+            include ActiveModel::MassAssignmentSecurity
+            include ActiveModel::ForbiddenAttributesProtection
+            attr_accessor :age
+          end
+        end
+      end
+
+      let :forbidden_attributes_error_class do
+        rails3 ? ActiveModel::ForbiddenAttributes : ActiveModel::ForbiddenAttributesError
+      end
+
+      shared_examples "strong mass assignment method", :strong_mass_assignment_method => true do
+        it "raises if provided parameters when none are permitted" do
+          expect { mass_assign_attributes(ActionController::Parameters.new(:age => 21)) }.to raise_error forbidden_attributes_error_class
+        end
+
+        it "sets a permitted parameter" do
+          person = mass_assign_attributes(ActionController::Parameters.new(:age => 21).permit(:age))
+          person.age.should == 21
+        end
+
+        it "does not set forbidden parameters" do
+          person = mass_assign_attributes(ActionController::Parameters.new(:age => 21).permit(:first_name))
+          person.age.should be_nil
+        end
+
+        it "continues to set normal attributes" do
+          person = mass_assign_attributes(:age => 21)
+          person.age.should == 21
+        end
+      end
+
+      describe "#assign_attributes", :assign_attributes, :strong_mass_assignment_method
+      describe "#attributes=", :attributes=, :strong_mass_assignment_method
+      describe "#initialize", :initialize, :strong_mass_assignment_method
+    end
+  end
+end

data/spec/functional/active_attr/matchers/have_attribute_matcher_spec.rb

@@ -3,6 +3,7 @@ require "active_attr/attributes"
 require "active_attr/attribute_defaults"
 require "active_attr/matchers/have_attribute_matcher"
 require "active_attr/typecasted_attributes"
+require "active_support/core_ext/string/strip"
 
 module ActiveAttr
   module Matchers
@@ -29,13 +30,13 @@ module ActiveAttr
         end
 
         describe "#matches?" do
-          it { subject.matches?(model_class).should be_false }
+          it { matcher.matches?(model_class).should be_false }
         end
 
         describe "#failure_message" do
-          before { subject.matches?(model_class) }
+          before { matcher.matches?(model_class) }
 
-          it { subject.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::Attributes} }
+          it { matcher.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::Attributes} }
         end
       end
 
@@ -51,13 +52,13 @@ module ActiveAttr
         end
 
         describe "#matches?" do
-          it { subject.matches?(model_class).should be_false }
+          it { matcher.matches?(model_class).should be_false }
         end
 
         describe "#failure_message" do
-          before { subject.matches?(model_class) }
+          before { matcher.matches?(model_class) }
 
-          it { subject.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::AttributeDefaults} }
+          it { matcher.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::AttributeDefaults} }
         end
       end
 
@@ -73,18 +74,18 @@ module ActiveAttr
         end
 
         describe "#matches?" do
-          it { subject.matches?(model_class).should be_false }
+          it { matcher.matches?(model_class).should be_false }
         end
 
         describe "#failure_message" do
-          before { subject.matches?(model_class) }
+          before { matcher.matches?(model_class) }
 
-          it { subject.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::TypecastedAttributes} }
+          it { matcher.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::TypecastedAttributes} }
         end
       end
 
       context "a matcher with just an attribute name" do
-        subject { described_class.new(:first_name) }
+        subject(:matcher) { described_class.new(:first_name) }
 
         it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
 
@@ -92,31 +93,36 @@ module ActiveAttr
           before { model_class.attribute :first_name }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :first_name
+                         got: attribute :first_name
+              MESSAGE
+            end
           end
         end
 
         context "a class without the attribute" do
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named first_name} }
+            it { matcher.failure_message.should == %{expected Person to have attribute named first_name} }
           end
         end
       end
 
       context "a matcher with a default value" do
-        subject { described_class.new(:first_name).with_default_value_of("John") }
+        subject(:matcher) { described_class.new(:first_name).with_default_value_of("John") }
 
         it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
         it_should_behave_like "a matcher matching a class without ActiveAttr::AttributeDefaults"
@@ -125,13 +131,18 @@ module ActiveAttr
           before { model_class.attribute :first_name }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named first_name with a default value of "John"} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :first_name, :default => "John"
+                     got: attribute :first_name
+              MESSAGE
+            end
           end
         end
 
@@ -139,13 +150,18 @@ module ActiveAttr
           before { model_class.attribute :first_name, :default => "Doe" }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named first_name with a default value of "John"} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :first_name, :default => "John"
+                     got: attribute :first_name, :default => "Doe"
+              MESSAGE
+            end
           end
         end
 
@@ -153,19 +169,24 @@ module ActiveAttr
           before { model_class.attribute :first_name, :default => "John" }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name with a default value of "John"} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :first_name, :default => "John"
+                         got: attribute :first_name, :default => "John"
+              MESSAGE
+            end
           end
         end
       end
 
       context "a matcher with a default value of false" do
-        subject { described_class.new(:admin).with_default_value_of(false) }
+        subject(:matcher) { described_class.new(:admin).with_default_value_of(false) }
 
         it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
         it_should_behave_like "a matcher matching a class without ActiveAttr::AttributeDefaults"
@@ -174,13 +195,18 @@ module ActiveAttr
           before { model_class.attribute :admin }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named admin with a default value of false} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :admin, :default => false
+                     got: attribute :admin
+              MESSAGE
+            end
           end
         end
 
@@ -188,13 +214,18 @@ module ActiveAttr
           before { model_class.attribute :admin, :default => nil }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named admin with a default value of false} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :admin, :default => false
+                     got: attribute :admin, :default => nil
+              MESSAGE
+            end
           end
         end
 
@@ -202,19 +233,24 @@ module ActiveAttr
           before { model_class.attribute :admin, :default => false }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named admin with a default value of false} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :admin, :default => false
+                         got: attribute :admin, :default => false
+              MESSAGE
+            end
           end
         end
       end
 
       context "a matcher with a default value of nil" do
-        subject { described_class.new(:first_name).with_default_value_of(nil) }
+        subject(:matcher) { described_class.new(:first_name).with_default_value_of(nil) }
 
         it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
         it_should_behave_like "a matcher matching a class without ActiveAttr::AttributeDefaults"
@@ -223,13 +259,18 @@ module ActiveAttr
           before { model_class.attribute :first_name }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name with a default value of nil} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :first_name, :default => nil
+                         got: attribute :first_name
+              MESSAGE
+            end
           end
         end
 
@@ -237,13 +278,18 @@ module ActiveAttr
           before { model_class.attribute :first_name, :default => false }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named first_name with a default value of nil} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :first_name, :default => nil
+                     got: attribute :first_name, :default => false
+              MESSAGE
+            end
           end
         end
 
@@ -251,19 +297,24 @@ module ActiveAttr
           before { model_class.attribute :first_name, :default => nil }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name with a default value of nil} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :first_name, :default => nil
+                         got: attribute :first_name, :default => nil
+              MESSAGE
+            end
           end
         end
       end
 
       context "a matcher with a type" do
-        subject { described_class.new(:first_name).of_type(String) }
+        subject(:matcher) { described_class.new(:first_name).of_type(String) }
 
         it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
         it_should_behave_like "a matcher matching a class without ActiveAttr::TypecastedAttributes"
@@ -272,13 +323,18 @@ module ActiveAttr
           before { model_class.attribute :first_name }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named first_name of type String} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :first_name, :type => String
+                     got: attribute :first_name
+              MESSAGE
+            end
           end
         end
 
@@ -286,13 +342,18 @@ module ActiveAttr
           before { model_class.attribute :first_name, :type => Symbol }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named first_name of type String} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :first_name, :type => String
+                     got: attribute :first_name, :type => Symbol
+              MESSAGE
+            end
           end
         end
 
@@ -300,19 +361,24 @@ module ActiveAttr
           before { model_class.attribute :first_name, :type => String }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name of type String} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :first_name, :type => String
+                         got: attribute :first_name, :type => String
+              MESSAGE
+            end
           end
         end
       end
 
       context "a matcher with a type of Object" do
-        subject { described_class.new(:first_name).of_type(Object) }
+        subject(:matcher) { described_class.new(:first_name).of_type(Object) }
 
         it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
         it_should_behave_like "a matcher matching a class without ActiveAttr::TypecastedAttributes"
@@ -321,13 +387,18 @@ module ActiveAttr
           before { model_class.attribute :first_name }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name of type Object} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :first_name, :type => Object
+                         got: attribute :first_name
+              MESSAGE
+            end
           end
         end
 
@@ -335,13 +406,18 @@ module ActiveAttr
           before { model_class.attribute :first_name, :type => String }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_false }
+            it { matcher.matches?(model_class).should be_false }
           end
 
           describe "#failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.failure_message.should == %{expected Person to have attribute named first_name of type Object} }
+            it do
+              matcher.failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected: attribute :first_name, :type => Object
+                     got: attribute :first_name, :type => String
+              MESSAGE
+            end
           end
         end
 
@@ -349,13 +425,18 @@ module ActiveAttr
           before { model_class.attribute :first_name, :type => Object }
 
           describe "#matches?" do
-            it { subject.matches?(model_class).should be_true }
+            it { matcher.matches?(model_class).should be_true }
           end
 
           describe "#negative_failure_message" do
-            before { subject.matches?(model_class) }
+            before { matcher.matches?(model_class) }
 
-            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name of type Object} }
+            it do
+              matcher.negative_failure_message.should == <<-MESSAGE.strip_heredoc.chomp
+                expected not: attribute :first_name, :type => Object
+                         got: attribute :first_name, :type => Object
+              MESSAGE
+            end
           end
         end
       end