basics working

Author: benwilson512

lib/absinthe/phase/subscription/subscribe_self.ex

@@ -23,10 +23,14 @@ defmodule Absinthe.Phase.Subscription.SubscribeSelf do
 
     with {:ok, config} <- get_config(field, context, blueprint) do
       field_keys = get_field_keys(field, config)
-      subscription_id = get_subscription_id(config, blueprint, options)
+      context_id = get_context_id(config)
+      document_id = get_document_id(config, blueprint, options)
 
-      for field_key <- field_keys,
-          do: Absinthe.Subscription.subscribe(pubsub, field_key, subscription_id, blueprint)
+      subscription_id = subscription_id(context_id, document_id)
+
+      for field_key <- field_keys do
+        Absinthe.Subscription.subscribe(pubsub, blueprint, field_key, context_id, subscription_id)
+      end
 
       {:replace, blueprint,
        [
@@ -137,10 +141,7 @@ defmodule Absinthe.Phase.Subscription.SubscribeSelf do
     end
   end
 
-  defp get_subscription_id(config, blueprint, options) do
-    context_id = get_context_id(config)
-    document_id = get_document_id(config, blueprint, options)
-
+  defp subscription_id(context_id, document_id) do
     "__absinthe__:doc:#{context_id}:#{document_id}"
   end
 

lib/absinthe/subscription.ex

@@ -107,21 +107,22 @@ defmodule Absinthe.Subscription do
   defp fetch_fields(_, _), do: []
 
   @doc false
-  def subscribe(pubsub, field_key, doc_id, doc) do
+  def subscribe(pubsub, doc, field_key, context_id, subscription_id) do
     dup_registry = pubsub |> registry_name(:duplicate)
     uniq_registry = pubsub |> registry_name(:unique)
 
     doc_value = {
-      doc_id,
+      subscription_id,
+      context_id,
       %{
         initial_phases: PipelineSerializer.pack(doc.initial_phases),
         source: doc.source
       }
     }
 
-    _ = Registry.register(uniq_registry, {self(), :context}, doc.execution.context)
+    _ = Registry.register(uniq_registry, {self(), context_id}, doc.execution.context)
     {:ok, _} = Registry.register(dup_registry, field_key, doc_value)
-    {:ok, _} = Registry.register(dup_registry, {self(), doc_id}, field_key)
+    {:ok, _} = Registry.register(dup_registry, {self(), subscription_id}, field_key)
   end
 
   @doc false
@@ -145,8 +146,8 @@ defmodule Absinthe.Subscription do
     dup_registry
     |> Registry.lookup(key)
     |> Enum.map(fn match ->
-      {pid, {doc_id, doc}} = match
-      {_, context} = Registry.lookup(uniq_registry, {pid, doc_id, :context})
+      {pid, {doc_id, context_id, doc}} = match
+      [{_, context}] = Registry.lookup(uniq_registry, {pid, context_id})
 
       doc =
         Map.update!(doc, :initial_phases, fn phases ->

lib/absinthe/subscription/proxy_supervisor.ex

@@ -3,8 +3,8 @@ defmodule Absinthe.Subscription.ProxySupervisor do
 
   use Supervisor
 
-  def start_link([pubsub, registry, pool_size]) do
-    Supervisor.start_link(__MODULE__, {pubsub, registry, pool_size})
+  def start_link([pubsub, pool_size]) do
+    Supervisor.start_link(__MODULE__, {pubsub, pool_size})
   end
 
   def init({pubsub, pool_size}) do

test/absinthe/execution/subscription_test.exs

@@ -48,6 +48,15 @@ defmodule Absinthe.Execution.SubscriptionTest do
       field :id, :id
       field :name, :string
 
+      field :email, :string do
+        resolve fn
+          _, _, %{context: %{admin: true}} ->
+            {:ok, "[email protected]"}
+          _, _, _ ->
+            {:error, "unauthorized"}
+        end
+      end
+
       field :group, :group do
         resolve fn user, _, %{context: %{test_pid: pid}} ->
           batch({__MODULE__, :batch_get_group, pid}, nil, fn _results ->
@@ -393,31 +402,6 @@ defmodule Absinthe.Execution.SubscriptionTest do
     assert String.contains?(error_log, "boom")
   end
 
-  @tag :pending
-  test "different subscription docs are batched together" do
-    opts = [context: %{test_pid: self()}]
-
-    assert {:ok, %{"subscribed" => doc1}} =
-             run_subscription("subscription { user { group { name } id} }", Schema, opts)
-
-    # different docs required for test, otherwise they get deduplicated from the start
-    assert {:ok, %{"subscribed" => doc2}} =
-             run_subscription("subscription { user { group { name } id name} }", Schema, opts)
-
-    user = %{id: "1", name: "Alicia", group: %{name: "Elixir Users"}}
-
-    Absinthe.Subscription.publish(PubSub, user, user: ["*", user.id])
-
-    assert_receive({:broadcast, %{topic: ^doc1, result: %{data: _}}})
-    assert_receive({:broadcast, %{topic: ^doc2, result: %{data: %{"user" => user}}}})
-
-    assert user["group"]["name"] == "Elixir Users"
-
-    # we should get this just once due to batching
-    assert_receive(:batch_get_group)
-    refute_receive(:batch_get_group)
-  end
-
   test "subscription docs with different contexts don't leak context" do
     ctx1 = %{test_pid: self(), user: 1}