graphql_devise 0.11.4 → 0.12.0

data/spec/rails_helper.rb

@@ -38,7 +38,6 @@ RSpec.configure do |config|
   config.include(Requests::JsonHelpers, type: :request)
   config.include(Requests::AuthHelpers, type: :request)
   config.include(ActiveSupport::Testing::TimeHelpers)
-  config.include(Generators::FileHelpers, type: :generator)
 
   config.before(:suite) do
     ActionController::Base.allow_forgery_protection = true

data/spec/requests/graphql_controller_spec.rb

@@ -0,0 +1,80 @@
+require 'rails_helper'
+
+RSpec.describe GraphqlDevise::GraphqlController do
+  let(:password) { 'password123' }
+  let(:user)     { create(:user, :confirmed, password: password) }
+  let(:params)   { { query: query, variables: variables } }
+  let(:request_params) do
+    if Rails::VERSION::MAJOR >= 5
+      { params: params }
+    else
+      params
+    end
+  end
+
+  context 'when variables are a string' do
+    let(:variables) { "{\"email\": \"#{user.email}\"}" }
+    let(:query)     { "mutation($email: String!) { userLogin(email: $email, password: \"#{password}\") { user { email name signInCount } } }" }
+
+    it 'parses the string variables' do
+      post '/api/v1/graphql_auth', request_params
+
+      expect(json_response).to match(
+        data: { userLogin: { user: { email: user.email, name: user.name, signInCount: 1 } } }
+      )
+    end
+
+    context 'when variables is an empty string' do
+      let(:variables) { '' }
+      let(:query)     { "mutation { userLogin(email: \"#{user.email}\", password: \"#{password}\") { user { email name signInCount } } }" }
+
+      it 'returns an empty hash as variables' do
+        post '/api/v1/graphql_auth', request_params
+
+        expect(json_response).to match(
+          data: { userLogin: { user: { email: user.email, name: user.name, signInCount: 1 } } }
+        )
+      end
+    end
+  end
+
+  context 'when variables are not a string or hash' do
+    let(:variables) { 1 }
+    let(:query)     { "mutation($email: String!) { userLogin(email: $email, password: \"#{password}\") { user { email name signInCount } } }" }
+
+    it 'raises an error' do
+      expect do
+        post '/api/v1/graphql_auth', request_params
+      end.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when multiplexing queries' do
+    let(:params) do
+      {
+        _json: [
+          { query: "mutation { userLogin(email: \"#{user.email}\", password: \"#{password}\") { user { email name signInCount } } }" },
+          { query: "mutation { userLogin(email: \"#{user.email}\", password: \"wrong password\") { user { email name signInCount } } }" }
+        ]
+      }
+    end
+
+    it 'executes multiple queries in the same request' do
+      post '/api/v1/graphql_auth', request_params
+
+      expect(json_response).to match(
+        [
+          { data: { userLogin: { user: { email: user.email, name: user.name, signInCount: 1 } } } },
+          {
+            data:   { userLogin: nil },
+            errors: [
+              hash_including(
+                message: 'Invalid login credentials. Please try again.', extensions: { code: 'USER_ERROR' }
+              )
+            ]
+          }
+        ]
+      )
+    end
+  end
+end

data/spec/requests/user_controller_spec.rb

@@ -1,40 +1,196 @@
 require 'rails_helper'
 
-RSpec.describe 'Integrations with the user controller' do
+RSpec.describe "Integrations with the user's controller" do
   include_context 'with graphql query request'
 
   let(:user) { create(:user, :confirmed) }
-  let(:query) do
-    <<-GRAPHQL
-      query {
-        user(
-          id: #{user.id}
-        ) {
-          id
-          email
+
+  describe 'publicField' do
+    let(:query) do
+      <<-GRAPHQL
+        query {
+          publicField
+        }
+      GRAPHQL
+    end
+
+    context 'when using a regular schema' do
+      before { post_request('/api/v1/graphql') }
+
+      it 'does not require authentication' do
+        expect(json_response[:data][:publicField]).to eq('Field does not require authentication')
+      end
+    end
+
+    context 'when using an interpreter schema' do
+      before { post_request('/api/v1/interpreter') }
+
+      it 'does not require authentication' do
+        expect(json_response[:data][:publicField]).to eq('Field does not require authentication')
+      end
+    end
+  end
+
+  describe 'privateField' do
+    let(:query) do
+      <<-GRAPHQL
+        query {
+          privateField
         }
-      }
-    GRAPHQL
+      GRAPHQL
+    end
+
+    context 'when using a regular schema' do
+      before { post_request('/api/v1/graphql') }
+
+      context 'when user is authenticated' do
+        let(:headers) { user.create_new_auth_token }
+
+        it 'allow to perform the query' do
+          expect(json_response[:data][:privateField]).to eq('Field will always require authentication')
+        end
+      end
+
+      context 'when user is not authenticated' do
+        it 'returns a must sign in error' do
+          expect(json_response[:errors]).to contain_exactly(
+            hash_including(message: 'privateField field requires authentication', extensions: { code: 'USER_ERROR' })
+          )
+        end
+      end
+    end
+
+    context 'when using an interpreter schema' do
+      before { post_request('/api/v1/interpreter') }
+
+      context 'when user is authenticated' do
+        let(:headers) { user.create_new_auth_token }
+
+        it 'allow to perform the query' do
+          expect(json_response[:data][:privateField]).to eq('Field will always require authentication')
+        end
+      end
+
+      context 'when user is not authenticated' do
+        it 'returns a must sign in error' do
+          expect(json_response[:errors]).to contain_exactly(
+            hash_including(message: 'privateField field requires authentication', extensions: { code: 'USER_ERROR' })
+          )
+        end
+      end
+    end
   end
 
-  before { post_request('/api/v1/graphql') }
+  describe 'dummyMutation' do
+    let(:query) do
+      <<-GRAPHQL
+        mutation {
+          dummyMutation
+        }
+      GRAPHQL
+    end
+
+    context 'when using a regular schema' do
+      before { post_request('/api/v1/graphql') }
+
+      context 'when user is authenticated' do
+        let(:headers) { user.create_new_auth_token }
 
-  context 'when user is authenticated' do
-    let(:headers) { user.create_new_auth_token }
+        it 'allow to perform the query' do
+          expect(json_response[:data][:dummyMutation]).to eq('Necessary so GraphQL gem does not complain about empty mutation type')
+        end
+      end
 
-    it 'allow to perform the query' do
-      expect(json_response[:data][:user]).to match(
-        email: user.email,
-        id:    user.id
-      )
+      context 'when user is not authenticated' do
+        it 'returns a must sign in error' do
+          expect(json_response[:errors]).to contain_exactly(
+            hash_including(message: 'dummyMutation field requires authentication', extensions: { code: 'USER_ERROR' })
+          )
+        end
+      end
+    end
+
+    context 'when using an interpreter schema' do
+      before { post_request('/api/v1/interpreter') }
+
+      context 'when user is authenticated' do
+        let(:headers) { user.create_new_auth_token }
+
+        it 'allow to perform the query' do
+          expect(json_response[:data][:dummyMutation]).to eq('Necessary so GraphQL gem does not complain about empty mutation type')
+        end
+      end
+
+      context 'when user is not authenticated' do
+        it 'returns a must sign in error' do
+          expect(json_response[:errors]).to contain_exactly(
+            hash_including(message: 'dummyMutation field requires authentication', extensions: { code: 'USER_ERROR' })
+          )
+        end
+      end
     end
   end
 
-  context 'when user is not authenticated' do
-    it 'returns a must sign in error' do
-      expect(json_response[:errors]).to contain_exactly(
-        'You need to sign in or sign up before continuing.'
-      )
+  describe 'user' do
+    let(:query) do
+      <<-GRAPHQL
+        query {
+          user(
+            id: #{user.id}
+          ) {
+            id
+            email
+          }
+        }
+      GRAPHQL
+    end
+
+    context 'when using a regular schema' do
+      before { post_request('/api/v1/graphql') }
+
+      context 'when user is authenticated' do
+        let(:headers) { user.create_new_auth_token }
+
+        it 'allow to perform the query' do
+          expect(json_response[:data][:user]).to match(
+            email: user.email,
+            id:    user.id
+          )
+        end
+      end
+
+      context 'when user is not authenticated' do
+        it 'returns a must sign in error' do
+          expect(json_response[:errors]).to contain_exactly(
+            hash_including(message: 'user field requires authentication', extensions: { code: 'USER_ERROR' })
+          )
+        end
+      end
+    end
+
+    context 'when using an interpreter schema' do
+      before { post_request('/api/v1/interpreter') }
+
+      context 'when user is authenticated' do
+        let(:headers) { user.create_new_auth_token }
+
+        it 'allow to perform the query' do
+          expect(json_response[:data][:user]).to match(
+            email: user.email,
+            id:    user.id
+          )
+        end
+      end
+
+      context 'when user is not authenticated' do
+        # Interpreter schema fields are public unless specified otherwise (plugin setting)
+        it 'allow to perform the query' do
+          expect(json_response[:data][:user]).to match(
+            email: user.email,
+            id:    user.id
+          )
+        end
+      end
     end
   end
 end

data/spec/services/mount_method/operation_preparer_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe GraphqlDevise::MountMethod::OperationPreparer do
   describe '#call' do
     subject(:prepared_operations) do
       described_class.new(
-        resource:              resource,
+        mapping_name:          mapping,
         selected_operations:   selected,
         preparer:              preparer,
         custom:                custom,
@@ -13,7 +13,7 @@ RSpec.describe GraphqlDevise::MountMethod::OperationPreparer do
     end
 
     let(:logout_class) { Class.new(GraphQL::Schema::Resolver) }
-    let(:resource)     { 'User' }
+    let(:mapping)      { :user }
     let(:selected)     { { login: double(:login_default), logout: logout_class } }
     let(:preparer)     { double(:preparer, call: logout_class) }
     let(:custom)       { { login: double(:custom_login, graphql_name: nil) } }

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

@@ -6,7 +6,7 @@ RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::CustomOperationPr
 
     let(:login_operation)  { double(:confirm_operation, graphql_name: nil) }
     let(:logout_operation) { double(:sign_up_operation, graphql_name: nil) }
-    let(:mapping_name)     { 'user' }
+    let(:mapping_name)     { :user }
     let(:operations)       { { login: login_operation, logout: logout_operation, invalid: double(:invalid) } }
     let(:selected_keys)    { [:login, :logout, :sign_up, :confirm] }
 

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

@@ -9,7 +9,7 @@ RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::DefaultOperationP
     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(: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] }

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

@@ -5,7 +5,7 @@ RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::ResourceNameSette
     subject(:prepared_operation) { described_class.new(mapping_name).call(operation) }
 
     let(:operation)    { double(:operation) }
-    let(:mapping_name) { 'user' }
+    let(:mapping_name) { :user }
 
     it 'sets a gql name to the operation' do
       expect(prepared_operation.instance_variable_get(:@resource_name)).to eq(:user)

data/spec/services/resource_loader_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::ResourceLoader do
+  describe '#call' do
+    subject(:loader) { described_class.new(resource, options, routing).call(query, mutation) }
+
+    let(:query)    { class_double(GraphQL::Schema::Object) }
+    let(:mutation) { class_double(GraphQL::Schema::Object) }
+    let(:routing)  { false }
+    let(:mounted)  { false }
+    let(:resource) { 'User' }
+    let(:options)  { { only: [:login, :confirm_account] } }
+
+    before do
+      allow(GraphqlDevise).to receive(:add_mapping).with(:user, resource)
+      allow(GraphqlDevise).to receive(:resource_mounted?).with(:user).and_return(mounted)
+      allow(GraphqlDevise).to receive(:mount_resource).with(:user)
+    end
+
+    it 'loads operations into the provided types' do
+      expect(query).to             receive(:field).with(:user_confirm_account, resolver: instance_of(Class), authenticate: false)
+      expect(mutation).to          receive(:field).with(:user_login, mutation: instance_of(Class), authenticate: false)
+      expect(GraphqlDevise).to     receive(:add_mapping).with(:user, resource)
+      expect(GraphqlDevise).not_to receive(:mount_resource)
+
+      returned = loader
+
+      expect(returned).to be_a(Struct)
+    end
+
+    context 'when mutation is nil' do
+      let(:mutation) { nil }
+
+      it 'raises an error' do
+        expect { loader }.to raise_error(
+          GraphqlDevise::Error,
+          'You need to provide a mutation type unless all mutations are skipped'
+        )
+      end
+    end
+
+    context 'when query is nil' do
+      let(:query) { nil }
+
+      before { allow(mutation).to receive(:field) }
+
+      it 'raises an error' do
+        expect { loader }.to raise_error(
+          GraphqlDevise::Error,
+          'You need to provide a query type unless all queries are skipped'
+        )
+      end
+    end
+
+    context 'when invoked from router' do
+      let(:routing) { true }
+
+      before do
+        allow(query).to    receive(:field)
+        allow(mutation).to receive(:field)
+      end
+
+      it 'adds mappings' do
+        expect(GraphqlDevise).to receive(:add_mapping).with(:user, resource)
+        expect(GraphqlDevise).to receive(:mount_resource).with(:user)
+
+        loader
+      end
+
+      context 'when resource was already mounted' do
+        before { allow(GraphqlDevise).to receive(:resource_mounted?).with(:user).and_return(true) }
+
+        it 'skips schema loading' do
+          expect(query).not_to         receive(:field)
+          expect(mutation).not_to      receive(:field)
+          expect(GraphqlDevise).not_to receive(:add_mapping).with(:user, resource)
+          expect(GraphqlDevise).not_to receive(:mount_resource)
+        end
+      end
+    end
+  end
+end

data/spec/services/schema_plugin_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::SchemaPlugin do
+  describe '#call' do
+    subject(:plugin) { described_class.new(query: query, mutation: mutation, resource_loaders: loaders) }
+
+    let(:query)    { instance_double(GraphQL::Schema::Object) }
+    let(:mutation) { instance_double(GraphQL::Schema::Object) }
+
+    context 'when loaders are not provided' do
+      let(:loaders) { [] }
+
+      it 'does not fail' do
+        expect { plugin }.not_to raise_error
+      end
+    end
+
+    context 'when a loaders is not an instance of loader' do
+      let(:loaders) { ['not a loader instance'] }
+
+      it 'raises an error' do
+        expect { plugin }.to raise_error(GraphqlDevise::Error, 'Invalid resource loader instance')
+      end
+    end
+  end
+end