Keep the :fallback null object out of relation serialization

serializable_hash serializes included associations through
serialize_relations, which read the association with a bare send(name)
outside the without_autobuild block that already wraps field
serialization. With a :fallback that returned the null object, and
serializable_hash(include: ...) then called serializable_hash on it,
raising NoMethodError.

When the association has a :fallback, read the value through
without_autobuild so a nil association is omitted from the output.
Autobuilding associations are left untouched.

Author: cperezabo

lib/mongoid/serializable.rb

@@ -127,10 +127,18 @@ def serialize_relations(attributes = {}, options = {})
       inclusions = options[:include]
       relation_names(inclusions).each do |name|
         association = relations[name.to_s]
-        if association && relation = send(association.name)
-          attributes[association.name.to_s] =
-            relation.serializable_hash(relation_options(inclusions, options, name))
-        end
+        next unless association
+
+        relation =
+          if association.fallback?
+            without_autobuild { send(association.name) }
+          else
+            send(association.name)
+          end
+        next unless relation
+
+        attributes[association.name.to_s] =
+          relation.serializable_hash(relation_options(inclusions, options, name))
       end
     end
 

spec/mongoid/association/fallback_spec.rb

@@ -352,6 +352,32 @@ class Symphony
     end
   end
 
+  context 'when serialized with an included association' do
+    before(:all) do
+      class Composer
+        include Mongoid::Document
+      end
+
+      class Symphony
+        include Mongoid::Document
+
+        belongs_to :composer, fallback: -> { Anonymous.new }
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Symphony)
+      Object.send(:remove_const, :Composer)
+    end
+
+    it 'omits the fallback when the real association is nil' do
+      symphony = Symphony.new
+
+      expect { symphony.serializable_hash(include: :composer) }.not_to raise_error
+      expect(symphony.serializable_hash(include: :composer)).not_to have_key('composer')
+    end
+  end
+
   context 'validation of the :fallback option' do
     it 'rejects a declaration that combines :fallback with :autobuild' do
       expect do