Exemplo n.º 1
0
        private static Task <IConnection> ConnectAndOutOfSyncOnData(string url, ConnectionOptions opts, CancellationToken ct)
        {
            return(TestConnection.Connect(
                       url,
                       opts,
                       ct,
                       transform: (ConnectionStepResult res) =>
            {
                // replace subscription/data pdu with subscription/info
                var ev = res.AsUnsolicitedEvent();
                if (ev != null && ev.pdu.Action.StartsWith(RtmActions.SubscriptionData, StringComparison.InvariantCulture))
                {
                    var oldPdu = ev.pdu.As <RtmSubscriptionData>();
                    var newPdu = Pdu.Create(
                        action: RtmActions.SubscriptionError,
                        id: null,
                        body: new RtmSubscriptionError {
                        Code = RtmSubscriptionError.OutOfSync,
                        SubscriptionId = oldPdu.Body.SubscriptionId,
                        Position = oldPdu.Body.Position
                    });
                    return new ConnectionStepResult.UnsolicitedEvent(newPdu);
                }

                return res;
            }));
        }
Exemplo n.º 2
0
        public async Task RestartOnUnsubscribeError()
        {
            var channel = GenerateRandomChannelName();
            var client  = new RtmClientBuilder(Config.Endpoint, Config.AppKey)
                          .SetConnector(
                (url, opts, ct) => TestConnection.Connect(
                    url,
                    opts,
                    ct,
                    transform: res =>
            {
                var reply = res.AsReply()?.AsPositive();
                if (reply != null && reply.pdu.Action.StartsWith(RtmActions.Unsubscribe, StringComparison.InvariantCulture))
                {
                    var oldPdu = reply.pdu.As <RtmUnsubscribeReply>();
                    var newPdu = Pdu.Create <RtmUnsubscribeError>(
                        action: $"{RtmActions.Unsubscribe}/{RtmOutcomes.Error}",
                        id: oldPdu.Id,
                        body: new RtmUnsubscribeError {
                        SubscriptionId = oldPdu.Body.SubscriptionId
                    });
                    return(new ConnectionOperationResult.Reply.Negative(newPdu));
                }

                return(res);
            })).Build();

            var queue  = client.CreateStateQueue();
            var subObs = new TestSubscriptionObserverQueue(queue);

            subObs.ObserveSubscriptionState();

            client.Start();
            await queue.AssertDequeue(
                "leave-stopped",
                "enter-connecting",
                "leave-connecting",
                "enter-connected");

            client.CreateSubscription(channel, SubscriptionModes.Advanced, subObs);
            await queue.AssertDequeue(
                "rtm:created",
                "rtm:enter-unsubscribed",
                "rtm:leave-unsubscribed",
                "rtm:enter-subscribing",
                "rtm:leave-subscribing",
                "rtm:enter-subscribed");

            client.RemoveSubscription(channel);

            await queue.AssertDequeue(
                "rtm:leave-subscribed",
                "rtm:enter-unsubscribing",
                "rtm:leave-unsubscribing",
                "rtm:enter-unsubscribed",
                "rtm:leave-unsubscribed",
                "rtm:deleted",
                "leave-connected",
                "enter-awaiting",
                "leave-awaiting",
                "enter-connecting",
                "leave-connecting",
                "enter-connected");

            await Task.Delay(200);

            await client.Yield();

            Assert.That(queue.TryDequeue(), Is.EqualTo(null));

            await client.Dispose();
        }