graphql 1.8.7 → 1.9.0

data/spec/graphql/schema/subscription_spec.rb

@@ -0,0 +1,416 @@
+# 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/traversal_spec.rb

@@ -20,24 +20,24 @@ describe GraphQL::Schema::Traversal do
   it "finds types from a single type and its fields" do
     expected = {
       "Boolean" => GraphQL::BOOLEAN_TYPE,
-      "Cheese" => Dummy::CheeseType,
+      "Cheese" => Dummy::Cheese.graphql_definition,
       "Float" => GraphQL::FLOAT_TYPE,
       "String" => GraphQL::STRING_TYPE,
-      "Edible" => Dummy::EdibleInterface,
-      "EdibleAsMilk" => Dummy::EdibleAsMilkInterface,
-      "DairyAnimal" => Dummy::DairyAnimalEnum,
+      "Edible" => Dummy::Edible.graphql_definition,
+      "EdibleAsMilk" => Dummy::EdibleAsMilk.graphql_definition,
+      "DairyAnimal" => Dummy::DairyAnimal.graphql_definition,
       "Int" => GraphQL::INT_TYPE,
-      "AnimalProduct" => Dummy::AnimalProductInterface,
-      "LocalProduct" => Dummy::LocalProductInterface,
+      "AnimalProduct" => Dummy::AnimalProduct.graphql_definition,
+      "LocalProduct" => Dummy::LocalProduct.graphql_definition,
     }
-    result = traversal([Dummy::CheeseType]).type_map
+    result = traversal([Dummy::Cheese.graphql_definition]).type_map
     assert_equal(expected.keys.sort, result.keys.sort)
     assert_equal(expected, result.to_h)
   end
 
   it "finds type from arguments" do
-    result = traversal([Dummy::DairyAppQueryType]).type_map
-    assert_equal(Dummy::DairyProductInputType, result["DairyProductInput"])
+    result = traversal([Dummy::DairyAppQuery.graphql_definition]).type_map
+    assert_equal(Dummy::DairyProductInput.graphql_definition, result["DairyProductInput"])
   end
 
   it "finds types from field instrumentation" do
@@ -126,7 +126,7 @@ describe GraphQL::Schema::Traversal do
 
   describe "when a field is only accessible through an interface" do
     it "is found through Schema.define(types:)" do
-      assert_equal Dummy::HoneyType, Dummy::Schema.types["Honey"]
+      assert_equal Dummy::Honey.graphql_definition, Dummy::Schema.types["Honey"]
     end
   end
 

data/spec/graphql/schema/type_expression_spec.rb

@@ -13,7 +13,7 @@ describe GraphQL::Schema::TypeExpression do
     describe "simple types" do
       let(:type_name) { "DairyProductInput" }
       it "it gets types from the provided types" do
-        assert_equal(Dummy::DairyProductInputType, type_expression_result)
+        assert_equal(Dummy::DairyProductInput.graphql_definition, type_expression_result)
       end
     end
 
@@ -28,7 +28,7 @@ describe GraphQL::Schema::TypeExpression do
       let(:type_name) { "[DairyAnimal!]!" }
 
       it "makes list types" do
-        expected = Dummy::DairyAnimalEnum
+        expected = Dummy::DairyAnimal.graphql_definition
           .to_non_null_type
           .to_list_type
           .to_non_null_type

data/spec/graphql/schema/union_spec.rb

@@ -3,6 +3,13 @@ require "spec_helper"
 
 describe GraphQL::Schema::Union do
   let(:union) { Jazz::PerformingAct }
+
+  describe ".path" do
+    it "is the name" do
+      assert_equal "PerformingAct", union.path
+    end
+  end
+
   describe "type info" do
     it "has some" do
       assert_equal 2, union.possible_types.size

data/spec/graphql/schema/validation_spec.rb

@@ -315,7 +315,7 @@ describe GraphQL::Schema::Validation do
     let(:null_default_value) {
       GraphQL::Argument.define do
         name "NullDefault"
-        type Dummy::DairyAnimalEnum
+        type Dummy::DairyAnimal
         default_value nil
       end
     }