glia-errors 0.0.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23c0be62fe5b91fe4914d5b6812cfd678a11497e9591291a0664823e6ef1938b
-  data.tar.gz: 51680c69eaf02641ecc47857d67679fb3e64208f2e008471dffbe64d422d41d1
+  metadata.gz: 65d627db5f7496b55539268de587762316d8d138ea0548ecd7abb5c7968fb4b1
+  data.tar.gz: f0894efd36f5e3013d9f3892e922ea5b7007e3a271595a262e9e97534d90923f
 SHA512:
-  metadata.gz: 3600850fc2f82f50c3608cbba041ef6af9bc9f15a387a64250e465b284ae26316532386443848a8718e4008b37a651c0c876bfb7ddac3e279990b2e11d9e49a7
-  data.tar.gz: 46a878503202ae5bdb3ba9f8df49c76fd1d122ca76aa9456f0d477753f6f312cd6f01514d59d1babd5a0259b72e2b9f383dc5e0442e7c446a0c9a869350ffc3d
+  metadata.gz: 03af1bfefb0087f78f4ddfabe4575980167f03df92fc0aba83052a1aaed18a936b60b53b3d442deb1676f85007b47a9c86772f0581fc63e425417ec3c22235d7
+  data.tar.gz: dac6e22cc50535689a445ae0616c73b362bfdf75af9daf81c4d11f54034f7233da72e3bf00f1c4a203e649227b223e2d37025db91aa83d8e3dd22ca8474b1be3

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.7.2

data/Gemfile

@@ -2,7 +2,7 @@
 
 source 'https://rubygems.org'
 
-gem 'prettier', '~> 0.21'
+gem 'prettier', '~> 0.22'
 gem 'rake', '~> 13.0'
 gem 'rspec', '~> 3.10'
 gem 'rubocop', '~> 1.5'

data/Gemfile.lock

@@ -13,7 +13,7 @@ GEM
       ast (~> 2.4.1)
     patience_diff (1.1.0)
       trollop (~> 1.16)
-    prettier (0.21.0)
+    prettier (0.22.0)
     rainbow (3.0.0)
     rake (13.0.1)
     regexp_parser (2.0.0)
@@ -58,10 +58,11 @@ GEM
 
 PLATFORMS
   ruby
+  x86_64-darwin-19
 
 DEPENDENCIES
   appraisal
-  prettier (~> 0.21)
+  prettier (~> 0.22)
   rake (~> 13.0)
   rspec (~> 3.10)
   rubocop (~> 1.5)

data/README.md

@@ -1,25 +1,24 @@
-# glia-errors-ruby
-Glia REST API errors (WIP)
+# glia-errors
 
-[![Build Status](https://travis-ci.org/salemove/glia-errors-ruby.svg?branch=master)](https://travis-ci.org/salemove/glia-errors-ruby)
+Implements Glia errors in Ruby and provides utilities to easily construct them.
 
-The library provides a list of errors that are used in Glia REST API and utilities to easily construct them.
+# Installation
 
-It is used by Glia developers to map application specific errors to one of standardized Glia errors.
-Glia REST API integrators can use the library as a collection of constants to match Glia error response with the error
-type, see the example below.
+```
+$ gem install glia-errors
+```
 
-# Usage
+## Usage
 
-## Require library
+### Require library
 
 ```ruby
 require 'glia/errors'
 ```
 
-## For Glia developers
+### For Glia developers
 
-### Map from `dry-validation` result
+#### Map from `dry-validation` result
 
 Currently 2 `dry-validation` versions are supported:
 * `v0` up to `0.13`
@@ -51,7 +50,7 @@ error = Glia::Errors.from_dry_validation_result(result, ERROR_MAP)
 response = error.to_h
 ```
 
-## For REST API integrators
+### For REST API integrators
 
 ```ruby
 require 'uri'
@@ -63,7 +62,6 @@ url = URI('https://api.glia.com/engagement_requests')
 
 http = Net::HTTP.new(url.host, url.port)
 http.use_ssl = true
-http.verify_mode = OpenSSL::SSL::VERIFY_NONE
 request = Net::HTTP::Post.new(url)
 request["Accept"] = 'application/json'
 request["Content-Type"] = 'application/json'
@@ -91,9 +89,9 @@ else
 end
 ```
 
-# Contributing
+## Contributing
 
-## Testing
+### Testing
 
 Glia errors support multiple versions of `dry-validation` and tests are run against each supported major version.
 Under the hood we use `Appraisal` gem which generals additional gemfiles for each of the versions.
@@ -116,7 +114,7 @@ To run tests only for `dry-validation` v0:
 bundle exec rake test_dry_validation_v0
 ```
 
-## Formatting
+### Formatting
 
 ```
 bundle exec rake format

data/gemfiles/dry_validation_v0.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "prettier", "~> 0.21"
+gem "prettier", "~> 0.22"
 gem "rake", "~> 13.0"
 gem "rspec", "~> 3.10"
 gem "rubocop", "~> 1.5"

data/gemfiles/dry_validation_v1.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-gem "prettier", "~> 0.21"
+gem "prettier", "~> 0.22"
 gem "rake", "~> 13.0"
 gem "rspec", "~> 3.10"
 gem "rubocop", "~> 1.5"

data/glia-errors.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'glia-errors'
-  spec.version       = '0.0.0'
+  spec.version       = '0.6.0'
   spec.authors       = ['Glia TechMovers']
   spec.email         = ['techmovers@glia.com']
 

data/lib/glia/errors.rb

@@ -2,7 +2,8 @@
 
 require_relative './errors/error'
 require_relative './errors/error_types'
-require_relative './errors/validation_errors'
+require_relative './errors/client_errors'
+require_relative './errors/server_errors'
 require_relative './errors/mapper'
 
 module Glia

data/lib/glia/errors/client_errors.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # rubocop:disable Style/Documentation
+    class InputValidationError < Error
+      def initialize(error_details:, message: nil)
+        super(
+          type: INPUT_VALIDATION_ERROR,
+          ref: "https://example.com/errors/#{INPUT_VALIDATION_ERROR}.html",
+          message: message,
+          error_details: error_details
+        )
+      end
+    end
+
+    class InvalidNumberError < Error
+      def initialize(field:, message: nil)
+        super(
+          type: INVALID_NUMBER_ERROR,
+          ref: "https://example.com/errors/#{INVALID_NUMBER_ERROR}.html",
+          message: message || "#{humanize(field)} value is invalid"
+        )
+      end
+    end
+
+    class InvalidValueError < Error
+      def initialize(field:, message: nil)
+        super(
+          type: INVALID_VALUE_ERROR,
+          ref: "https://example.com/errors/#{INVALID_VALUE_ERROR}.html",
+          message: message || "#{humanize(field)} value is invalid"
+        )
+      end
+    end
+
+    class InvalidLengthError < Error
+      def initialize(field:, message: nil)
+        super(
+          type: INVALID_LENGTH_ERROR,
+          ref: "https://example.com/errors/#{INVALID_LENGTH_ERROR}.html",
+          message: message || "#{humanize(field)} length is invalid"
+        )
+      end
+    end
+
+    class InvalidFormatError < Error
+      class Formats
+        DATE_TIME = 'date_time'
+        DATE = 'date'
+        TIME = 'time'
+        UUID = 'uuid'
+      end
+
+      def initialize(field:, format: nil, message: nil)
+        default_message =
+          format ? "has invalid format, required format is #{format}" : 'has invalid format'
+        super(
+          type: INVALID_FORMAT_ERROR,
+          ref: "https://example.com/errors/#{INVALID_FORMAT_ERROR}.html",
+          message: message || "#{humanize(field)} #{default_message}"
+        )
+      end
+    end
+
+    class InvalidTypeError < Error
+      class Types
+        STRING = 'string'
+        INTEGER = 'integer'
+        NUMBER = 'number'
+        BOOLEAN = 'boolean'
+        ARRAY = 'array'
+        OBJECT = 'object'
+      end
+
+      def initialize(field:, type:, message: nil)
+        super(
+          type: INVALID_TYPE_ERROR,
+          ref: "https://example.com/errors/#{INVALID_TYPE_ERROR}.html",
+          message: message || "#{humanize(field)} must be of type #{type}",
+          error_details: { type: type }
+        )
+      end
+    end
+
+    class MissingValueError < Error
+      def initialize(field:, message: nil)
+        super(
+          type: MISSING_VALUE_ERROR,
+          ref: "https://example.com/errors/#{MISSING_VALUE_ERROR}.html",
+          message: message || "#{humanize(field)} is missing"
+        )
+      end
+    end
+
+    class UnknownError < Error
+      def initialize(field:, message: nil)
+        super(
+          type: UNKNOWN_ERROR,
+          ref: "https://example.com/errors/#{UNKNOWN_ERROR}.html",
+          message: message || "#{humanize(field)} validation failed with unknown error"
+        )
+      end
+    end
+
+    class ResourceNotFoundError < Error
+      def initialize(resource:, message: nil)
+        assert_snake_case(resource)
+
+        super(
+          type: RESOURCE_NOT_FOUND_ERROR,
+          ref: "https://example.com/errors/#{RESOURCE_NOT_FOUND_ERROR}.html",
+          message: message || "#{humanize(resource)} not found",
+          error_details: { resource: resource }
+        )
+      end
+    end
+
+    class NotVerifiedError < Error
+      def initialize(resource:, message: nil)
+        assert_snake_case(resource)
+
+        super(
+          type: NOT_VERIFIED_ERROR,
+          ref: "https://example.com/errors/#{NOT_VERIFIED_ERROR}.html",
+          message: message || "#{humanize(resource)} is not verified",
+          error_details: { resource: resource }
+        )
+      end
+    end
+
+    class RemainingAssociationError < Error
+      def initialize(resource:, associated_resource:, message: nil)
+        assert_snake_case(resource)
+        assert_snake_case(associated_resource)
+
+        default_message =
+          "cannot be modified/deleted because it is associated to one or more #{
+            humanize(associated_resource)
+          }(s)"
+        super(
+          type: REMAINING_ASSOCIATION_ERROR,
+          ref: "https://example.com/errors/#{REMAINING_ASSOCIATION_ERROR}.html",
+          message: message || "#{humanize(resource)} #{default_message}",
+          error_details: { resource: resource, associated_resource: associated_resource }
+        )
+      end
+    end
+
+    class LimitExceededError < Error
+      def initialize(resource:, max:, message: nil)
+        assert_snake_case(resource)
+
+        super(
+          type: LIMIT_EXCEEDED_ERROR,
+          ref: "https://example.com/errors/#{LIMIT_EXCEEDED_ERROR}.html",
+          message: message || "#{humanize(resource)} count must not exceed #{max}",
+          error_details: { resource: resource, max: max }
+        )
+      end
+    end
+
+    class ResourceAlreadyExistsError < Error
+      def initialize(resource:, message: nil)
+        assert_snake_case(resource)
+
+        super(
+          type: RESOURCE_ALREADY_EXISTS_ERROR,
+          ref: "https://example.com/errors/#{RESOURCE_ALREADY_EXISTS_ERROR}.html",
+          message: message || "#{humanize(resource)} already exists",
+          error_details: { resource: resource }
+        )
+      end
+    end
+
+    class InvalidResourceStateError < Error
+      def initialize(resource:, state:, message: nil)
+        assert_snake_case(resource)
+        assert_snake_case(state)
+
+        super(
+          type: INVALID_RESOURCE_STATE_ERROR,
+          ref: "https://example.com/errors/#{INVALID_RESOURCE_STATE_ERROR}.html",
+          message: message || "#{humanize(resource)} is in invalid state: #{state}",
+          error_details: { resource: resource, state: state }
+        )
+      end
+    end
+
+    class AuthorizationError < Error
+      def initialize(message: nil)
+        super(
+          type: AUTHORIZATION_ERROR,
+          ref: "https://example.com/errors/#{AUTHORIZATION_ERROR}.html",
+          message: message || 'You do not have permissions to perform the action'
+        )
+      end
+    end
+
+    class RecipientOptedOutError < Error
+      def initialize(message: nil)
+        super(
+          type: RECIPIENT_OPTED_OUT_ERROR,
+          ref:
+            'https://docs.glia.com/glia-dev/reference/webhooks#example-engagementrequestfailure-event-with-fail_error',
+          message: message || 'Recipient has opted out'
+        )
+      end
+    end
+    # rubocop:enable Style/Documentation
+  end
+end

data/lib/glia/errors/error.rb

@@ -4,6 +4,7 @@ module Glia
   module Errors
     # Base error
     class Error
+      SNAKE_CASE_REGEX = /^[a-z0-9]+(_[a-z0-9]+)*$/.freeze
       attr_reader :type, :ref, :message, :error_details
 
       def initialize(type:, ref:, message: nil, error_details: nil)
@@ -46,6 +47,12 @@ module Glia
       def humanize(value)
         value.to_s.capitalize.gsub('_', ' ')
       end
+
+      def assert_snake_case(value)
+        return if value.to_s.match(SNAKE_CASE_REGEX)
+
+        raise ArgumentError, "Expected '#{value}' to be in snake case"
+      end
     end
   end
 end

data/lib/glia/errors/error_types.rb

@@ -2,6 +2,7 @@
 
 module Glia
   module Errors
+    # Client errors
     INPUT_VALIDATION_ERROR = 'input_validation_error'
     INVALID_TYPE_ERROR = 'invalid_type_error'
     INVALID_NUMBER_ERROR = 'invalid_number_error'
@@ -10,5 +11,17 @@ module Glia
     INVALID_LENGTH_ERROR = 'invalid_length_error'
     MISSING_VALUE_ERROR = 'missing_value_error'
     UNKNOWN_ERROR = 'unknown_error'
+    RESOURCE_NOT_FOUND_ERROR = 'resource_not_found_error'
+    NOT_VERIFIED_ERROR = 'not_verified_error'
+    REMAINING_ASSOCIATION_ERROR = 'remaining_association_error'
+    LIMIT_EXCEEDED_ERROR = 'limit_exceeded_error'
+    RESOURCE_ALREADY_EXISTS_ERROR = 'resource_already_exists_error'
+    INVALID_RESOURCE_STATE_ERROR = 'invalid_resource_state_error'
+    AUTHORIZATION_ERROR = 'authorization_error'
+    RECIPIENT_OPTED_OUT_ERROR = 'recipient_opted_out_error'
+
+    # Server errors
+    INTERNAL_SERVER_ERROR = 'internal_server_error'
+    SERVICE_UNAVAILABLE_ERROR = 'service_unavailable_error'
   end
 end

data/lib/glia/errors/mapper.rb

@@ -8,17 +8,18 @@ module Glia
         lambda do |field, _value, message|
           type =
             case message
-            when 'must be an array'
+            when 'must be an array', 'must be Array'
               InvalidTypeError::Types::ARRAY
-            when 'must be an integer'
+            when 'must be an integer', 'must be Integer'
               InvalidTypeError::Types::INTEGER
-            when 'must be a number', 'must be a float', 'must be a decimal'
+            when 'must be a number', 'must be a float', 'must be a decimal', 'must be Float',
+                 'must be BigDecimal'
               InvalidTypeError::Types::NUMBER
-            when 'must be a hash'
+            when 'must be a hash', 'must be Hash'
               InvalidTypeError::Types::OBJECT
-            when 'must be boolean'
+            when 'must be boolean', 'must be Boolean'
               InvalidTypeError::Types::BOOLEAN
-            when 'must be a string'
+            when 'must be a string', 'must be String'
               InvalidTypeError::Types::STRING
             end
           InvalidTypeError.new(field: field, type: type)
@@ -45,40 +46,44 @@ module Glia
           end
         end
 
-      # dry-validation will return `must be a date/time` even if we provide a number or boolean,
-      # in which case `invalid_format_error` does not make sense, so instead we will return `invalid_type_error`
-      INVALID_DATE_FORMAT_OR_TYPE_ERROR =
-        lambda do |field, value, message|
-          if value.is_a?(String)
-            format =
-              case message
-              when 'must be a date'
-                InvalidFormatError::Formats::DATE
-              when 'must be a date time'
-                InvalidFormatError::Formats::DATE_TIME
-              when 'must be a time'
-                InvalidFormatError::Formats::TIME
-              end
-            InvalidFormatError.new(field: field, format: format)
-          else
-            InvalidTypeError.new(field: field, type: InvalidTypeError::Types::STRING)
-          end
+      INVALID_DATE_FORMAT =
+        lambda do |field, _value, message|
+          format =
+            case message
+            when 'must be a date', 'must be Date'
+              InvalidFormatError::Formats::DATE
+            when 'must be a date time', 'must be DateTime'
+              InvalidFormatError::Formats::DATE_TIME
+            when 'must be a time', 'must be Time'
+              InvalidFormatError::Formats::TIME
+            end
+          InvalidFormatError.new(field: field, format: format)
         end
 
       ERROR_MAP = {
         # InvalidTypeError
         'must be an array' => INVALID_TYPE_ERROR,
+        'must be Array' => INVALID_TYPE_ERROR,
         'must be an integer' => INVALID_TYPE_ERROR,
+        'must be Integer' => INVALID_TYPE_ERROR,
         'must be a number' => INVALID_TYPE_ERROR,
         'must be a float' => INVALID_TYPE_ERROR,
+        'must be Float' => INVALID_TYPE_ERROR,
         'must be a decimal' => INVALID_TYPE_ERROR,
+        'must be BigDecimal' => INVALID_TYPE_ERROR,
         'must be a hash' => INVALID_TYPE_ERROR,
+        'must be Hash' => INVALID_TYPE_ERROR,
         'must be boolean' => INVALID_TYPE_ERROR,
+        'must be Boolean' => INVALID_TYPE_ERROR,
         'must be a string' => INVALID_TYPE_ERROR,
-        'must be a date time' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
-        'must be a date' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
-        'must be a time' => INVALID_DATE_FORMAT_OR_TYPE_ERROR,
+        'must be String' => INVALID_TYPE_ERROR,
         # InvalidFormatError
+        'must be a date time' => INVALID_DATE_FORMAT,
+        'must be DateTime' => INVALID_DATE_FORMAT,
+        'must be a date' => INVALID_DATE_FORMAT,
+        'must be Date' => INVALID_DATE_FORMAT,
+        'must be a time' => INVALID_DATE_FORMAT,
+        'must be Time' => INVALID_DATE_FORMAT,
         'is in invalid format' => INVALID_FORMAT_ERROR,
         'is not a valid UUID' => INVALID_UUID_ERROR,
         # InvalidNumberError
@@ -93,9 +98,11 @@ module Glia
         'must be false' => INVALID_VALUE_ERROR,
         'must include' => INVALID_VALUE_ERROR,
         'must not include' => INVALID_VALUE_ERROR,
-        'must be empty' => INVALID_VALUE_ERROR,
-        'must be filled' => INVALID_VALUE_ERROR,
-        'cannot be empty' => INVALID_VALUE_ERROR,
+        'must be filled' =>
+          lambda do |field, value, _message|
+            # Consider `nil` as invalid value error, but empty string or array as invalid length error
+            value.nil? ? InvalidValueError.new(field: field) : InvalidLengthError.new(field: field)
+          end,
         'cannot be defined' => INVALID_VALUE_ERROR,
         # InvalidNumberError or InvalidValueError
         'must be equal to' => INVALID_NUMBER_OR_VALUE_ERROR,
@@ -112,6 +119,8 @@ module Glia
         'bytes long' => INVALID_LENGTH_ERROR,
         'length must be' => INVALID_LENGTH_ERROR,
         'length must be within' => INVALID_LENGTH_ERROR,
+        'must be empty' => INVALID_LENGTH_ERROR,
+        'cannot be empty' => INVALID_LENGTH_ERROR,
         # MissingValueError
         'is missing' => MISSING_VALUE_ERROR,
         # Custom format errors
@@ -132,7 +141,9 @@ module Glia
             field_value = output[field]
             acc[field] =
               if field_messages.is_a?(Hash)
-                from_dry_validation_result_rec(field_value, field_messages, error_map)
+                # Wrap result in array as by defined structure each field has an array of errors.
+                # This is not needed for the `else` case as dry-validation already provides an array.
+                [from_dry_validation_result_rec(field_value, field_messages, error_map)]
               else
                 field_messages.map do |message|
                   from_dry_validation_error(field, field_value, message, error_map)

data/lib/glia/errors/server_errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Glia
+  module Errors
+    # rubocop:disable Style/Documentation
+    class InternalServerError < Error
+      def initialize(message: nil)
+        super(
+          type: INTERNAL_SERVER_ERROR,
+          ref: "https://example.com/errors/#{INTERNAL_SERVER_ERROR}.html",
+          message: message || 'Internal server error'
+        )
+      end
+    end
+
+    class ServiceUnavailableError < Error
+      def initialize(message: nil)
+        super(
+          type: SERVICE_UNAVAILABLE_ERROR,
+          ref: "https://example.com/errors/#{SERVICE_UNAVAILABLE_ERROR}.html",
+          message: message || 'Service unavailable'
+        )
+      end
+    end
+    # rubocop:enable Style/Documentation
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glia-errors
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Glia TechMovers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-14 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies: []
 description: ''
 email:
@@ -22,27 +22,22 @@ files:
 - ".prettierrc"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - ".travis.yml"
 - Appraisals
 - Gemfile
 - Gemfile.lock
-- LICENSE
 - README.md
 - Rakefile
 - gemfiles/dry_validation_v0.gemfile
 - gemfiles/dry_validation_v1.gemfile
 - glia-errors.gemspec
 - lib/glia/errors.rb
+- lib/glia/errors/client_errors.rb
 - lib/glia/errors/error.rb
 - lib/glia/errors/error_types.rb
 - lib/glia/errors/mapper.rb
-- lib/glia/errors/validation_errors.rb
-- test_cases/invalid_format_error_case.json
-- test_cases/invalid_length_error_case.json
-- test_cases/invalid_number_error_case.json
-- test_cases/invalid_type_error_case.json
-- test_cases/invalid_value_error_case.json
-- test_cases/missing_value_error_case.json
+- lib/glia/errors/server_errors.rb
 homepage:
 licenses:
 - MIT
@@ -62,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: Glia REST API errors

data/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Glia Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

data/lib/glia/errors/validation_errors.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module Glia
-  module Errors
-    # InputValidationError
-    class InputValidationError < Error
-      def initialize(error_details:, message: nil)
-        super(
-          type: INPUT_VALIDATION_ERROR,
-          ref: "https://example.com/errors/#{INPUT_VALIDATION_ERROR}.html",
-          message: message,
-          error_details: error_details
-        )
-      end
-    end
-
-    # InvalidNumberError
-    class InvalidNumberError < Error
-      def initialize(field:)
-        super(
-          type: INVALID_NUMBER_ERROR,
-          ref: "https://example.com/errors/#{INVALID_NUMBER_ERROR}.html",
-          message: "#{humanize(field)} is invalid"
-        )
-      end
-    end
-
-    # InvalidValueError
-    class InvalidValueError < Error
-      def initialize(field:)
-        super(
-          type: INVALID_VALUE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_VALUE_ERROR}.html",
-          message: "#{humanize(field)} is invalid"
-        )
-      end
-    end
-
-    # InvalidLengthError
-    class InvalidLengthError < Error
-      def initialize(field:)
-        super(
-          type: INVALID_LENGTH_ERROR,
-          ref: "https://example.com/errors/#{INVALID_LENGTH_ERROR}.html",
-          message: "#{humanize(field)} length is invalid"
-        )
-      end
-    end
-
-    # InvalidFormatError
-    class InvalidFormatError < Error
-      class Formats
-        DATE_TIME = 'date_time'
-        DATE = 'date'
-        TIME = 'time'
-        UUID = 'uuid'
-      end
-
-      def initialize(field:, format: nil)
-        super(
-          type: INVALID_FORMAT_ERROR,
-          ref: "https://example.com/errors/#{INVALID_FORMAT_ERROR}.html",
-          message:
-            if format
-              "#{humanize(field)} has invalid format, required format is #{format}"
-            else
-              "#{humanize(field)} has invalid format"
-            end
-        )
-      end
-    end
-
-    # InvalidTypeError
-    class InvalidTypeError < Error
-      class Types
-        STRING = 'string'
-        INTEGER = 'integer'
-        NUMBER = 'number'
-        BOOLEAN = 'boolean'
-        ARRAY = 'array'
-        OBJECT = 'object'
-      end
-
-      def initialize(field:, type:)
-        super(
-          type: INVALID_TYPE_ERROR,
-          ref: "https://example.com/errors/#{INVALID_TYPE_ERROR}.html",
-          message: "#{humanize(field)} must be of type #{type}"
-        )
-      end
-    end
-
-    # MissingValueError
-    class MissingValueError < Error
-      def initialize(field:)
-        super(
-          type: MISSING_VALUE_ERROR,
-          ref: "https://example.com/errors/#{MISSING_VALUE_ERROR}.html",
-          message: "#{humanize(field)} is missing"
-        )
-      end
-    end
-
-    # UnknownError
-    class UnknownError < Error
-      def initialize(field:)
-        super(
-          type: UNKNOWN_ERROR,
-          ref: "https://example.com/errors/#{UNKNOWN_ERROR}.html",
-          message: "#{humanize(field)} validation failed with unknown error"
-        )
-      end
-    end
-  end
-end

data/test_cases/invalid_format_error_case.json

@@ -1,74 +0,0 @@
-{
-  "input": {
-    "invalid_format_abc_regex": "defg",
-    "invalid_format_date": "not date",
-    "invalid_format_date_time": "not date time",
-    "invalid_format_time": "not time",
-    "invalid_format_uuid": "not uuid",
-    "invalid_format_e164": "not phone number",
-    "invalid_format_phone_extension": "not phone extension",
-    "invalid_format_email": "not email"
-  },
-  "expectation": {
-    "type": "input_validation_error",
-    "ref": "https://example.com/errors/input_validation_error.html",
-    "error_details": {
-      "invalid_format_abc_regex": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format abc regex has invalid format"
-        }
-      ],
-      "invalid_format_date": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format date has invalid format, required format is date"
-        }
-      ],
-      "invalid_format_date_time": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format date time has invalid format, required format is date_time"
-        }
-      ],
-      "invalid_format_time": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format time has invalid format, required format is time"
-        }
-      ],
-      "invalid_format_uuid": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format uuid has invalid format, required format is uuid"
-        }
-      ],
-      "invalid_format_e164": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format e164 has invalid format"
-        }
-      ],
-      "invalid_format_phone_extension": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format phone extension has invalid format"
-        }
-      ],
-      "invalid_format_email": [
-        {
-          "type": "invalid_format_error",
-          "ref": "https://example.com/errors/invalid_format_error.html",
-          "message": "Invalid format email has invalid format"
-        }
-      ]
-    }
-  }
-}

data/test_cases/invalid_length_error_case.json

@@ -1,106 +0,0 @@
-{
-  "input": {
-    "invalid_length_array_max_length_3": [1, 2, 3, 4],
-    "invalid_length_array_min_length_3": [1, 2],
-    "invalid_length_array_exact_length_3": [1, 2],
-    "invalid_length_array_range_length_1_2": [1, 2, 3],
-    "invalid_length_string_max_length_3": "abcd",
-    "invalid_length_string_min_length_3": "ab",
-    "invalid_length_string_exact_length_3": "ab",
-    "invalid_length_string_range_length_1_2": "abc",
-    "invalid_length_string_max_bytesize_3": "abcd",
-    "invalid_length_string_min_bytesize_3": "a",
-    "invalid_length_string_exact_bytesize_3": "ab",
-    "invalid_length_string_range_bytesize_1_2": "abc"
-  },
-  "expectation": {
-    "type": "input_validation_error",
-    "ref": "https://example.com/errors/input_validation_error.html",
-    "error_details": {
-      "invalid_length_array_max_length_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length array max length 3 length is invalid"
-        }
-      ],
-      "invalid_length_array_min_length_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length array min length 3 length is invalid"
-        }
-      ],
-      "invalid_length_array_exact_length_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length array exact length 3 length is invalid"
-        }
-      ],
-      "invalid_length_array_range_length_1_2": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length array range length 1 2 length is invalid"
-        }
-      ],
-      "invalid_length_string_max_length_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string max length 3 length is invalid"
-        }
-      ],
-      "invalid_length_string_min_length_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string min length 3 length is invalid"
-        }
-      ],
-      "invalid_length_string_exact_length_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string exact length 3 length is invalid"
-        }
-      ],
-      "invalid_length_string_range_length_1_2": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string range length 1 2 length is invalid"
-        }
-      ],
-      "invalid_length_string_max_bytesize_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string max bytesize 3 length is invalid"
-        }
-      ],
-      "invalid_length_string_min_bytesize_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string min bytesize 3 length is invalid"
-        }
-      ],
-      "invalid_length_string_exact_bytesize_3": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string exact bytesize 3 length is invalid"
-        }
-      ],
-      "invalid_length_string_range_bytesize_1_2": [
-        {
-          "type": "invalid_length_error",
-          "ref": "https://example.com/errors/invalid_length_error.html",
-          "message": "Invalid length string range bytesize 1 2 length is invalid"
-        }
-      ]
-    }
-  }
-}

data/test_cases/invalid_number_error_case.json

@@ -1,90 +0,0 @@
-{
-  "input": {
-    "invalid_number_less_than_10": 20,
-    "invalid_number_less_than_or_equal_10": 20,
-    "invalid_number_more_than_10": 5,
-    "invalid_number_more_than_or_equal_10": 5,
-    "invalid_number_equal_10": 5,
-    "invalid_number_not_equal_10": 10,
-    "invalid_number_one_of_1_2": 4,
-    "invalid_number_in_range_1_to_3": 4,
-    "invalid_number_even": 3,
-    "invalid_number_odd": 4
-  },
-  "expectation": {
-    "type": "input_validation_error",
-    "ref": "https://example.com/errors/input_validation_error.html",
-    "error_details": {
-      "invalid_number_less_than_10": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number less than 10 is invalid"
-        }
-      ],
-      "invalid_number_less_than_or_equal_10": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number less than or equal 10 is invalid"
-        }
-      ],
-      "invalid_number_more_than_10": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number more than 10 is invalid"
-        }
-      ],
-      "invalid_number_more_than_or_equal_10": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number more than or equal 10 is invalid"
-        }
-      ],
-      "invalid_number_equal_10": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number equal 10 is invalid"
-        }
-      ],
-      "invalid_number_not_equal_10": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number not equal 10 is invalid"
-        }
-      ],
-      "invalid_number_one_of_1_2": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number one of 1 2 is invalid"
-        }
-      ],
-      "invalid_number_in_range_1_to_3": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number in range 1 to 3 is invalid"
-        }
-      ],
-      "invalid_number_even": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number even is invalid"
-        }
-      ],
-      "invalid_number_odd": [
-        {
-          "type": "invalid_number_error",
-          "ref": "https://example.com/errors/invalid_number_error.html",
-          "message": "Invalid number odd is invalid"
-        }
-      ]
-    }
-  }
-}

data/test_cases/invalid_type_error_case.json

@@ -1,98 +0,0 @@
-{
-  "input": {
-    "invalid_type_array": 0,
-    "invalid_type_number": "str",
-    "invalid_type_object": 0,
-    "invalid_type_boolean": 0,
-    "invalid_type_integer": 0.0,
-    "invalid_type_float": 0,
-    "invalid_type_decimal": 0,
-    "invalid_type_date": 0,
-    "invalid_type_date_time": 0,
-    "invalid_type_time": 0,
-    "invalid_type_string": 0
-  },
-  "expectation": {
-    "type": "input_validation_error",
-    "ref": "https://example.com/errors/input_validation_error.html",
-    "error_details": {
-      "invalid_type_array": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type array must be of type array"
-        }
-      ],
-      "invalid_type_number": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type number must be of type number"
-        }
-      ],
-      "invalid_type_object": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type object must be of type object"
-        }
-      ],
-      "invalid_type_boolean": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type boolean must be of type boolean"
-        }
-      ],
-      "invalid_type_integer": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type integer must be of type integer"
-        }
-      ],
-      "invalid_type_float": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type float must be of type number"
-        }
-      ],
-      "invalid_type_decimal": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type decimal must be of type number"
-        }
-      ],
-      "invalid_type_date": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type date must be of type string"
-        }
-      ],
-      "invalid_type_date_time": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type date time must be of type string"
-        }
-      ],
-      "invalid_type_time": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type time must be of type string"
-        }
-      ],
-      "invalid_type_string": [
-        {
-          "type": "invalid_type_error",
-          "ref": "https://example.com/errors/invalid_type_error.html",
-          "message": "Invalid type string must be of type string"
-        }
-      ]
-    }
-  }
-}

data/test_cases/invalid_value_error_case.json

@@ -1,125 +0,0 @@
-{
-  "input": {
-    "invalid_value_string_equal_abc": "defg",
-    "invalid_value_string_one_of_a_b_c": "d",
-    "invalid_value_string_not_equal_abc": "abc",
-    "invalid_value_string_not_one_of_a_b_c": "a",
-    "invalid_value_string_empty": "a",
-    "invalid_value_string_not_empty": "",
-
-    "invalid_value_boolean_equal_true": false,
-    "invalid_value_boolean_equal_false": true,
-
-    "invalid_value_array_includes_a": ["b"],
-    "invalid_value_array_excludes_a": ["a"],
-    "invalid_value_array_empty": ["a"],
-    "invalid_value_array_not_empty": [],
-
-    "invalid_value_null": "a",
-    "invalid_value_not_null": null
-  },
-  "expectation": {
-    "type": "input_validation_error",
-    "ref": "https://example.com/errors/input_validation_error.html",
-    "error_details": {
-      "invalid_value_string_equal_abc": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value string equal abc is invalid"
-        }
-      ],
-      "invalid_value_string_one_of_a_b_c": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value string one of a b c is invalid"
-        }
-      ],
-      "invalid_value_string_not_equal_abc": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value string not equal abc is invalid"
-        }
-      ],
-      "invalid_value_string_not_one_of_a_b_c": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value string not one of a b c is invalid"
-        }
-      ],
-      "invalid_value_string_empty": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value string empty is invalid"
-        }
-      ],
-      "invalid_value_string_not_empty": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value string not empty is invalid"
-        }
-      ],
-      "invalid_value_boolean_equal_true": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value boolean equal true is invalid"
-        }
-      ],
-      "invalid_value_boolean_equal_false": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value boolean equal false is invalid"
-        }
-      ],
-      "invalid_value_array_includes_a": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value array includes a is invalid"
-        }
-      ],
-      "invalid_value_array_excludes_a": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value array excludes a is invalid"
-        }
-      ],
-      "invalid_value_array_empty": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value array empty is invalid"
-        }
-      ],
-      "invalid_value_array_not_empty": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value array not empty is invalid"
-        }
-      ],
-      "invalid_value_null": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value null is invalid"
-        }
-      ],
-      "invalid_value_not_null": [
-        {
-          "type": "invalid_value_error",
-          "ref": "https://example.com/errors/invalid_value_error.html",
-          "message": "Invalid value not null is invalid"
-        }
-      ]
-    }
-  }
-}

data/test_cases/missing_value_error_case.json

@@ -1,16 +0,0 @@
-{
-  "input": {},
-  "expectation": {
-    "type": "input_validation_error",
-    "ref": "https://example.com/errors/input_validation_error.html",
-    "error_details": {
-      "missing_value": [
-        {
-          "type": "missing_value_error",
-          "ref": "https://example.com/errors/missing_value_error.html",
-          "message": "Missing value is missing"
-        }
-      ]
-    }
-  }
-}