Fixed: Subscription is not working with variables (#1176)

Author: michaelstaib

src/Core/Core/Execution/SubscriptionExecutionStrategy.cs

@@ -1,14 +1,15 @@
+using System.Runtime.InteropServices.ComTypes;
+using System.IO;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using HotChocolate.Execution.Configuration;
-using HotChocolate.Language;
 using HotChocolate.Properties;
-using HotChocolate.Resolvers;
 using HotChocolate.Subscriptions;
-using HotChocolate.Types;
+using HotChocolate.Language;
 
 namespace HotChocolate.Execution
 {
@@ -71,30 +72,41 @@ private static EventDescription CreateEvent(
             if (selections.Count == 1)
             {
                 FieldSelection selection = selections.Single();
-                return new EventDescription(
-                    selection.Field.Name,
-                    selection.Selection.Arguments);
+                var arguments = new List<ArgumentNode>();
+                IVariableValueCollection variables = executionContext.Variables;
+
+                foreach (ArgumentNode argument in selection.Selection.Arguments)
+                {
+                    if (argument.Value is VariableNode v)
+                    {
+                        IValueNode value = variables.GetVariable<IValueNode>(v.Name.Value);
+                        arguments.Add(argument.WithValue(value));
+                    }
+                    else
+                    {
+                        arguments.Add(argument);
+                    }
+                }
+
+                return new EventDescription(selection.Field.Name, arguments);
             }
             else
             {
-                throw new QueryException(
-                    CoreResources.Subscriptions_SingleRootField);
+                throw new QueryException(CoreResources.Subscriptions_SingleRootField);
             }
         }
 
         private static Task<IEventStream> SubscribeAsync(
             IServiceProvider services,
             IEventDescription @event)
         {
-            var eventRegistry = (IEventRegistry)services
-                .GetService(typeof(IEventRegistry));
+            var eventRegistry = services.GetService<IEventRegistry>();
 
             if (eventRegistry == null)
             {
                 throw new QueryException(
                     ErrorBuilder.New()
-                        .SetMessage(CoreResources
-                            .SubscriptionExecutionStrategy_NoEventRegistry)
+                        .SetMessage(CoreResources.SubscriptionExecutionStrategy_NoEventRegistry)
                         .Build());
             }
 
@@ -121,7 +133,7 @@ private async Task<IReadOnlyQueryResult> ExecuteSubscriptionQueryAsync(
                         executionContext,
                         batchOperationHandler,
                         cancellationToken)
-                            .ConfigureAwait(false);
+                        .ConfigureAwait(false);
 
                     return result.AsReadOnly();
                 }

src/Core/Subscriptions.Tests/SubscriptionTests.cs

@@ -1,6 +1,8 @@
-using System;
+using System.Threading;
+using System;
 using System.Threading.Tasks;
 using HotChocolate.Execution;
+using HotChocolate.Language;
 using HotChocolate.Types;
 using Moq;
 using Xunit;
@@ -10,7 +12,7 @@ namespace HotChocolate.Subscriptions
     public class SubscriptionTests
     {
         [Fact]
-        public async Task Subscribe_RaiseEvent_ReceiveSubscriptionResult()
+        public async Task Subscribe_RaiseEvent_No_Arguments()
         {
             // arrange
             var registry = new InMemoryEventRegistry();
@@ -45,9 +47,106 @@ await executor.ExecuteAsync("subscription { foo }")
             await executor.ExecuteAsync("mutation { foo }");
 
             // assert
-            IReadOnlyQueryResult result = await responseStream.ReadAsync();
-            Assert.False(responseStream.IsCompleted);
-            Assert.Equal("bar", result.Data["foo"]);
+            using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
+            {
+                IReadOnlyQueryResult result = await responseStream.ReadAsync(cts.Token);
+                Assert.False(responseStream.IsCompleted);
+                Assert.Equal("bar", result.Data["foo"]);
+            }
+        }
+
+        [Fact]
+        public async Task Subscribe_RaiseEvent_With_Argument()
+        {
+            // arrange
+            var registry = new InMemoryEventRegistry();
+
+            var services = new Mock<IServiceProvider>();
+            services.Setup(t => t.GetService(It.IsAny<Type>()))
+                .Returns(new Func<Type, object>(t =>
+                {
+                    if (t == typeof(IEventRegistry)
+                        || t == typeof(IEventSender))
+                    {
+                        return registry;
+                    }
+                    return null;
+                }));
+
+            ISchema schema = Schema.Create(c =>
+            {
+                c.RegisterQueryType<DummyQuery>();
+                c.RegisterServiceProvider(services.Object);
+                c.RegisterMutationType<MutationType>();
+                c.RegisterSubscriptionType<SubscriptionType>();
+            });
+
+            IQueryExecutor executor = schema.MakeExecutable();
+
+            var responseStream =
+                await executor.ExecuteAsync("subscription { bar(baz:\"123\") }")
+                as IResponseStream;
+
+            // act
+            await executor.ExecuteAsync("mutation { bar(baz:\"123\") }");
+
+            // assert
+            using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
+            {
+                IReadOnlyQueryResult result = await responseStream.ReadAsync(cts.Token);
+                Assert.False(responseStream.IsCompleted);
+                Assert.Equal("123", result.Data["bar"]);
+            }
+        }
+
+        [Fact]
+        public async Task Subscribe_RaiseEvent_With_Argument_As_Variables()
+        {
+            // arrange
+            var registry = new InMemoryEventRegistry();
+
+            var services = new Mock<IServiceProvider>();
+            services.Setup(t => t.GetService(It.IsAny<Type>()))
+                .Returns(new Func<Type, object>(t =>
+                {
+                    if (t == typeof(IEventRegistry)
+                        || t == typeof(IEventSender))
+                    {
+                        return registry;
+                    }
+                    return null;
+                }));
+
+            ISchema schema = Schema.Create(c =>
+            {
+                c.RegisterQueryType<DummyQuery>();
+                c.RegisterServiceProvider(services.Object);
+                c.RegisterMutationType<MutationType>();
+                c.RegisterSubscriptionType<SubscriptionType>();
+            });
+
+            IQueryExecutor executor = schema.MakeExecutable();
+
+            var responseStream =
+                await executor.ExecuteAsync(QueryRequestBuilder.New()
+                    .SetQuery("subscription($a: String!) { bar(baz:$a) }")
+                    .AddVariableValue("a", "123")
+                    .Create())
+                as IResponseStream;
+
+            // act
+            await executor.ExecuteAsync(QueryRequestBuilder.New()
+                .SetQuery("mutation($a: String!) { bar(baz:$a) }")
+                .AddVariableValue("a", "123")
+                .Create());
+
+            // assert
+            using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30)))
+            {
+                IReadOnlyQueryResult result = await responseStream.ReadAsync(cts.Token);
+                Assert.False(responseStream.IsCompleted);
+                Assert.Equal("123", result.Data["bar"]);
+            }
         }
 
         public class DummyQuery
@@ -62,6 +161,9 @@ protected override void Configure(IObjectTypeDescriptor descriptor)
             {
                 descriptor.Name("subscription");
                 descriptor.Field("foo").Resolver(() => "bar");
+                descriptor.Field("bar")
+                    .Argument("baz", a => a.Type<NonNullType<StringType>>())
+                    .Resolver(ctx => ctx.Argument<string>("baz"));
             }
         }
 
@@ -73,8 +175,17 @@ protected override void Configure(IObjectTypeDescriptor descriptor)
                 descriptor.Name("mutation");
                 descriptor.Field("foo").Resolver(ctx =>
                 {
-                    ctx.Service<IEventSender>()
-                        .SendAsync(new EventMessage("foo"));
+                    ctx.Service<IEventSender>().SendAsync(new EventMessage("foo"));
+                    return "barmut";
+                });
+
+                descriptor.Field("bar")
+                    .Argument("baz", a => a.Type<NonNullType<StringType>>())
+                    .Resolver(ctx =>
+                {
+                    IValueNode argumentValue = ctx.Argument<IValueNode>("baz");
+                    ctx.Service<IEventSender>().SendAsync(
+                        new EventMessage("bar", new ArgumentNode("baz", argumentValue)));
                     return "barmut";
                 });
             }