Refactor mount method options validator

Author: mcelicalderon

.rubocop.yml

@@ -59,7 +59,7 @@ Style/MethodCalledOnDoEndBlock:
   Enabled: false
 
 Naming/VariableNumber:
-  Enabled: false
+  EnforcedColonStyle: normalcase
 
 Style/StringLiterals:
   ConsistentQuotesInMultiline: true

lib/graphql_devise.rb

@@ -2,6 +2,12 @@
 require 'graphql'
 require 'devise_token_auth'
 
+module GraphqlDevise
+  class Error < StandardError; end
+
+  class InvalidMountOptionsError < GraphqlDevise::Error; end
+end
+
 require 'graphql_devise/concerns/controller_methods'
 require 'graphql_devise/types/authenticatable_type'
 require 'graphql_devise/types/credential_type'
@@ -17,11 +23,8 @@
 require 'graphql_devise/user_error'
 require 'graphql_devise/detailed_user_error'
 
+require 'graphql_devise/mount_method/options_validator'
 require 'graphql_devise/rails/queries_preparer'
 require 'graphql_devise/rails/mutations_preparer'
 require 'graphql_devise/rails/operation_checker'
 require 'graphql_devise/rails/operation_sanitizer'
-
-module GraphqlDevise
-  class Error < StandardError; end
-end

lib/graphql_devise/mount_method/option_validators/provided_operations_validator.rb

@@ -0,0 +1,44 @@
+require_relative 'supported_operations_validator'
+
+module GraphqlDevise
+  module MountMethod
+    module OptionValidators
+      class ProvidedOperationsValidator
+        def initialize(options: {}, supported_operations: {})
+          @options              = options || {}
+          @supported_operations = supported_operations
+        end
+
+        def validate!
+          skipped        = @options.fetch(:skip, [])
+          only           = @options.fetch(:only, [])
+          operations     = @options.fetch(:operations, {})
+          supported_keys = @supported_operations.keys
+
+          raise_on_invalid_option_type!(:skip, skipped, Array)
+          raise_on_invalid_option_type!(:only, only, Array)
+          raise_on_invalid_option_type!(:operations, operations, Hash)
+
+          custom = operations.keys
+
+          [
+            SupportedOperationsValidator.new(provided_operations: skipped, key: :skip, supported_operations: supported_keys),
+            SupportedOperationsValidator.new(provided_operations: only, key: :only, supported_operations: supported_keys),
+            SupportedOperationsValidator.new(provided_operations: custom, key: :operations, supported_operations: supported_keys)
+          ].each(&:validate!)
+        end
+
+        private
+
+        def raise_on_invalid_option_type!(key, value, expected_class)
+          unless value.is_a?(expected_class)
+            raise(
+              GraphqlDevise::InvalidMountOptionsError,
+              "#{key} option contains value of invalid value. Value must be #{expected_class.name}."
+            )
+          end
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/option_validators/skip_only_validator.rb

@@ -0,0 +1,20 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionValidators
+      class SkipOnlyValidator
+        def initialize(options: {})
+          @options = options || {}
+        end
+
+        def validate!
+          if [@options[:skip], @options[:only]].all?(&:present?)
+            raise(
+              GraphqlDevise::InvalidMountOptionsError,
+              "Can't specify both `skip` and `only` options when mounting the route."
+            )
+          end
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/option_validators/supported_operations_validator.rb

@@ -0,0 +1,24 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionValidators
+      class SupportedOperationsValidator
+        def initialize(provided_operations: [], supported_operations: [], key:)
+          @provided_operations  = provided_operations
+          @supported_operations = supported_operations
+          @key                  = key
+        end
+
+        def validate!
+          unsupported_operations = @provided_operations - @supported_operations
+
+          if unsupported_operations.present?
+            raise(
+              GraphqlDevise::InvalidMountOptionsError,
+              "#{@key} option contains unsupported operations: \"#{unsupported_operations.join(', ')}\". Check for typos."
+            )
+          end
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/options_validator.rb

@@ -0,0 +1,16 @@
+require_relative 'option_validators/skip_only_validator'
+require_relative 'option_validators/provided_operations_validator'
+
+module GraphqlDevise
+  module MountMethod
+    class OptionsValidator
+      def initialize(validators = [])
+        @validators = validators
+      end
+
+      def validate!
+        @validators.each(&:validate!)
+      end
+    end
+  end
+end

lib/graphql_devise/rails/routes.rb

@@ -10,29 +10,35 @@ class Mapper
       :invitations
     ].freeze
 
-    def mount_graphql_devise_for(resource, opts = {})
-      custom_operations    = opts.fetch(:operations, {})
-      skipped_operations   = opts.fetch(:skip, [])
-      only_operations      = opts.fetch(:only, [])
-      additional_mutations = opts.fetch(:additional_mutations, {})
-      additional_queries   = opts.fetch(:additional_queries, {})
-      path                 = opts.fetch(:at, '/graphql_auth')
+    def mount_graphql_devise_for(resource, options = {})
+      default_operations = GraphqlDevise::DefaultOperations::MUTATIONS.merge(GraphqlDevise::DefaultOperations::QUERIES)
+
+      GraphqlDevise::MountMethod::OptionsValidator.new(
+        [
+          GraphqlDevise::MountMethod::OptionValidators::SkipOnlyValidator.new(options: options),
+          GraphqlDevise::MountMethod::OptionValidators::ProvidedOperationsValidator.new(
+            options: options, supported_operations: default_operations
+          )
+        ]
+      ).validate!
+
+      custom_operations    = options.fetch(:operations, {})
+      skipped_operations   = options.fetch(:skip, [])
+      only_operations      = options.fetch(:only, [])
+      additional_mutations = options.fetch(:additional_mutations, {})
+      additional_queries   = options.fetch(:additional_queries, {})
+      path                 = options.fetch(:at, '/graphql_auth')
       mapping_name         = resource.underscore.tr('/', '_').to_sym
-      authenticatable_type = opts[:authenticatable_type].presence ||
-        "Types::#{resource}Type".safe_constantize ||
-        GraphqlDevise::Types::AuthenticatableType
-      param_operations     = {
+      authenticatable_type = options[:authenticatable_type].presence ||
+                             "Types::#{resource}Type".safe_constantize ||
+                             GraphqlDevise::Types::AuthenticatableType
+
+      param_operations = {
         custom:  custom_operations,
         only:    only_operations,
         skipped: skipped_operations
       }
 
-      GraphqlDevise::OperationChecker.call(
-        mutations: GraphqlDevise::DefaultOperations::MUTATIONS,
-        queries:   GraphqlDevise::DefaultOperations::QUERIES,
-        **param_operations
-      )
-
       devise_for(
         resource.pluralize.underscore.tr('/', '_').to_sym,
         module:     :devise,
@@ -61,7 +67,7 @@ def mount_graphql_devise_for(resource, opts = {})
       end
 
       if (prepared_mutations.present? || additional_mutations.present?) &&
-          (Gem::Version.new(GraphQL::VERSION) <= Gem::Version.new('1.10.0') || GraphqlDevise::Schema.mutation.nil?)
+         (Gem::Version.new(GraphQL::VERSION) <= Gem::Version.new('1.10.0') || GraphqlDevise::Schema.mutation.nil?)
         GraphqlDevise::Schema.mutation(GraphqlDevise::Types::MutationType)
       end
 

spec/services/mount_method/option_validators/provided_operations_validator_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionValidators::ProvidedOperationsValidator do
+  describe '#validate!' do
+    subject { -> { described_class.new(options: provided_operations, supported_operations: supported_operations).validate! } }
+
+    let(:supported_operations) { { operation1: 'irrelevant', operation2: 'irrelevant', operation3: 'irrelevant' } }
+
+    context 'when skip option is provided' do
+      let(:provided_operations) { { skip: skipped } }
+
+      context 'when all skipped are supported' do
+        let(:skipped) { [:operation2, :operation3] }
+
+        it { is_expected.not_to raise_error }
+      end
+
+      context 'when skipped contains unsupported operations' do
+        let(:skipped) { [:operation2, :operation3, :invalid] }
+
+        it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'skip option contains unsupported operations: "invalid". Check for typos.') }
+      end
+
+      context 'when provided skip value is not an array' do
+        let(:skipped) { 'Invalid value' }
+
+        it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'skip option contains value of invalid value. Value must be Array.') }
+      end
+    end
+
+    context 'when only option is provided' do
+      let(:provided_operations) { { only: only } }
+
+      context 'when all only are supported' do
+        let(:only) { [:operation2, :operation3] }
+
+        it { is_expected.not_to raise_error }
+      end
+
+      context 'when only contains unsupported operations' do
+        let(:only) { [:operation2, :operation3, :invalid] }
+
+        it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'only option contains unsupported operations: "invalid". Check for typos.') }
+      end
+
+      context 'when provided only value is not an array' do
+        let(:only) { 'Invalid value' }
+
+        it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'only option contains value of invalid value. Value must be Array.') }
+      end
+    end
+
+    context 'when operations option is provided' do
+      let(:provided_operations) { { operations: operations } }
+
+      context 'when all operations are supported' do
+        let(:operations) { { operation2: 'irrelevant', operation3: 'irrelevant' } }
+
+        it { is_expected.not_to raise_error }
+      end
+
+      context 'when operations contains unsupported operations' do
+        let(:operations) { { operation2: 'irrelevant', operation3: 'irrelevant', invalid: 'invalid' } }
+
+        it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'operations option contains unsupported operations: "invalid". Check for typos.') }
+      end
+
+      context 'when provided operations value is not a hash' do
+        let(:operations) { [:one, :two, :three] }
+
+        it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'operations option contains value of invalid value. Value must be Hash.') }
+      end
+    end
+  end
+end

spec/services/mount_method/option_validators/skip_only_validator_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionValidators::SkipOnlyValidator do
+  describe '#validate!' do
+    subject { -> { described_class.new(options: options).validate! } }
+
+    context 'when only `only` key is set' do
+      let(:options) { { only: 'Irrelevant value' } }
+
+      it { is_expected.not_to raise_error }
+    end
+
+    context 'when only `skip` key is set' do
+      let(:options) { { skip: 'Irrelevant value' } }
+
+      it { is_expected.not_to raise_error }
+    end
+
+    context 'when `skip` and `only` keys are set' do
+      let(:options) { { only: 'Irrelevant value', skip: 'irrelevant for specs' } }
+
+      it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, "Can't specify both `skip` and `only` options when mounting the route.") }
+    end
+
+    context 'when neither `skip` nor `only are set`' do
+      let(:options) { { irrelevant_option: 'Irrelevant value', another_option: 'irrelevant for specs' } }
+
+      it { is_expected.not_to raise_error }
+    end
+  end
+end

spec/services/mount_method/option_validators/supported_operations_validator_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionValidators::SupportedOperationsValidator do
+  describe '#validate!' do
+    subject { -> { described_class.new(provided_operations: provided_operations, supported_operations: supported_operations, key: key).validate! } }
+
+    let(:supported_operations) { [:operation1, :operation2, :operation3] }
+    let(:key)                  { :only }
+
+    context 'when custom operations are all supported' do
+      let(:provided_operations) { [:operation2, :operation3] }
+
+      it { is_expected.not_to raise_error }
+    end
+
+    context 'when no operations are provided' do
+      let(:provided_operations) { [] }
+
+      it { is_expected.not_to raise_error }
+    end
+
+    context 'when default_operations are empty' do
+      let(:supported_operations) { [] }
+      let(:provided_operations) { [:invalid] }
+
+      it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'only option contains unsupported operations: "invalid". Check for typos.') }
+    end
+
+    context 'when not all custom operations are supported' do
+      let(:provided_operations) { [:operation2, :operation3, :unsupported] }
+
+      it { is_expected.to raise_error(GraphqlDevise::InvalidMountOptionsError, 'only option contains unsupported operations: "unsupported". Check for typos.') }
+    end
+  end
+end