graphql 1.9.0.pre2 → 1.9.0.pre3

data/lib/graphql/schema/subscription.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This class can be extended to create fields on your subscription root.
+    #
+    # It provides hooks for the different parts of the subscription lifecycle:
+    #
+    # - `#authorized?`: called before initial subscription and subsequent updates
+    # - `#subscribe`: called for the initial subscription
+    # - `#update`: called for subsequent update
+    #
+    # Also, `#unsubscribe` terminates the subscription.
+    class Subscription < GraphQL::Schema::Resolver
+      class EarlyTerminationError < StandardError
+      end
+
+      # Raised when `unsubscribe` is called; caught by `subscriptions.rb`
+      class UnsubscribedError < EarlyTerminationError
+      end
+
+      # Raised when `no_update` is returned; caught by `subscriptions.rb`
+      class NoUpdateError < EarlyTerminationError
+      end
+      extend GraphQL::Schema::Resolver::HasPayloadType
+      extend GraphQL::Schema::Member::HasFields
+
+      # The generated payload type is required; If there's no payload,
+      # propagate null.
+      null false
+
+      def initialize(object:, context:)
+        super
+        # Figure out whether this is an update or an initial subscription
+        @mode = context.query.subscription_update? ? :update : :subscribe
+      end
+
+      # Implement the {Resolve} API
+      def resolve(**args)
+        # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
+        # have an unexpected `@mode`
+        public_send("resolve_#{@mode}", args)
+      end
+
+      # Wrap the user-defined `#subscribe` hook
+      def resolve_subscribe(args)
+        ret_val = args.any? ? subscribe(args) : subscribe
+        if ret_val == :no_response
+          context.skip
+        else
+          ret_val
+        end
+      end
+
+      # Default implementation returns the root object.
+      # Override it to return an object or
+      # `:no_response` to return nothing.
+      #
+      # The default is `:no_response`.
+      def subscribe(args)
+        :no_response
+      end
+
+      # Wrap the user-provided `#update` hook
+      def resolve_update(args)
+        ret_val = args.any? ? update(args) : update
+        if ret_val == :no_update
+          raise NoUpdateError
+        else
+          ret_val
+        end
+      end
+
+      # The default implementation returns the root object.
+      # Override it to return `:no_update` if you want to
+      # skip updates sometimes. Or override it to return a different object.
+      def update(args = {})
+        object
+      end
+
+      # If an argument is flagged with `loads:` and no object is found for it,
+      # remove this subscription (assuming that the object was deleted in the meantime,
+      # or that it became inaccessible).
+      def load_application_object_failed(err)
+        if @mode == :update
+          unsubscribe
+        end
+        super
+      end
+
+      # Call this to halt execution and remove this subscription from the system
+      def unsubscribe
+        raise UnsubscribedError
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions.rb

@@ -100,6 +100,12 @@ module GraphQL
         }
       )
       deliver(subscription_id, result)
+    rescue GraphQL::Schema::Subscription::NoUpdateError
+      # This update was skipped in user code; do nothing.
+    rescue GraphQL::Schema::Subscription::UnsubscribedError
+      # `unsubscribe` was called, clean up on our side
+      # TODO also send `{more: false}` to client?
+      delete_subscription(subscription_id)
     end
 
     # Event `event` occurred on `object`,
@@ -133,9 +139,8 @@ module GraphQL
     # The result should be send to `subscription_id`.
     # @param subscription_id [String]
     # @param result [Hash]
-    # @param context [GraphQL::Query::Context]
     # @return [void]
-    def deliver(subscription_id, result, context)
+    def deliver(subscription_id, result)
       raise NotImplementedError
     end
 
@@ -148,6 +153,14 @@ module GraphQL
       raise NotImplementedError
     end
 
+    # A subscription was terminated server-side.
+    # Clean up the database.
+    # @param subscription_id [String]
+    # @return void.
+    def delete_subscription(subscription_id)
+      raise NotImplementedError
+    end
+
     # @return [String] A new unique identifier for a subscription
     def build_id
       SecureRandom.uuid

data/lib/graphql/subscriptions/subscription_root.rb

@@ -4,8 +4,30 @@ module GraphQL
   class Subscriptions
     # Extend this module in your subscription root when using {GraphQL::Execution::Interpreter}.
     module SubscriptionRoot
+      def self.extended(child_cls)
+        child_cls.include(InstanceMethods)
+      end
+
+      # This is for maintaining backwards compatibility:
+      # if a subscription field is created without a `subscription:` resolver class,
+      # then implement the method with the previous default behavior.
+      module InstanceMethods
+        def skip_subscription_root(*)
+          if context.query.subscription_update?
+            object
+          else
+            context.skip
+          end
+        end
+      end
+
       def field(*args, extensions: [], **rest, &block)
         extensions += [Extension]
+        # Backwards-compat for schemas
+        if !rest[:subscription]
+          name = args.first
+          alias_method(name, :skip_subscription_root)
+        end
         super(*args, extensions: extensions, **rest, &block)
       end
 
@@ -22,16 +44,17 @@ module GraphQL
               context: context,
               field: field,
             )
-            context.skip
+            # TODO compat with non-class-based subscriptions?
+            value
           elsif context.query.subscription_topic == Subscriptions::Event.serialize(
               field.name,
               arguments,
               field,
               scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
             )
-            # The root object is _already_ the subscription update,
-            # it was passed to `.trigger`
-            object.object
+            # This is a subscription update. The resolver returned `skip` if it should be skipped,
+            # or else it returned an object to resolve the update.
+            value
           else
             # This is a subscription update, but this event wasn't triggered.
             context.skip

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.9.0.pre2"
+  VERSION = "1.9.0.pre3"
 end

data/spec/dummy/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: /Users/rmosolgo/code/graphql-ruby
   specs:
-    graphql (1.8.8)
+    graphql (1.9.0.pre2)
 
 GEM
   remote: https://rubygems.org/
@@ -154,4 +154,4 @@ DEPENDENCIES
   selenium-webdriver
 
 BUNDLED WITH
-   1.16.1
+   2.0.1

data/spec/dummy/app/channels/graphql_channel.rb

@@ -14,15 +14,15 @@ class GraphqlChannel < ActionCable::Channel::Base
   class SubscriptionType < GraphQL::Schema::Object
     if TESTING_INTERPRETER
       extend GraphQL::Subscriptions::SubscriptionRoot
+    else
+      def payload(id:)
+        id
+      end
     end
 
     field :payload, PayloadType, null: false do
       argument :id, ID, required: true
     end
-
-    def payload(id:)
-      id
-    end
   end
 
   # Wacky behavior around the number 4

data/spec/dummy/log/test.log

@@ -194,3 +194,6 @@ GraphqlChannel transmitting {"result"=>{"data"=>{"payload"=>{"value"=>400}}}, "m
 Finished "/cable/" [WebSocket] for 127.0.0.1 at 2018-10-05 11:46:25 -0400
 GraphqlChannel stopped streaming from graphql-subscription:c781954b-7b9a-4742-9f9c-69b869d85fad
 GraphqlChannel stopped streaming from graphql-event::payload:id:updates-2
+-----------------------------------------------------------
+ActionCableSubscriptionsTest: test_it_handles_subscriptions
+-----------------------------------------------------------

data/spec/graphql/execution/lookahead_spec.rb

@@ -14,12 +14,19 @@ describe GraphQL::Execution::Lookahead do
       DATA.find { |b| b.name == name }
     end
 
+    module Node
+      include GraphQL::Schema::Interface
+      field :id, ID, null: false
+    end
+
     class BirdGenus < GraphQL::Schema::Object
       field :latin_name, String, null: false
+      field :id, ID, null: false, method: :latin_name
     end
 
     class BirdSpecies < GraphQL::Schema::Object
       field :name, String, null: false
+      field :id, ID, null: false, method: :name
       field :is_waterfowl, Boolean, null: false
       field :similar_species, [BirdSpecies], null: false
 
@@ -46,6 +53,18 @@ describe GraphQL::Execution::Lookahead do
       def find_bird_species(by_name:)
         DATA.find_by_name(by_name)
       end
+
+      field :node, Node, null: true do
+        argument :id, ID, required: true
+      end
+
+      def node(id:)
+        if (node = DATA.find_by_name(id))
+          node
+        else
+          DATA.map { |d| d.genus }.select { |g| g.name == id }
+        end
+      end
     end
 
     class LookaheadInstrumenter
@@ -101,6 +120,40 @@ describe GraphQL::Execution::Lookahead do
       assert_equal true, query.lookahead.selects?("__typename")
     end
 
+    describe "fields on interfaces" do
+      let(:document) {
+        GraphQL.parse <<-GRAPHQL
+        query {
+          node(id: "Cardinal") {
+            id
+            ... on BirdSpecies {
+              name
+            }
+            ...Other
+          }
+        }
+        fragment Other on BirdGenus {
+          latinName
+        }
+        GRAPHQL
+      }
+
+      it "finds fields on object types and interface types" do
+        node_lookahead = query.lookahead.selection("node")
+        assert_equal [:id, :name, :latin_name], node_lookahead.selections.map(&:name)
+      end
+    end
+
+    describe "inspect" do
+      it "works for root lookaheads" do
+        assert_includes query.lookahead.inspect, "#<GraphQL::Execution::Lookahead @root_type="
+      end
+
+      it "works for field lookaheads" do
+        assert_includes query.lookahead.selection(:find_bird_species).inspect, "#<GraphQL::Execution::Lookahead @field="
+      end
+    end
+
     describe "constraints by arguments" do
       let(:lookahead) do
         query.lookahead
@@ -245,7 +298,7 @@ describe GraphQL::Execution::Lookahead do
       ast_node = document.definitions.first.selections.first
       field = LookaheadTest::Query.fields["findBirdSpecies"]
       lookahead = GraphQL::Execution::Lookahead.new(query: query, ast_nodes: [ast_node], field: field)
-      assert_equal lookahead.selections.map(&:name), [:name, :similar_species]
+      assert_equal [:name, :similar_species], lookahead.selections.map(&:name)
     end
 
     it "filters outs selections which do not match arguments" do

data/spec/graphql/query/executor_spec.rb

@@ -257,10 +257,10 @@ describe GraphQL::Query::Executor do
             {
               "message" => "Variable input of type ReplaceValuesInput! was provided invalid value",
               "locations" => [{ "line" => 1, "column" => 13 }],
-              "value" => nil,
-              "problems" => [
-                { "path" => [], "explanation" => "Expected value to not be null" }
-              ]
+              "extensions" => {
+                "value" => nil,
+                "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
+              }
             }
           ]
         }
@@ -277,10 +277,10 @@ describe GraphQL::Query::Executor do
             {
               "message" => "Variable input of type ReplaceValuesInput! was provided invalid value",
               "locations" => [{ "line" => 1, "column" => 13 }],
-              "value" => {},
-              "problems" => [
-                { "path" => ["values"], "explanation" => "Expected value to not be null" }
-              ]
+              "extensions" => {
+                "value" => {},
+                "problems" => [{ "path" => ["values"], "explanation" => "Expected value to not be null" }]
+              }
             }
           ]
         }
@@ -297,11 +297,13 @@ describe GraphQL::Query::Executor do
             {
               "message" => "Variable input of type [DairyProductInput] was provided invalid value",
               "locations" => [{ "line" => 1, "column" => 10 }],
-              "value" => [{ "foo" => "bar" }],
-              "problems" => [
-                { "path" => [0, "foo"], "explanation" => "Field is not defined on DairyProductInput" },
-                { "path" => [0, "source"], "explanation" => "Expected value to not be null" }
-              ]
+              "extensions" => {
+                "value" => [{ "foo" => "bar" }],
+                "problems" => [
+                  { "path" => [0, "foo"], "explanation" => "Field is not defined on DairyProductInput" },
+                  { "path" => [0, "source"], "explanation" => "Expected value to not be null" }
+                ]
+              }
             }
           ]
         }

data/spec/graphql/query_spec.rb

@@ -435,8 +435,10 @@ describe GraphQL::Query do
             {
               "message" => "Variable cheeseId of type Int! was provided invalid value",
               "locations"=>[{ "line" => 2, "column" => 23 }],
-              "value" => "2",
-              "problems" => [{ "path" => [], "explanation" => 'Could not coerce value "2" to Int' }]
+              "extensions" => {
+                "value" => "2",
+                "problems" => [{ "path" => [], "explanation" => 'Could not coerce value "2" to Int' }]
+              }
             }
           ]
         }
@@ -453,8 +455,10 @@ describe GraphQL::Query do
             {
               "message" => "Variable cheeseId of type Int! was provided invalid value",
               "locations" => [{"line" => 2, "column" => 23}],
-              "value" => nil,
-              "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
+              "extensions" => {
+                "value" => nil,
+                "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
+              }
             }
           ]
         }
@@ -471,8 +475,10 @@ describe GraphQL::Query do
             {
               "message" => "Variable cheeseId of type Int! was provided invalid value",
               "locations" => [{"line" => 2, "column" => 23}],
-              "value" => nil,
-              "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
+              "extensions" => {
+                "value" => nil,
+                "problems" => [{ "path" => [], "explanation" => "Expected value to not be null" }]
+              }
             }
           ]
         }

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