public void TriggerUnknownIsNopEvenWithErrors()
        {
            using var uut = new RequestCorrespondances();
            var outcome = uut.Trigger(0, null, "irrelevant");

            Assert.False(outcome);
        }
        public void TriggerUnknownIsNop()
        {
            using var uut = new RequestCorrespondances();
            var outcome = uut.Trigger(0, 123, null);

            Assert.False(outcome);
        }
        public void InvalidTrigger()
        {
            using var uut = new RequestCorrespondances();
            var req = uut.Request("nothing.really", Array.Empty <object>(), thing => thing as Gizmo ?? throw new InvalidCastException());

            Assert.Throws <NotImplementedException>(() => uut.Trigger(req.request.id, null, null));
        }
        public async Task SuccessfulYetFailingAsync()
        {
            using var uut = new RequestCorrespondances();
            var req  = uut.Request("nothing.really", Array.Empty <object>(), thing => thing as Gizmo ?? throw new InvalidCastException());
            var trig = uut.Trigger(req.request.id, 123, null);

            Assert.True(trig);
            await Assert.ThrowsAsync <InvalidCastException>(async() => await req.task);
        }
        async public Task ErroredAsync()
        {
            using var uut = new RequestCorrespondances();
            var req  = uut.Request("nothing.really", Array.Empty <object>(), thing => thing as Gizmo ?? throw new InvalidCastException());
            var trig = uut.Trigger(req.request.id, null, "gone wrong");

            Assert.True(trig);
            await Assert.ThrowsAsync <JsonRpc.FailedMethodException>(async() => await req.task);
        }
        public void RequestOwnsArgs()
        {
            using var uut = new RequestCorrespondances();
            var sillyArgs = new object[] {
                true,
                1234
            };
            var gen = uut.Request("dontcare", sillyArgs, got => true);

            Assert.Same(sillyArgs, gen.request.args);
        }
        public void CanRequestWithoutArgs()
        {
            var stupidMethodName = "some.method-thisSTRINGisOpaque";

            using var uut = new RequestCorrespondances();
            var gen = uut.Request(stupidMethodName, Array.Empty <object>(), got => true);

            Assert.Same(stupidMethodName, gen.request.method);
            Assert.Equal(Array.Empty <object>(), gen.request.args);
            Assert.Equal(1u, gen.request.id);
        }
        async public Task SuccessfulAsync()
        {
            var resPayload = "abcd";

            using var uut = new RequestCorrespondances();
            var req  = uut.Request("nothing.really", Array.Empty <object>(), thing => thing as Gizmo ?? throw new InvalidCastException());
            var trig = uut.Trigger(req.request.id, new Gizmo()
            {
                payload = resPayload
            }, null);
            var result = await req.task;

            Assert.True(trig);
            Assert.Equal(resPayload, result.payload);
        }