graphql 1.9.0 → 2.1.1

data/spec/graphql/schema/scalar_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Scalar do
-  describe ".path" do
-    it "is the name" do
-      assert_equal "String", GraphQL::Types::String.path
-    end
-  end
-
-  describe "in queries" do
-    it "becomes output" do
-      query_str = <<-GRAPHQL
-      {
-        find(id: "Musician/Herbie Hancock") {
-          ... on Musician {
-            name
-            favoriteKey
-          }
-        }
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      assert_equal "B♭", res["data"]["find"]["favoriteKey"]
-    end
-
-    it "can be input" do
-      query_str = <<-GRAPHQL
-      {
-        inspectKey(key: "F♯") {
-          root
-          isSharp
-          isFlat
-        }
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      key_info = res["data"]["inspectKey"]
-      assert_equal "F", key_info["root"]
-      assert_equal true, key_info["isSharp"]
-      assert_equal false, key_info["isFlat"]
-    end
-
-    it "can be nested JSON" do
-      query_str = <<-GRAPHQL
-      {
-        echoJson(input: {foo: [{bar: "baz"}]})
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      assert_equal({"foo" => [{"bar" => "baz"}]}, res["data"]["echoJson"])
-    end
-
-    it "can be a JSON array" do
-      query_str = <<-GRAPHQL
-      {
-        echoFirstJson(input: [{foo: "bar"}, {baz: "boo"}])
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      assert_equal({"foo" => "bar"}, res["data"]["echoFirstJson"])
-    end
-
-    it "can be a JSON array even if the GraphQL type is not an array" do
-      query_str = <<-GRAPHQL
-      {
-        echoJson(input: [{foo: "bar"}])
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      assert_equal([{"foo" => "bar"}], res["data"]["echoJson"])
-    end
-
-    it "can be JSON with a nested enum" do
-      query_str = <<-GRAPHQL
-      {
-        echoJson(input: [{foo: WOODWIND}])
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      assert_equal([{"foo" => "WOODWIND"}], res["data"]["echoJson"])
-    end
-
-    it "cannot be JSON with a nested variable" do
-      query_str = <<-GRAPHQL
-      {
-        echoJson(input: [{foo: $var}])
-      }
-      GRAPHQL
-
-      res = Jazz::Schema.execute(query_str)
-      assert_includes(res["errors"][0]["message"], "Argument 'input' on Field 'echoJson' has an invalid value")
-    end
-  end
-end

data/spec/graphql/schema/subscription_spec.rb

@@ -1,416 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::Subscription do
-  class SubscriptionFieldSchema < GraphQL::Schema
-    TOOTS = []
-    ALL_USERS = {
-      "dhh" => {handle: "dhh", private: false},
-      "matz" => {handle: "matz", private: false},
-      "_why" => {handle: "_why", private: true},
-    }
-
-    USERS = {}
-
-    class User < GraphQL::Schema::Object
-      field :handle, String, null: false
-      field :private, Boolean, null: false
-    end
-
-    class Toot < GraphQL::Schema::Object
-      field :handle, String, null: false
-      field :body, String, null: false
-    end
-
-    class Query < GraphQL::Schema::Object
-      field :toots, [Toot], null: false
-
-      def toots
-        TOOTS
-      end
-    end
-
-    class BaseSubscription < GraphQL::Schema::Subscription
-    end
-
-    class TootWasTooted < BaseSubscription
-      argument :handle, String, required: true, loads: User, as: :user
-      field :toot, Toot, null: false
-      field :user, User, null: false
-      # Can't subscribe to private users
-      def authorized?(user:)
-        if user[:private]
-          raise GraphQL::ExecutionError, "Can't subscribe to private user"
-        else
-          true
-        end
-      end
-
-      def subscribe(user:)
-        if context[:prohibit_subscriptions]
-          raise GraphQL::ExecutionError, "You don't have permission to subscribe"
-        else
-          # Default is to return :no_response
-          super
-        end
-      end
-
-      def update(user:)
-        if context[:viewer] == user
-          # don't update for one's own toots.
-          # (IRL it would make more sense to implement this in `#subscribe`)
-          :no_update
-        else
-          # This assumes that trigger object can fulfill `{toot:, user:}`,
-          # for testing that the default implementation is `return object`
-          super
-        end
-      end
-    end
-
-    # Test initial response, which returns all users
-    class UsersJoined < BaseSubscription
-      class UsersJoinedManualPayload < GraphQL::Schema::Object
-        field :users, [User], null: true,
-          description: "Includes newly-created users, or all users on the initial load"
-      end
-
-      payload_type UsersJoinedManualPayload
-
-      def subscribe
-        { users: USERS.values }
-      end
-
-      # Test returning a custom object from #update
-      def update
-        { users: object[:new_users] }
-      end
-    end
-
-    class Subscription < GraphQL::Schema::Object
-      extend GraphQL::Subscriptions::SubscriptionRoot
-      field :toot_was_tooted, subscription: TootWasTooted
-      field :users_joined, subscription: UsersJoined
-    end
-
-    class Mutation < GraphQL::Schema::Object
-      field :toot, Toot, null: false do
-        argument :body, String, required: true
-      end
-
-      def toot(body:)
-        handle = context[:viewer][:handle]
-        toot = { handle: handle, body: body }
-        TOOTS << toot
-        SubscriptionFieldSchema.trigger(:toot_was_tooted, {handle: handle}, toot)
-      end
-    end
-
-    query(Query)
-    mutation(Mutation)
-    subscription(Subscription)
-    use GraphQL::Execution::Interpreter
-    use GraphQL::Analysis::AST
-
-    def self.object_from_id(id, ctx)
-      USERS[id]
-    end
-
-
-    class InMemorySubscriptions < GraphQL::Subscriptions
-      SUBSCRIPTION_REGISTRY = {}
-
-      EVENT_REGISTRY = Hash.new { |h, k| h[k] = [] }
-
-      def write_subscription(query, events)
-        query.context[:subscription_mailbox] = []
-        subscription_id = build_id
-        events.each do |ev|
-          EVENT_REGISTRY[ev.topic] << subscription_id
-        end
-        SUBSCRIPTION_REGISTRY[subscription_id] = [query, events]
-      end
-
-      def each_subscription_id(event)
-        EVENT_REGISTRY[event.topic].each do |sub_id|
-          yield(sub_id)
-        end
-      end
-
-      def read_subscription(subscription_id)
-        query, _events = SUBSCRIPTION_REGISTRY[subscription_id]
-        {
-          query_string: query.query_string,
-          context: query.context.to_h,
-          variables: query.provided_variables,
-          operation_name: query.selected_operation_name,
-        }
-      end
-
-      def deliver(subscription_id, result)
-        query, _events = SUBSCRIPTION_REGISTRY[subscription_id]
-        query.context[:subscription_mailbox] << result
-      end
-
-      def delete_subscription(subscription_id)
-        _query, events = SUBSCRIPTION_REGISTRY.delete(subscription_id)
-        events.each do |ev|
-          EVENT_REGISTRY[ev.topic].delete(subscription_id)
-        end
-      end
-    end
-
-    use InMemorySubscriptions
-  end
-
-  def exec_query(*args)
-    SubscriptionFieldSchema.execute(*args)
-  end
-
-  def in_memory_subscription_count
-    SubscriptionFieldSchema::InMemorySubscriptions::SUBSCRIPTION_REGISTRY.size
-  end
-
-  before do
-    # Reset databases
-    SubscriptionFieldSchema::TOOTS.clear
-    # Reset in order:
-    SubscriptionFieldSchema::USERS.clear
-    SubscriptionFieldSchema::ALL_USERS.map do |k, v|
-      SubscriptionFieldSchema::USERS[k] = v.dup
-    end
-
-    SubscriptionFieldSchema::InMemorySubscriptions::SUBSCRIPTION_REGISTRY.clear
-    SubscriptionFieldSchema::InMemorySubscriptions::EVENT_REGISTRY.clear
-  end
-
-  it "generates a return type" do
-    return_type = SubscriptionFieldSchema::TootWasTooted.payload_type
-    assert_equal "TootWasTootedPayload", return_type.graphql_name
-    assert_equal ["toot", "user"], return_type.fields.keys
-  end
-
-  it "can use a premade `payload_type`" do
-    return_type = SubscriptionFieldSchema::UsersJoined.payload_type
-    assert_equal "UsersJoinedManualPayload", return_type.graphql_name
-    assert_equal ["users"], return_type.fields.keys
-    assert_equal SubscriptionFieldSchema::UsersJoined::UsersJoinedManualPayload, return_type
-  end
-
-  describe "initial subscription" do
-    it "calls #subscribe for the initial subscription and returns the result" do
-      res = exec_query <<-GRAPHQL
-      subscription {
-        usersJoined {
-          users {
-            handle
-          }
-        }
-      }
-      GRAPHQL
-
-      assert_equal ["dhh", "matz", "_why"], res["data"]["usersJoined"]["users"].map { |u| u["handle"] }
-      assert_equal 1, in_memory_subscription_count
-    end
-
-    it "rejects the subscription if #subscribe raises an error" do
-      res = exec_query <<-GRAPHQL, context: { prohibit_subscriptions: true }
-      subscription {
-        tootWasTooted(handle: "matz") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-
-      expected_response = {
-        "data"=>nil,
-        "errors"=>[
-          {
-            "message"=>"You don't have permission to subscribe",
-            "locations"=>[{"line"=>2, "column"=>9}],
-            "path"=>["tootWasTooted"]
-          }
-        ]
-      }
-
-      assert_equal(expected_response, res)
-      assert_equal 0, in_memory_subscription_count
-    end
-
-    it "doesn't subscribe if `loads:` fails" do
-      res = exec_query <<-GRAPHQL
-      subscription {
-        tootWasTooted(handle: "jack") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-
-      expected_response = {
-        "data" => nil,
-        "errors" => [
-          {
-            "message"=>"No object found for `handle: \"jack\"`",
-            "locations"=>[{"line"=>2, "column"=>9}],
-            "path"=>["tootWasTooted"]
-          }
-        ]
-      }
-      assert_equal(expected_response, res)
-      assert_equal 0, in_memory_subscription_count
-    end
-
-    it "rejects if #authorized? fails" do
-      res = exec_query <<-GRAPHQL
-      subscription {
-        tootWasTooted(handle: "_why") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-      expected_response = {
-        "data"=>nil,
-        "errors"=>[
-          {
-            "message"=>"Can't subscribe to private user",
-            "locations"=>[{"line"=>2, "column"=>9}],
-            "path"=>["tootWasTooted"]
-          },
-        ],
-      }
-      assert_equal(expected_response, res)
-    end
-
-    it "sends no initial response if :no_response is returned, which is the default" do
-      assert_equal 0, in_memory_subscription_count
-
-      res = exec_query <<-GRAPHQL
-      subscription {
-        tootWasTooted(handle: "matz") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-      assert_equal({"data" => {}}, res)
-      assert_equal 1, in_memory_subscription_count
-    end
-  end
-
-  describe "updates" do
-    it "updates with `object` by default" do
-      res = exec_query <<-GRAPHQL
-      subscription {
-        tootWasTooted(handle: "matz") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-      assert_equal 1, in_memory_subscription_count
-      obj = OpenStruct.new(toot: { body: "I am a C programmer" }, user: SubscriptionFieldSchema::USERS["matz"])
-      SubscriptionFieldSchema.subscriptions.trigger(:toot_was_tooted, {handle: "matz"}, obj)
-
-      mailbox = res.context[:subscription_mailbox]
-      update_payload = mailbox.first
-      assert_equal "I am a C programmer", update_payload["data"]["tootWasTooted"]["toot"]["body"]
-    end
-
-    it "updates with the returned value" do
-      res = exec_query <<-GRAPHQL
-      subscription {
-        usersJoined {
-          users {
-            handle
-          }
-        }
-      }
-      GRAPHQL
-
-      assert_equal 1, in_memory_subscription_count
-      SubscriptionFieldSchema.subscriptions.trigger(:users_joined, {}, {new_users: [{handle: "eileencodes"}, {handle: "tenderlove"}]})
-
-      update = res.context[:subscription_mailbox].first
-      assert_equal [{"handle" => "eileencodes"}, {"handle" => "tenderlove"}], update["data"]["usersJoined"]["users"]
-    end
-
-    it "skips the update if `:no_update` is returned, but updates other subscribers" do
-      query_str = <<-GRAPHQL
-      subscription {
-        tootWasTooted(handle: "matz") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-
-      res1 = exec_query(query_str)
-      res2 = exec_query(query_str, context: { viewer: SubscriptionFieldSchema::USERS["matz"] })
-      assert_equal 2, in_memory_subscription_count
-
-      obj = OpenStruct.new(toot: { body: "Merry Christmas, here's a new Ruby version" }, user: SubscriptionFieldSchema::USERS["matz"])
-      SubscriptionFieldSchema.subscriptions.trigger(:toot_was_tooted, {handle: "matz"}, obj)
-
-      mailbox1 = res1.context[:subscription_mailbox]
-      mailbox2 = res2.context[:subscription_mailbox]
-      # The anonymous viewer got an update:
-      assert_equal "Merry Christmas, here's a new Ruby version", mailbox1.first["data"]["tootWasTooted"]["toot"]["body"]
-      # But not matz:
-      assert_equal [], mailbox2
-    end
-
-    it "unsubscribes if a `loads:` argument is not found" do
-      res = exec_query <<-GRAPHQL
-      subscription {
-        tootWasTooted(handle: "matz") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-      assert_equal 1, in_memory_subscription_count
-      obj = OpenStruct.new(toot: { body: "I am a C programmer" }, user: SubscriptionFieldSchema::USERS["matz"])
-      SubscriptionFieldSchema.subscriptions.trigger(:toot_was_tooted, {handle: "matz"}, obj)
-
-      # Get 1 successful update
-      mailbox = res.context[:subscription_mailbox]
-      assert_equal 1, mailbox.size
-      update_payload = mailbox.first
-      assert_equal "I am a C programmer", update_payload["data"]["tootWasTooted"]["toot"]["body"]
-
-      # Then cause a not-found and update again
-      matz = SubscriptionFieldSchema::USERS.delete("matz")
-      obj = OpenStruct.new(toot: { body: "Merry Christmas, here's a new Ruby version" }, user: matz)
-      SubscriptionFieldSchema.subscriptions.trigger(:toot_was_tooted, {handle: "matz"}, obj)
-      # there was no subsequent update
-      assert_equal 1, mailbox.size
-      # The database was cleaned up
-      assert_equal 0, in_memory_subscription_count
-    end
-
-    it "sends an error if `#authorized?` fails" do
-      res = exec_query <<-GRAPHQL
-      subscription {
-        tootWasTooted(handle: "matz") {
-          toot { body }
-        }
-      }
-      GRAPHQL
-      assert_equal 1, in_memory_subscription_count
-      matz = SubscriptionFieldSchema::USERS["matz"]
-      obj = OpenStruct.new(toot: { body: "I am a C programmer" }, user: matz)
-      SubscriptionFieldSchema.subscriptions.trigger(:toot_was_tooted, {handle: "matz"}, obj)
-
-      # Get 1 successful update
-      mailbox = res.context[:subscription_mailbox]
-      assert_equal 1, mailbox.size
-      update_payload = mailbox.first
-      assert_equal "I am a C programmer", update_payload["data"]["tootWasTooted"]["toot"]["body"]
-
-      # Cause an authorized failure
-      matz[:private] = true
-      obj = OpenStruct.new(toot: { body: "Merry Christmas, here's a new Ruby version" }, user: matz)
-      SubscriptionFieldSchema.subscriptions.trigger(:toot_was_tooted, {handle: "matz"}, obj)
-      assert_equal 2, mailbox.size
-      assert_equal ["Can't subscribe to private user"], mailbox.last["errors"].map { |e| e["message"] }
-      # The subscription remains in place
-      assert_equal 1, in_memory_subscription_count
-    end
-  end
-end

data/spec/graphql/schema/timeout_middleware_spec.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema::TimeoutMiddleware do
-  let(:max_seconds) { 1 }
-  let(:timeout_middleware) {  GraphQL::Schema::TimeoutMiddleware.new(max_seconds: max_seconds) }
-  let(:timeout_schema) {
-
-    sleep_for_seconds_resolve = ->(obj, args, ctx) {
-      sleep(args[:seconds])
-      args[:seconds]
-    }
-
-    nested_sleep_type = GraphQL::ObjectType.define do
-      name "NestedSleep"
-      field :seconds, types.Float do
-        resolve ->(obj, args, ctx) { obj }
-      end
-
-      field :nestedSleep, -> { nested_sleep_type } do
-        argument :seconds, !types.Float
-        resolve(sleep_for_seconds_resolve)
-      end
-    end
-
-    query_type = GraphQL::ObjectType.define do
-      name "Query"
-      field :sleepFor, types.Float do
-        argument :seconds, !types.Float
-        resolve(sleep_for_seconds_resolve)
-      end
-
-      field :nestedSleep, nested_sleep_type do
-        argument :seconds, !types.Float
-        resolve(sleep_for_seconds_resolve)
-      end
-    end
-
-    schema = GraphQL::Schema.define(query: query_type)
-    schema.middleware << timeout_middleware
-    schema
-  }
-
-  let(:result) { timeout_schema.execute(query_string) }
-
-  describe "timeout part-way through" do
-    let(:query_string) {%|
-      {
-        a: sleepFor(seconds: 0.4)
-        b: sleepFor(seconds: 0.4)
-        c: sleepFor(seconds: 0.4)
-        d: sleepFor(seconds: 0.4)
-        e: sleepFor(seconds: 0.4)
-      }
-    |}
-    it "returns a partial response and error messages" do
-      expected_data = {
-        "a"=>0.4,
-        "b"=>0.4,
-        "c"=>0.4,
-        "d"=>nil,
-        "e"=>nil,
-      }
-
-      expected_errors =  [
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>6, "column"=>9}],
-          "path"=>["d"]
-        },
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>7, "column"=>9}],
-          "path"=>["e"]
-        },
-      ]
-      assert_equal expected_data, result["data"]
-      assert_equal expected_errors, result["errors"]
-    end
-  end
-
-  describe "timeout in nested fields" do
-    let(:query_string) {%|
-    {
-      a: nestedSleep(seconds: 0.3) {
-        seconds
-        b: nestedSleep(seconds: 0.3) {
-          seconds
-          c: nestedSleep(seconds: 0.3) {
-            seconds
-            d: nestedSleep(seconds: 0.4) {
-              seconds
-              e: nestedSleep(seconds: 0.4) {
-                seconds
-              }
-            }
-          }
-        }
-      }
-    }
-    |}
-
-    it "returns a partial response and error messages" do
-      expected_data = {
-        "a" => {
-          "seconds" => 0.3,
-          "b" => {
-            "seconds" => 0.3,
-            "c" => {
-              "seconds"=>0.3,
-              "d" => {
-                "seconds"=>nil,
-                "e"=>nil
-              }
-            }
-          }
-        }
-      }
-      expected_errors = [
-        {
-          "message"=>"Timeout on NestedSleep.seconds",
-          "locations"=>[{"line"=>10, "column"=>15}],
-          "path"=>["a", "b", "c", "d", "seconds"]
-        },
-        {
-          "message"=>"Timeout on NestedSleep.nestedSleep",
-          "locations"=>[{"line"=>11, "column"=>15}],
-          "path"=>["a", "b", "c", "d", "e"]
-        },
-      ]
-
-      assert_equal expected_data, result["data"]
-      assert_equal expected_errors, result["errors"]
-    end
-  end
-
-  describe "long-running fields" do
-    let(:query_string) {%|
-      {
-        a: sleepFor(seconds: 0.2)
-        b: sleepFor(seconds: 0.2)
-        c: sleepFor(seconds: 0.8)
-        d: sleepFor(seconds: 0.1)
-      }
-    |}
-    it "doesn't terminate long-running field execution" do
-      expected_data = {
-        "a"=>0.2,
-        "b"=>0.2,
-        "c"=>0.8,
-        "d"=>nil,
-      }
-
-      expected_errors = [
-        {
-          "message"=>"Timeout on Query.sleepFor",
-          "locations"=>[{"line"=>6, "column"=>9}],
-          "path"=>["d"]
-        },
-      ]
-
-      assert_equal expected_data, result["data"]
-      assert_equal expected_errors, result["errors"]
-    end
-  end
-
-  describe "with a custom block" do
-    let(:timeout_middleware) {
-      GraphQL::Schema::TimeoutMiddleware.new(max_seconds: max_seconds) do |err, query|
-        raise("Query timed out after 2s: #{query.operations.count} on #{query.context.ast_node.alias}")
-      end
-    }
-    let(:query_string) {%|
-      {
-        a: sleepFor(seconds: 0.4)
-        b: sleepFor(seconds: 0.4)
-        c: sleepFor(seconds: 0.4)
-        d: sleepFor(seconds: 0.4)
-        e: sleepFor(seconds: 0.4)
-      }
-    |}
-
-    it "calls the block" do
-      err = assert_raises(RuntimeError) { result }
-      assert_equal "Query timed out after 2s: 1 on d", err.message
-    end
-  end
-end