Handle errors in filmRate

Author: cjoudrey

app/controllers/graphql_controller.rb

@@ -2,6 +2,9 @@ class GraphqlController < ApplicationController
   before_action :authenticate
 
   def execute
+    context = {
+      user: @user,
+    }
     query_string = params[:query].to_s
     variables = ensure_hash(params[:variables])
     context = {

app/models/graph.rb

@@ -5,14 +5,21 @@ def find_by_id_field(type, model)
         type type
         argument :id, !types.ID
         resolve ->(_, args, _) do
-          gid = GlobalID.parse(args[:id])
+          model_id = Graph.parse_id(args[:id], model)
 
-          return unless gid
-          return unless gid.model_name == type.name
-
-          Graph::FindLoader.for(model).load(gid.model_id.to_i)
+          Graph::FindLoader.for(model).load(model_id)
         end
       end
     end
+
+    def parse_id(gid, model)
+      parsed_gid = GlobalID.parse(gid)
+
+      return unless parsed_gid
+      return unless parsed_gid.app == GlobalID.app
+      return unless parsed_gid.model_name != model.name.downcase
+
+      parsed_gid.model_id.to_i
+    end
   end
 end

app/models/graph/mutations/film_rate.rb

@@ -7,27 +7,27 @@ module Mutations
       input_field :rating, !types.Int
 
       return_field :film, Graph::Types::Film
+      return_field :errors, !types[!Graph::Types::MutationError]
 
       resolve ->(_, input, ctx) do
-        # TODO auth error
-        return unless user = ctx[:user]
+        raise GraphQL::ExecutionError.new('Authentication required to rate a film.') unless user = ctx[:user]
 
-        # TODO user error
-        return unless film = Film.find_by(id: input["filmId"])
+        film_id = Graph.parse_id(input['filmId'], Film)
+        film = Film.find_by(id: film_id) if film_id
+        raise GraphQL::ExecutionError.new('Invalid filmId.') unless film
 
-        rating = user.ratings.build(
-          film: film,
-          rating: input["rating"]
-        )
+        rating = user.ratings.where(film: film).first_or_initialize
+        rating.rating = input['rating']
 
         if rating.save
           {
-            film: film
+            film: film,
+            errors: []
           }
         else
-          # TODO add user errors
           {
-            film: film
+            film: film,
+            errors: rating.errors.map { |field, message| MutationError.new(field, message) },
           }
         end
       end

app/models/graph/mutations/mutation_error.rb

@@ -0,0 +1,6 @@
+module Graph
+  module Mutations
+    class MutationError < Struct.new(:field, :message)
+    end
+  end
+end

app/models/graph/schema.rb

@@ -13,6 +13,8 @@ module Graph
 
     object_from_id ->(id, query_ctx) do
       gid = GlobalID.parse(id)
+      return unless gid
+
       possible_types = query_ctx.warden.possible_types(GraphQL::Relay::Node.interface)
 
       return unless possible_types.map(&:name).include?(gid.model_name)

app/models/graph/types/mutation_error.rb

@@ -0,0 +1,10 @@
+module Graph
+  module Types
+    MutationError = GraphQL::ObjectType.define do
+      name "MutationError"
+
+      field :field, !types.String, "The name of the input field that caused the error."
+      field :message, !types.String, "The description of the error."
+    end
+  end
+end

app/models/rating.rb

@@ -2,5 +2,5 @@ class Rating < ApplicationRecord
   belongs_to :user
   belongs_to :film
 
-  validates_inclusion_of :rating, in: 0..5
+  validates :rating, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 5 }
 end

test/models/graph/mutations/film_rate_test.rb

@@ -0,0 +1,126 @@
+require 'test_helper'
+
+class Graph::Mutations::FilmRateTest < ActiveSupport::TestCase
+  def setup
+    @context = {
+      user: @user = User.first
+    }
+
+    @query_string = "
+      mutation ($input: FilmRateInput!) {
+        filmRate(input: $input) {
+          film {
+            title
+          }
+          errors {
+            field
+            message
+          }
+        }
+      }
+    "
+
+    @film = Film.first
+
+    @variables = {
+      "input" => {
+        "filmId" => @film.to_global_id.to_s,
+        "rating" => 5,
+      }
+    }
+  end
+
+  test "raises an execution error when user is not logged in" do
+    expected = {
+      "data" => { "filmRate" => nil},
+      "errors" => [{
+        "message" => "Authentication required to rate a film.",
+        "locations" => [{ "line" => 3, "column" => 9}],
+        "path" => ["filmRate"]}
+      ]
+    }
+
+    result = Graph::Schema.execute(@query_string, variables: @variables, context: {})
+    assert_equal expected, result
+  end
+
+  test "raises an execution error when filmId is invalid" do
+    @variables['input']['filmId'] = 'invalid'
+    expected = {
+      "data" => { "filmRate" => nil},
+      "errors" => [{
+        "message" => "Invalid filmId.",
+        "locations" => [{ "line" => 3, "column" => 9}],
+        "path" => ["filmRate"]}
+      ]
+    }
+
+    result = Graph::Schema.execute(@query_string, variables: @variables, context: @context)
+    assert_equal expected, result
+  end
+
+  test "returns error when an invalid rating is inputted" do
+    @variables['input']['rating'] = 100
+    expected = {
+      "data" => {
+        "filmRate" => {
+          "film" => {
+            "title" => @film.title
+          },
+          "errors" => [
+            { "field" => "rating", "message" => "must be less than or equal to 5" }
+          ]
+        }
+      }
+    }
+
+    result = Graph::Schema.execute(@query_string, variables: @variables, context: @context)
+    assert_equal expected, result
+  end
+
+  test "creates a new rating on success" do
+    expected = {
+      "data" => {
+        "filmRate" => {
+          "film" => {
+            "title" => @film.title
+          },
+          "errors" => [],
+        }
+      }
+    }
+
+    assert_difference "Rating.count", 1 do
+      result = Graph::Schema.execute(@query_string, variables: @variables, context: @context)
+      assert_equal expected, result
+    end
+
+    rating = Rating.last
+    assert_equal @film, rating.film
+    assert_equal @variables['input']['rating'], rating.rating
+    assert_equal @user, rating.user
+  end
+
+  test "updates existing rating if user already rated film" do
+    expected = {
+      "data" => {
+        "filmRate" => {
+          "film" => {
+            "title" => @film.title
+          },
+          "errors" => [],
+        }
+      }
+    }
+
+    rating = @user.ratings.create(film: @film, rating: 1)
+
+    assert_difference "Rating.count", 0 do
+      result = Graph::Schema.execute(@query_string, variables: @variables, context: @context)
+      assert_equal expected, result
+    end
+
+    rating.reload
+    assert_equal @variables['input']['rating'], rating.rating
+  end
+end