graphql_devise 0.10.1 → 0.11.0

data/spec/services/mount_method/operation_preparers/default_operation_preparer_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::DefaultOperationPreparer do
+  describe '#call' do
+    subject(:prepared) { default_preparer.call }
+
+    let(:default_preparer)  { described_class.new(selected_operations: operations, custom_keys: custom_keys, mapping_name: mapping_name, preparer: preparer) }
+    let(:confirm_operation) { double(:confirm_operation, graphql_name: nil) }
+    let(:sign_up_operation) { double(:sign_up_operation, graphql_name: nil) }
+    let(:login_operation)   { double(:confirm_operation, graphql_name: nil) }
+    let(:logout_operation)  { double(:sign_up_operation, graphql_name: nil) }
+    let(:mapping_name)      { 'user' }
+    let(:preparer)          { double(:preparer) }
+    let(:operations)        { { login: login_operation, logout: logout_operation, sign_up: sign_up_operation, confirm: confirm_operation } }
+    let(:custom_keys)       { [:login, :logout] }
+
+    before do
+      allow(default_preparer).to receive(:child_class).with(confirm_operation).and_return(confirm_operation)
+      allow(default_preparer).to receive(:child_class).with(sign_up_operation).and_return(sign_up_operation)
+      allow(default_preparer).to receive(:child_class).with(login_operation).and_return(login_operation)
+      allow(default_preparer).to receive(:child_class).with(logout_operation).and_return(logout_operation)
+      allow(preparer).to receive(:call).with(confirm_operation).and_return(confirm_operation)
+      allow(preparer).to receive(:call).with(sign_up_operation).and_return(sign_up_operation)
+      allow(preparer).to receive(:call).with(login_operation).and_return(login_operation)
+      allow(preparer).to receive(:call).with(logout_operation).and_return(logout_operation)
+    end
+
+    it 'returns only those operations with no custom operation provided' do
+      expect(prepared.keys).to contain_exactly(:user_sign_up, :user_confirm)
+    end
+
+    it 'prepares default operations' do
+      expect(confirm_operation).to receive(:graphql_name).with('UserConfirm')
+      expect(sign_up_operation).to receive(:graphql_name).with('UserSignUp')
+      expect(preparer).to receive(:call).with(confirm_operation)
+      expect(preparer).to receive(:call).with(sign_up_operation)
+
+      prepared
+
+      expect(confirm_operation.instance_variable_get(:@resource_name)).to eq(:user)
+      expect(sign_up_operation.instance_variable_get(:@resource_name)).to eq(:user)
+    end
+
+    context 'when no custom keys are provided' do
+      let(:custom_keys) { [] }
+
+      it 'returns all selected operations' do
+        expect(prepared.keys).to contain_exactly(:user_sign_up, :user_confirm, :user_login, :user_logout)
+      end
+    end
+
+    context 'when no selected operations are provided' do
+      let(:operations) { {} }
+
+      it 'returns all selected operations' do
+        expect(prepared.keys).to eq([])
+      end
+    end
+  end
+end

data/spec/services/mount_method/operation_preparers/gql_name_setter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::GqlNameSetter do
+  describe '#call' do
+    subject(:prepared_operation) { described_class.new(mapping_name).call(operation) }
+
+    let(:operation)    { double(:operation) }
+    let(:mapping_name) { 'user_login' }
+
+    it 'sets a gql name to the operation' do
+      expect(operation).to receive(:graphql_name).with('UserLogin')
+
+      prepared_operation
+    end
+  end
+end

data/spec/services/mount_method/operation_preparers/mutation_field_setter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::MutationFieldSetter do
+  describe '#call' do
+    subject(:prepared_operation) { described_class.new(field_type).call(operation) }
+
+    let(:operation)  { double(:operation) }
+    let(:field_type) { double(:type) }
+
+    it 'sets a field for the mutation' do
+      expect(operation).to receive(:field).with(:authenticatable, field_type, null: false)
+
+      prepared_operation
+    end
+  end
+end

data/spec/services/mount_method/operation_preparers/resolver_type_setter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::ResolverTypeSetter do
+  describe '#call' do
+    subject(:prepared_operation) { described_class.new(field_type).call(operation) }
+
+    let(:operation)  { double(:operation) }
+    let(:field_type) { double(:type) }
+
+    it 'sets a field for the mutation' do
+      expect(operation).to receive(:type).with(field_type, null: false)
+
+      prepared_operation
+    end
+  end
+end

data/spec/services/mount_method/operation_preparers/resource_name_setter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::ResourceNameSetter do
+  describe '#call' do
+    subject(:prepared_operation) { described_class.new(mapping_name).call(operation) }
+
+    let(:operation)    { double(:operation) }
+    let(:mapping_name) { 'user' }
+
+    it 'sets a gql name to the operation' do
+      expect(prepared_operation.instance_variable_get(:@resource_name)).to eq(:user)
+    end
+  end
+end

data/spec/services/mount_method/operation_sanitizer_spec.rb

@@ -0,0 +1,33 @@
+require 'rails_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationSanitizer do
+  describe '.call' do
+    subject { described_class.call(default: default, only: only, skipped: skipped) }
+
+    let(:op_class1) { Class.new }
+    let(:op_class2) { Class.new }
+    let(:op_class3) { Class.new }
+
+    context 'when the operations passed are mutations' do
+      let(:skipped)  { [] }
+      let(:only)     { [] }
+      let(:default)  { { operation1: op_class1, operation2: op_class2 } }
+
+      context 'when no other option besides default is passed' do
+        it { is_expected.to eq(default) }
+      end
+
+      context 'when there are only operations' do
+        let(:only) { [:operation1] }
+
+        it { is_expected.to eq(operation1: op_class1) }
+      end
+
+      context 'when there are skipped operations' do
+        let(:skipped) { [:operation2] }
+
+        it { is_expected.to eq(operation1: op_class1) }
+      end
+    end
+  end
+end

data/spec/services/mount_method/option_sanitizer_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionSanitizer do
+  subject(:clean_options) { described_class.new(options, supported_options).call! }
+
+  describe '#call!' do
+    let(:supported_options) do
+      {
+        my_string:     GraphqlDevise::MountMethod::OptionSanitizers::StringChecker.new('default string'),
+        hash_multiple: GraphqlDevise::MountMethod::OptionSanitizers::HashChecker.new([String, Numeric]),
+        array:         GraphqlDevise::MountMethod::OptionSanitizers::ArrayChecker.new(Symbol),
+        hash_single:   GraphqlDevise::MountMethod::OptionSanitizers::HashChecker.new(Float),
+        my_class:      GraphqlDevise::MountMethod::OptionSanitizers::ClassChecker.new(Numeric)
+      }
+    end
+
+    context 'when all options are provided and correct' do
+      let(:options) do
+        {
+          my_string:     'non default',
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          hash_single:   { first: Float, second: Float },
+          my_class:      Float
+        }
+      end
+
+      it 'returns a struct with clean options' do
+        expect(
+          my_string:     clean_options.my_string,
+          hash_multiple: clean_options.hash_multiple,
+          array:         clean_options.array,
+          hash_single:   clean_options.hash_single,
+          my_class:      clean_options.my_class
+        ).to match(
+          my_string:     'non default',
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          hash_single:   { first: Float, second: Float },
+          my_class:      Float
+        )
+      end
+    end
+
+    context 'when some options are provided but all correct' do
+      let(:options) do
+        {
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          my_class:      Float
+        }
+      end
+
+      it 'returns a struct with clean options and default values' do
+        expect(
+          my_string:     clean_options.my_string,
+          hash_multiple: clean_options.hash_multiple,
+          array:         clean_options.array,
+          hash_single:   clean_options.hash_single,
+          my_class:      clean_options.my_class
+        ).to match(
+          my_string:     'default string',
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          hash_single:   {},
+          my_class:      Float
+        )
+      end
+    end
+
+    context 'when an option provided is invalid' do
+      let(:options) do
+        {
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         ['not symbol 1', 'not symbol 2'],
+          my_class:      Float
+        }
+      end
+
+      it 'raises an error' do
+        expect { clean_options }.to raise_error(GraphqlDevise::InvalidMountOptionsError, '`array` option has invalid elements. Symbol expected.')
+      end
+    end
+  end
+end

data/spec/services/mount_method/option_sanitizers/array_checker_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionSanitizers::ArrayChecker do
+  describe '#call!' do
+    subject(:clean_value) { described_class.new(element_type).call!(value, key) }
+
+    let(:key)          { :any_option }
+    let(:element_type) { Symbol }
+
+    context 'when no value is provided' do
+      let(:value) { nil }
+
+      it { is_expected.to eq([]) }
+    end
+
+    context 'when provided value is not an array' do
+      let(:value) { 'not an array' }
+
+      it 'raises an error' do
+        expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. Array expected.")
+      end
+    end
+
+    context 'when provided array contains invalid elements' do
+      let(:value) { [:valid, 'invalid'] }
+
+      it 'raises an error' do
+        expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has invalid elements. #{element_type} expected.")
+      end
+    end
+
+    context 'when provided array contains all valid elements' do
+      let(:value) { [:valid1, :valid2] }
+
+      it { is_expected.to eq(value) }
+    end
+  end
+end

data/spec/services/mount_method/option_sanitizers/class_checker_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionSanitizers::ClassChecker do
+  describe '#call!' do
+    subject(:clean_value) { described_class.new(expected_class).call!(value, key) }
+
+    let(:key)            { :any_option }
+    let(:expected_class) { Numeric }
+
+    context 'when no value is provided' do
+      let(:value) { nil }
+
+      it { is_expected.to eq(nil) }
+    end
+
+    context 'when provided value is not a class' do
+      let(:value) { 'I\'m not a class' }
+
+      it 'raises an error' do
+        expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. Class expected.")
+      end
+    end
+
+    context 'when provided class is not of the expected type' do
+      let(:value) { String }
+
+      it 'raises an error' do
+        expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. #{expected_class} or descendants expected. Got String.")
+      end
+    end
+
+    context 'when provided class is of the expected type' do
+      let(:value) { Numeric }
+
+      it { is_expected.to eq(value) }
+    end
+
+    context 'when provided class has the expected type as an acestor' do
+      let(:value) { Float }
+
+      it { is_expected.to eq(value) }
+    end
+  end
+end

data/spec/services/mount_method/option_sanitizers/hash_checker_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionSanitizers::HashChecker do
+  describe '#call!' do
+    subject(:clean_value) { described_class.new(element_type).call!(value, key) }
+
+    let(:key) { :any_option }
+
+    context 'when a single valid type is provided' do
+      let(:element_type) { Numeric }
+
+      context 'when no value is provided' do
+        let(:value) { nil }
+
+        it { is_expected.to eq({}) }
+      end
+
+      context 'when provided value is not a hash' do
+        let(:value) { 'not a hash' }
+
+        it 'raises an error' do
+          expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. Hash expected. Got String.")
+        end
+      end
+
+      context 'when provided hash contains invalid elements' do
+        let(:value) { { valid: Float, invalid: String } }
+
+        it 'raises an error' do
+          expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key} -> invalid` option has an invalid value. #{element_type} or descendants expected. Got #{String}.")
+        end
+      end
+
+      context 'when provided array contains all valid elements' do
+        let(:value) { { valid1: Numeric, valid2: Numeric } }
+
+        it { is_expected.to eq(value) }
+      end
+
+      context 'when provided class has the expected type as an acestor' do
+        let(:value) { { valid: Float } }
+
+        it { is_expected.to eq(value) }
+      end
+    end
+
+    context 'when multiple value types are allowed' do
+      let(:element_type) { [String, Numeric] }
+
+      context 'when no value is provided' do
+        let(:value) { nil }
+
+        it { is_expected.to eq({}) }
+      end
+
+      context 'when provided array contains all valid elements' do
+        let(:value) { { valid1: String, valid2: Numeric } }
+
+        it { is_expected.to eq(value) }
+      end
+
+      context 'when provided class has the expected type as an acestor' do
+        let(:value) { { valid: Float } }
+
+        it { is_expected.to eq(value) }
+      end
+
+      context 'when provided value is not a hash' do
+        let(:value) { 'not a hash' }
+
+        it 'raises an error' do
+          expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. Hash expected. Got String.")
+        end
+      end
+
+      context 'when provided hash contains invalid elements' do
+        let(:value) { { valid: String, invalid: StandardError } }
+
+        it 'raises an error' do
+          expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key} -> invalid` option has an invalid value. #{element_type.join(', ')} or descendants expected. Got #{StandardError}.")
+        end
+      end
+    end
+  end
+end

data/spec/services/mount_method/option_sanitizers/string_checker_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionSanitizers::StringChecker do
+  describe '#call!' do
+    subject(:clean_value) { described_class.new(default_string).call!(value, key) }
+
+    let(:key)            { :any_option }
+    let(:default_string) { 'default string' }
+
+    context 'when no value is provided' do
+      let(:value) { nil }
+
+      it { is_expected.to eq(default_string) }
+    end
+
+    context 'when provided value is not a String' do
+      let(:value) { 1000 }
+
+      it 'raises an error' do
+        expect { clean_value }.to raise_error(GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. String expected.")
+      end
+    end
+
+    context 'when provided array contains all valid elements' do
+      let(:value) { 'custom valid string' }
+
+      it { is_expected.to eq(value) }
+    end
+  end
+end