refactor: create sequel plugin for insert ignore

Author: bethesque

lib/pact_broker/db/insert_ignore.rb

@@ -3,14 +3,13 @@
 require 'pact_broker/repositories/helpers'
 require 'pact_broker/versions/latest_version'
 require 'pact_broker/domain/label'
-require 'pact_broker/db/insert_ignore'
 
 module PactBroker
   module Domain
     class Pacticipant < Sequel::Model
 
       include Messages
-      include PactBroker::DB::InsertIgnore
+      plugin :insert_ignore, identifying_columns: [:name]
 
       plugin :timestamps, update_on_create: true
 

lib/pact_broker/domain/pacticipant.rb

@@ -59,7 +59,7 @@ def create args
           repository_url: args[:repository_url],
           created_at: Sequel.datetime_class.now,
           updated_at: Sequel.datetime_class.now
-        ).save
+        ).insert_ignore
         PactBroker::Domain::Pacticipant.find(name: args[:name])
       end
 

lib/pact_broker/pacticipants/repository.rb

@@ -0,0 +1,44 @@
+# This plugin can be included into a Sequel model to allow the original record
+# to be loaded into the model if a duplicate is inserted.
+# This is to handle race conditions when two requests come in in parallel to create
+# the same resource.
+
+# Rather than re-writing the whole save method and all the hooks and validation logic in it,
+# it naughtily overrides the private _insert_dataset.
+
+# MySQL does not return the id of the original row when a duplicate is inserted,
+# so we have to manually find the original record an load it into the model.
+
+module Sequel
+  module Plugins
+    module InsertIgnore
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          @insert_ignore_identifying_columns = opts.fetch(:identifying_columns)
+        end
+      end
+
+      module ClassMethods
+        attr_reader :insert_ignore_identifying_columns
+      end
+
+      module InstanceMethods
+        def insert_ignore(opts = {})
+          save(opts)
+        rescue Sequel::NoExistingObject
+          # MySQL. Ruining it for everyone.
+          query = self.class.insert_ignore_identifying_columns.each_with_object({}) do | column_name, q |
+            q[column_name] = values[column_name]
+          end
+          self.id = model.where(query).single_record.id
+          self.refresh
+        end
+
+        # Does the job for Sqlite and Postgres
+        def _insert_dataset
+          super.insert_ignore
+        end
+      end
+    end
+  end
+end

lib/sequel/plugins/insert_ignore.rb

@@ -0,0 +1,82 @@
+require 'sequel/plugins/insert_ignore'
+require 'sequel'
+
+module Sequel
+  module Plugins
+    module InsertIgnore
+      class PacticipantNoInsertIgnore < Sequel::Model(:pacticipants)
+        plugin :timestamps, update_on_create: true
+      end
+
+      class Pacticipant < Sequel::Model
+        plugin :insert_ignore, identifying_columns: [:name]
+        plugin :timestamps, update_on_create: true
+      end
+
+      class Version < Sequel::Model
+        plugin :insert_ignore, identifying_columns: [:pacticipant_id, :number]
+        plugin :timestamps, update_on_create: true
+      end
+
+      context "when a duplicate is inserted with no insert_ignore" do
+        before do
+          PacticipantNoInsertIgnore.new(name: "Foo").save
+        end
+
+        subject do
+          PacticipantNoInsertIgnore.new(name: "Foo").save
+        end
+
+        it "raises an error" do
+          expect { subject }.to raise_error Sequel::UniqueConstraintViolation
+        end
+      end
+
+      # This doesn't work on MSQL because the _insert_raw method
+      # does not return the row ID of the duplicated row when insert_ignore is used
+      # May have to go back to the old method of doing this
+      context "when a duplicate Pacticipant is inserted with insert_ignore" do
+        before do
+          Pacticipant.new(name: "Foo", repository_url: "http://foo").insert_ignore
+        end
+
+        subject do
+          Pacticipant.new(name: "Foo").insert_ignore
+        end
+
+        it "does not raise an error" do
+          expect { subject }.to_not raise_error
+        end
+
+        it "sets the values on the object" do
+          expect(subject.repository_url).to eq "http://foo"
+        end
+
+        it "does not insert another row" do
+          expect { subject }.to_not change { Pacticipant.count }
+        end
+      end
+
+      context "when a duplicate Version is inserted with insert_ignore" do
+        let!(:pacticipant) { Pacticipant.new(name: "Foo").save }
+        let!(:original_version) { Version.new(number: "1", pacticipant_id: pacticipant.id).insert_ignore }
+
+        subject do
+          Version.new(number: "1", pacticipant_id: pacticipant.id).insert_ignore
+        end
+
+        it "does not raise an error" do
+          expect { subject }.to_not raise_error
+        end
+
+        it "sets the values on the object" do
+          expect(subject.id).to eq original_version.id
+        end
+
+        it "does not insert another row" do
+          expect { subject }.to_not change { Version.count }
+        end
+      end
+    end
+  end
+end