fix: avoid creating invalid objects when foreign key is null in serializer (#740)

Author: matthv

app/serializers/forest_liana/serializer_factory.rb

@@ -146,7 +146,10 @@ def has_one_relationships
                 @options[:fields][relation_class_name]&.size == 1 &&
                 @options[:fields][relation_class_name]&.include?(relation.klass.primary_key.to_sym)
 
-                attr_data[:attr_or_block] = proc {  relation.klass.new(relation.klass.primary_key => object.send(relation.foreign_key.to_sym)) }
+                attr_data[:attr_or_block] = proc {
+                  foreign_key_value = object.send(relation.foreign_key.to_sym)
+                  foreign_key_value.nil? ? nil : relation.klass.new(relation.klass.primary_key => foreign_key_value)
+                }
               end
             end
 

spec/dummy/app/models/tree.rb

@@ -1,7 +1,7 @@
 class Tree < ActiveRecord::Base
   belongs_to :owner, class_name: 'User', inverse_of: :trees_owned
   belongs_to :cutter, class_name: 'User', inverse_of: :trees_cut
-  belongs_to :island
+  belongs_to :island, optional: true
   belongs_to :eponymous_island,
     ->(record) { where(name: record.name) },
     class_name: 'Island',

spec/services/forest_liana/serializer_factory_spec.rb

@@ -0,0 +1,53 @@
+module ForestLiana
+  describe SerializerFactory do
+    describe '#serializer_for has_one_relationships patch' do
+      let(:user) { User.create!(name: 'PatchTest') }
+      let(:island) { Island.create!(name: 'TestIsland') }
+      let(:tree) { Tree.create!(name: 'TestTree', island: island, owner: user) }
+
+      it 'simulates has_one relation with only primary key' do
+        factory = described_class.new
+        serializer_class = factory.serializer_for(Tree)
+
+        serializer_class.send(:has_one, :island) { }
+
+        instance = serializer_class.new(tree, fields: {
+          'Island' => [:id],
+          'Tree' => [:island]
+        })
+
+        relationships = instance.send(:has_one_relationships)
+        expect(relationships).to have_key(:island)
+        relation_data = relationships[:island]
+        expect(relation_data[:attr_or_block]).to be_a(Proc)
+        model = relation_data[:attr_or_block].call
+
+        expect(model).to be_a(Island)
+        expect(model.id).to eq(island.id)
+      end
+
+      it 'returns nil if foreign key is nil' do
+        tree_without_island = Tree.create!(name: 'NoIslandTree', island_id: nil, owner: user)
+
+        factory = described_class.new
+        serializer_class = factory.serializer_for(Tree)
+
+        serializer_class.send(:has_one, :island) { }
+
+        instance = serializer_class.new(tree_without_island, fields: {
+          'Island' => [:id],
+          'Tree' => [:island]
+        })
+
+        relationships = instance.send(:has_one_relationships)
+        expect(relationships).to have_key(:island)
+        relation_data = relationships[:island]
+        expect(relation_data[:attr_or_block]).to be_a(Proc)
+        model = relation_data[:attr_or_block].call
+
+        expect(model).to be_nil
+      end
+
+    end
+  end
+end