Add .find_by! method

Behaves the same as `.find_by`, accepting one or more attributes to find
a matching record by. The key difference is the method raises a
`StaticAssociation::RecordNotFound` exception if no record is found.

Author: sidane

README.md

@@ -49,11 +49,13 @@ The `Day` class will gain `.all`, `.find`, `.find_by_id`, `.find_by` and
 - The `.all` method returns all the static records defined in the class.
 - The `.ids` method returns an array of all the ids of the static records.
 - The `.find` method accepts a single id and returns the matching record. If the
-  record does not exist, a `RecordNotFound` error is raised.
+  record does not exist, a `StaticAssociation::RecordNotFound` error is raised.
 - The `.find_by_id` method behaves similarly to the `.find` method, except it
   returns `nil` when a record does not exist.
 - `find_by` finds the first record matching the specified conditions. If no
   record is found, returns `nil`.
+- `find_by!` behaves like `find_by` but raises a
+  `StaticAssociation::RecordNotFound` error if no record is found.
 - The `.where` method accepts an array of ids and returns all records with
   matching ids.
 

lib/static_association.rb

@@ -62,6 +62,13 @@ def find_by(**args)
       all.find { |record| matches_attributes?(record: record, attributes: args) }
     end
 
+    def find_by!(**args)
+      find_by(**args) or raise RecordNotFound.new(
+        "Couldn't find #{name} with " +
+        args.map { |k, v| "#{k}=#{v}" }.join(", ")
+      )
+    end
+
     def record(settings, &block)
       settings.assert_valid_keys(:id)
       id = settings.fetch(:id)

spec/static_association_spec.rb

@@ -286,6 +286,105 @@ class AssociationClass
     end
   end
 
+  describe ".find_by!" do
+    context "when record exists with the specified attribute value" do
+      it "returns the record" do
+        record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+        _record2 = DummyClass.record(id: 2) do |r|
+          r.name = "bar"
+        end
+
+        found_record = DummyClass.find_by!(name: "foo")
+
+        expect(found_record).to eq(record1)
+      end
+    end
+
+    context "when no record exists that matches the specified attribute value" do
+      it "raises exception" do
+        DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+
+        expect {
+          DummyClass.find_by!(name: "bar")
+        }.to raise_error(
+          StaticAssociation::RecordNotFound,
+          "Couldn't find DummyClass with name=bar"
+        )
+      end
+    end
+
+    context "when multiple records match the specified attribute value" do
+      it "returns the first matching record" do
+        record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+        _record2 = DummyClass.record(id: 2) do |r|
+          r.name = "foo"
+        end
+
+        found_record = DummyClass.find_by!(name: "foo")
+
+        expect(found_record).to eq(record1)
+      end
+    end
+
+    context "when specifying multiple attribute values" do
+      it "returns the record matching all attributes" do
+        _record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+        record2 = DummyClass.record(id: 2) do |r|
+          r.name = "foo"
+        end
+
+        found_record = DummyClass.find_by!(id: 2, name: "foo")
+
+        expect(found_record).to eq(record2)
+      end
+    end
+
+    context "when specifying multiple attribute values but no record " \
+            "matches all attributes" do
+      it "returns nil" do
+        _record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+
+        expect {
+          DummyClass.find_by!(id: 1, name: "bar")
+        }.to raise_error(
+          StaticAssociation::RecordNotFound,
+          "Couldn't find DummyClass with id=1, name=bar"
+        )
+      end
+    end
+
+    context "with undefined attributes" do
+      it "raises a StaticAssociation::UndefinedAttribute" do
+        DummyClass.record(id: 1)
+
+        expect {
+          DummyClass.find_by!(undefined_attribute: 1)
+        }.to raise_error(
+          StaticAssociation::UndefinedAttribute,
+          "Undefined attribute 'undefined_attribute'"
+        )
+      end
+    end
+
+    context "with no attributes" do
+      it "raises a StaticAssociation::ArgumentError" do
+        expect {
+          DummyClass.find_by!
+        }.to raise_error(StaticAssociation::ArgumentError)
+      end
+    end
+  end
+
   describe ".belongs_to_static" do
     it "defines a reader method for the association" do
       associated_class = AssociationClass.new