smart_params 5.1.0 → 6.0.1

data/lib/smart_params_spec.rb

@@ -3,42 +3,95 @@
 require "spec_helper"
 
 RSpec.describe SmartParams do
-  let(:schema) { CreateAccountSchema.new(params) }
-  let(:nullable_schema) { NullableSchema.new(params) }
-  let(:nullable_required_subfield_schema) { NullableRequiredSubfieldSchema.new(params) }
+  let(:account_payload) { described_class.from(AccountSchema, params, :create) }
+  let(:nullable_payload) { described_class.from(NullableSchema, params) }
+  let(:nullable_required_subfield_payload) { described_class.from(NullableRequiredSubfieldSchema, params) }
+
+  describe ".validate!(account_payload)" do
+    subject { account_payload }
+
+    let(:account_payload) { described_class.validate!(AccountSchema, params, :create) }
 
-  describe ".new" do
     context "with an empty params" do
       let(:params) { {} }
 
       it "throws an error with a message detailing the invalid property type and given properties" do
-        expect { schema }.to raise_exception(SmartParams::Error::InvalidPropertyType, "expected [:data] to be Hash, but is nil")
+        expect { subject }.to raise_exception(SmartParams::InvalidPayloadException, "structure failed to validate: \n\t/data is missing from the structure, last node was {}\n\t/data/type is missing from the structure, last node was {}\n\t/data/attributes is missing from the structure, last node was {}\n\t/data/attributes/email is missing from the structure, last node was {}")
       end
 
       it "throws an error with the missing property and given properties" do
-        expect { schema }.to raise_exception do |exception|
-          expect(exception).to have_attributes(keychain: [:data], wanted: a_kind_of(Dry::Types::Constrained), raw: nil)
+        expect { subject }.to raise_exception(SmartParams::InvalidPayloadException) do |exception|
+          expect(exception).to(have_attributes(failures: an_array_matching([
+                                                                             have_attributes(class: SmartParams::MissingPropertyException, path: [:data], last: {}),
+                                                                             have_attributes(class: SmartParams::MissingPropertyException, path: [:data, :type], last: {}),
+                                                                             have_attributes(class: SmartParams::MissingPropertyException, path: [:data, :attributes], last: {}),
+                                                                             have_attributes(class: SmartParams::MissingPropertyException, path: [:data, :attributes, :email], last: {})
+                                                                           ])))
+        end
+      end
+    end
+
+    context "with a good root key, intermediary key, and bad type" do
+      let(:params) do
+        {
+          data: {
+            type: "accounts",
+            attributes: {
+              email: "kurtis@example.com",
+              password: 1
+            }
+          },
+          meta: {
+            jsonapi_version: "1.0"
+          },
+          included: [
+            {
+              data: {
+                id: "a",
+                type: "widget",
+                attributes: {
+                  title: "Widget A"
+                }
+              }
+            }
+          ]
+        }
+      end
+
+      it "throws an error with a message detailing the invalid property, expected type, given type, and given value" do
+        expect { subject }.to raise_exception(SmartParams::InvalidPayloadException, "structure failed to validate: \n\texpected /data/attributes/password to be NilClass | String, but is 1 and 1 violates constraints (type?(String, 1) failed)")
+      end
+
+      it "throws an error with the invalid property, expected type, given type, and given value" do
+        expect { subject }.to raise_exception(SmartParams::InvalidPayloadException) do |exception|
+          expect(exception).to(have_attributes(failures: an_array_matching([
+                                                                             have_attributes(class: SmartParams::InvalidPropertyTypeException, path: [:data, :attributes, :password])
+                                                                           ])))
         end
       end
     end
 
-    context "with a good key but bad type" do
+    context "with a good root key but missing intermediary key" do
       let(:params) { { data: "" } }
 
       it "throws an error with a message detailing the invalid property, expected type, given type, and given value" do
-        expect { schema }.to raise_exception(SmartParams::Error::InvalidPropertyType, "expected [:data] to be Hash, but is \"\"")
+        expect { subject }.to raise_exception(SmartParams::InvalidPayloadException, "structure failed to validate: \n\t/data/type is missing from the structure, last node was \"\"\n\t/data/attributes is missing from the structure, last node was \"\"\n\t/data/attributes/email is missing from the structure, last node was \"\"")
       end
 
       it "throws an error with the invalid property, expected type, given type, and given value" do
-        expect { schema }.to raise_exception do |exception|
-          expect(exception).to have_attributes(keychain: [:data], wanted: a_kind_of(Dry::Types::Constrained), raw: "")
+        expect { subject }.to raise_exception(SmartParams::InvalidPayloadException) do |exception|
+          expect(exception).to(have_attributes(failures: an_array_matching([
+                                                                             have_attributes(class: SmartParams::MissingPropertyException, path: [:data, :type], last: ""),
+                                                                             have_attributes(class: SmartParams::MissingPropertyException, path: [:data, :attributes], last: ""),
+                                                                             have_attributes(class: SmartParams::MissingPropertyException, path: [:data, :attributes, :email], last: "")
+                                                                           ])))
         end
       end
     end
   end
 
-  describe "#payload" do
-    subject { schema.payload }
+  describe ".from(account_payload)" do
+    subject { account_payload }
 
     context "with a reasonably good params" do
       let(:params) do
@@ -67,25 +120,59 @@ RSpec.describe SmartParams do
         }
       end
 
+      it "returns as native data types" do
+        expect(
+          subject
+        ).to match(
+          hash_including(
+            {
+              data: hash_including(
+                {
+                  type: "accounts",
+                  attributes: hash_including(
+                    {
+                      email: "kurtis@example.com",
+                      password: an_instance_of(String)
+                    }
+                  )
+                }
+              ),
+              meta: {
+                jsonapi_version: "1.0"
+              },
+              included: [
+                {
+                  data: {
+                    id: "a",
+                    type: "widget",
+                    attributes: {
+                      title: "Widget A"
+                    }
+                  }
+                }
+              ]
+            }
+          )
+        )
+      end
+
       it "has a chain path data.type" do
-        expect(subject.data.type).to eq("accounts")
+        expect(subject[:data][:type]).to eq("accounts")
       end
 
       it "has a chain path data.attributes.email" do
-        expect(subject.data.attributes.email).to eq("kurtis@example.com")
+        expect(subject[:data][:attributes][:email]).to eq("kurtis@example.com")
       end
 
       it "has a chain path data.attributes.password" do
-        expect(subject.data.attributes.password).to be_a(String)
+        expect(subject[:data][:attributes][:password]).to be_a(String)
       end
 
       it "has a chain path meta.jsonapi_version" do
-        expect(subject.meta.jsonapi_version).to eq("1.0")
+        expect(subject[:meta][:jsonapi_version]).to eq("1.0")
       end
     end
-  end
 
-  shared_examples "native types" do
     context "with extra params" do
       let(:params) do
         {
@@ -105,12 +192,12 @@ RSpec.describe SmartParams do
           subject
         ).to match(
           {
-            "data" => hash_including(
+            data: hash_including(
               {
-                "type" => "accounts",
-                "attributes" => hash_including(
+                type: "accounts",
+                attributes: hash_including(
                   {
-                    "email" => "kurtis@example.com"
+                    email: "kurtis@example.com"
                   }
                 )
               }
@@ -138,12 +225,12 @@ RSpec.describe SmartParams do
           subject
         ).to match(
           {
-            "data" => hash_including(
+            data: hash_including(
               {
-                "type" => "accounts",
-                "attributes" => hash_including(
+                type: "accounts",
+                attributes: hash_including(
                   {
-                    "email" => "kurtis@example.com",
+                    email: "kurtis@example.com",
                     "full-name" => "Kurtis Rainbolt-Greene"
                   }
                 )
@@ -153,234 +240,63 @@ RSpec.describe SmartParams do
         )
       end
     end
-
-    context "with a reasonably good params" do
-      let(:params) do
-        {
-          data: {
-            type: "accounts",
-            attributes: {
-              email: "kurtis@example.com",
-              password: "secret"
-            }
-          },
-          meta: {
-            jsonapi_version: "1.0"
-          },
-          included: [
-            {
-              data: {
-                id: "a",
-                type: "widget",
-                attributes: {
-                  title: "Widget A"
-                }
-              }
-            }
-          ]
-        }
-      end
-
-      it "returns as native data types" do
-        expect(
-          subject
-        ).to match(
-          hash_including(
-            {
-              "data" => hash_including(
-                {
-                  "type" => "accounts",
-                  "attributes" => hash_including(
-                    {
-                      "email" => "kurtis@example.com",
-                      "password" => an_instance_of(String)
-                    }
-                  )
-                }
-              ),
-              "meta" => {
-                "jsonapi_version" => "1.0"
-              },
-              "included" => [
-                {
-                  "data" => {
-                    "id" => "a",
-                    "type" => "widget",
-                    "attributes" => {
-                      "title" => "Widget A"
-                    }
-                  }
-                }
-              ]
-            }
-          )
-        )
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    subject { schema.to_hash }
-
-    include_examples "native types"
-  end
-
-  describe "#as_json" do
-    subject { schema.as_json }
-
-    include_examples "native types"
   end
 
-  describe "#fetch" do
-    subject { schema.fetch("data") }
+  describe ".from(nullable_required_subfield_payload)" do
+    subject { nullable_required_subfield_payload }
 
-    context "with a reasonably good params" do
+    context "when specified with unclean data" do
       let(:params) do
         {
+          # This will raise an exception becase the data hash is specified
+          # but its required subfields are not.
           data: {
-            type: "accounts",
-            attributes: {
-              email: "kurtis@example.com",
-              password: "secret"
-            }
-          },
-          meta: {
-            jsonapi_version: "1.0"
-          },
-          included: [
-            {
-              data: {
-                id: "a",
-                type: "widget",
-                attributes: {
-                  title: "Widget A"
-                }
-              }
-            }
-          ]
+            is: "garbage"
+          }
         }
       end
 
-      it "returns the native type" do
-        expect(
-          subject
-        ).to match(
-          hash_including(
-            {
-              "type" => "accounts",
-              "attributes" => hash_including(
-                {
-                  "email" => "kurtis@example.com",
-                  "password" => an_instance_of(String)
-                }
-              )
-            }
-          )
-        )
+      it "checks subfields" do
+        expect(subject).to(an_array_matching([have_attributes(class: SmartParams::MissingPropertyException, path: [:data, :id], last: { is: "garbage" })]))
       end
     end
-  end
-
-  describe "#dig" do
-    subject { schema.dig("data", "attributes", "email") }
 
-    context "with a reasonably good params" do
+    context "when specified as null" do
       let(:params) do
         {
-          data: {
-            type: "accounts",
-            attributes: {
-              email: "kurtis@example.com"
-            }
-          },
-          meta: {
-            jsonapi_version: "1.0"
-          },
-          included: [
-            {
-              data: {
-                id: "a",
-                type: "widget",
-                attributes: {
-                  title: "Widget A"
-                }
-              }
-            }
-          ]
+          # This will not raise an error, since data is allowed to be null.
+          # Subfields will not be checked.
+          data: nil
         }
       end
 
-      it "returns the native type" do
-        expect(
+      it "checks subfields" do
+        expect do
           subject
-        ).to eq(
-          "kurtis@example.com"
-        )
+        end.not_to raise_exception
       end
     end
-  end
-
-  describe "#fetch_values" do
-    subject { schema.fetch_values("data", "meta") }
 
-    context "with a reasonably good params" do
+    context "when unspecified with required subfield" do
       let(:params) do
         {
-          data: {
-            type: "accounts",
-            attributes: {
-              email: "kurtis@example.com",
-              password: "secret"
-            }
-          },
-          meta: {
-            jsonapi_version: "1.0"
-          },
-          included: [
-            {
-              data: {
-                id: "a",
-                type: "widget",
-                attributes: {
-                  title: "Widget A"
-                }
-              }
-            }
-          ]
+          # In this case, the nullable data hash is not specified so we
+          # don't need to enforce constraints on subfields.
         }
       end
 
-      it "returns the native type" do
-        expect(
+      it "allows null value" do
+        expect do
           subject
-        ).to match(
-          [
-            hash_including(
-              {
-                "type" => "accounts",
-                "attributes" => hash_including(
-                  {
-                    "email" => "kurtis@example.com",
-                    "password" => an_instance_of(String)
-                  }
-                )
-              }
-            ),
-            hash_including(
-              {
-                "jsonapi_version" => "1.0"
-              }
-            )
-          ]
-        )
+        end.not_to raise_exception
       end
     end
   end
 
-  describe "nullable values" do
-    context "when set to nil" do
-      subject { nullable_schema.to_hash }
+  describe ".from(nullable_payload)" do
+    subject { nullable_payload }
 
+    context "when set to nil" do
       let(:params) do
         {
           data: nil
@@ -393,7 +309,7 @@ RSpec.describe SmartParams do
         ).to match(
           hash_including(
             {
-              "data" => nil
+              data: nil
             }
           )
         )
@@ -401,8 +317,6 @@ RSpec.describe SmartParams do
     end
 
     context "when provided matching data" do
-      subject { nullable_schema.to_hash }
-
       let(:params) do
         {
           data: {
@@ -418,10 +332,10 @@ RSpec.describe SmartParams do
         ).to match(
           hash_including(
             {
-              "data" => hash_including(
+              data: hash_including(
                 {
-                  "id" => "1",
-                  "type" => "people"
+                  id: "1",
+                  type: "people"
                 }
               )
             }
@@ -431,8 +345,6 @@ RSpec.describe SmartParams do
     end
 
     context "when not provided" do
-      subject { nullable_schema.to_hash }
-
       let(:params) do
         {}
       end
@@ -443,7 +355,7 @@ RSpec.describe SmartParams do
         ).to match(
           hash_excluding(
             {
-              "data" => nil
+              data: nil
             }
           )
         )
@@ -451,8 +363,6 @@ RSpec.describe SmartParams do
     end
 
     context "with non matching subfield data" do
-      subject { nullable_schema.to_hash }
-
       let(:params) do
         {
           data: {
@@ -469,66 +379,11 @@ RSpec.describe SmartParams do
         ).to match(
           hash_excluding(
             {
-              "is" => "garbage"
+              is: "garbage"
             }
           )
         )
       end
     end
-
-    context "when specified with unclean data" do
-      subject { nullable_required_subfield_schema.to_hash }
-
-      let(:params) do
-        {
-          # This will raise an exception becase the data hash is specified
-          # but its required subfields are not.
-          data: {
-            is: "garbage"
-          }
-        }
-      end
-
-      it "checks subfields" do
-        expect do
-          subject
-        end.to raise_exception(SmartParams::Error::InvalidPropertyType)
-      end
-    end
-
-    context "when specified as null" do
-      subject { nullable_required_subfield_schema.to_hash }
-
-      let(:params) do
-        {
-          # This will not raise an error, since data is allowed to be null.
-          # Subfields will not be checked.
-          data: nil
-        }
-      end
-
-      it "checks subfields" do
-        expect do
-          subject
-        end.not_to raise_exception
-      end
-    end
-
-    context "when unspecified with required subfield" do
-      subject { nullable_required_subfield_schema.to_hash }
-
-      let(:params) do
-        {
-          # In this case, the nullable data hash is not specified so we
-          # don't need to enforce constraints on subfields.
-        }
-      end
-
-      it "allows null value" do
-        expect do
-          subject
-        end.not_to raise_exception
-      end
-    end
   end
 end

metadata

@@ -1,57 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: smart_params
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 6.0.1
 platform: ruby
 authors:
 - Kurtis Rainbolt-Greene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-10 00:00:00.000000000 Z
+date: 2024-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: dry-types
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: recursive-open-struct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
 description: Apply an organized and easy to maintain schema to request params
 email:
 - kurtis@rainbolt-greene.online
@@ -63,10 +49,15 @@ files:
 - README.md
 - Rakefile
 - lib/smart_params.rb
-- lib/smart_params/error.rb
-- lib/smart_params/error/invalid_property_type.rb
-- lib/smart_params/error/invalid_property_type_spec.rb
 - lib/smart_params/field.rb
+- lib/smart_params/fluent_language.rb
+- lib/smart_params/invalid_payload_exception.rb
+- lib/smart_params/invalid_property_type_exception.rb
+- lib/smart_params/missing_property_exception.rb
+- lib/smart_params/missing_type_annotation_exception.rb
+- lib/smart_params/namespace_already_defined_exception.rb
+- lib/smart_params/no_matching_namespace_exception.rb
+- lib/smart_params/path_already_defined_exception.rb
 - lib/smart_params/version.rb
 - lib/smart_params_spec.rb
 homepage: https://github.com/krainboltgreene/smart_params.rb