示例#1
0
        private static MockClient <IWampClientProxy <MockRaw> > GetSubscriber(Type scenario, WampMockClientBuilder <MockRaw> clientBuilder, IWampIncomingMessageHandler <MockRaw, IWampClientProxy <MockRaw> > handler, IEnumerable <WampMessage <MockRaw> > calls)
        {
            WampMessage <MockRaw> welcome =
                GetCalls(scenario, Channel.BrokerToSubscriber,
                         new WampMessageType[] { WampMessageType.v2Welcome })
                .FirstOrDefault();

            // TODO: After enough events unsubscribe.
            NullPlayer <MockRaw> nullPlayer =
                new NullPlayer <MockRaw>();

            IMessageRecorder <MockRaw> recorder =
                new ResponsiveMessageRecorder(calls,
                                              new Dictionary <WampMessageType, string>()
            {
                { WampMessageType.v2Subscribed, "subscriptionId" }
            });

            IWampClientProxy <MockRaw> built =
                clientBuilder.Create(nullPlayer,
                                     recorder,
                                     welcome);

            MockClient <IWampClientProxy <MockRaw> > result =
                new MockClient <IWampClientProxy <MockRaw> >(built, recorder);

            return(result);
        }
示例#2
0
        private static MockClient <IWampClientProxy <MockRaw> > GetPublisher(Type scenario, WampMockClientBuilder <MockRaw> builder, IEnumerable <WampMessage <MockRaw> > calls)
        {
            WampMessage <MockRaw> welcome =
                GetCalls(scenario, Channel.BrokerToPublisher,
                         new WampMessageType[] { WampMessageType.v2Welcome })
                .FirstOrDefault();

            long sessionId = (long)welcome.Arguments[0].Value;

            NullPlayer <MockRaw> nullPlayer =
                new NullPlayer <MockRaw>();

            IMessageRecorder <MockRaw> recorder =
                new ResponsiveMessageRecorder(calls,
                                              new Dictionary <WampMessageType, string>()
            {
                { WampMessageType.v2Published, "publicationId" }
            });

            IWampClientProxy <MockRaw> built =
                builder.Create(nullPlayer,
                               recorder,
                               welcome);

            MockClient <IWampClientProxy <MockRaw> > result =
                new MockClient <IWampClientProxy <MockRaw> >(built, recorder);

            return(result);
        }
        private MockClient <IWampClientProxy <MockRaw> > GetCallee(Type scenario, WampMockClientBuilder <MockRaw> clientBuilder, IWampIncomingMessageHandler <MockRaw, IWampClientProxy <MockRaw> > handler)
        {
            WampMessage <MockRaw> welcome =
                GetCalls(scenario, Channel.DealerToCallee,
                         new WampMessageType[] { WampMessageType.v2Welcome })
                .FirstOrDefault();

            IEnumerable <WampMessage <MockRaw> > calls =
                GetCalls(scenario, Channel.CalleeToDealer, MessageTypes.Rpc).Concat
                    (GetCalls(scenario, Channel.DealerToCallee, MessageTypes.Rpc)).ToList();

            CalleeMessagePlayer player =
                new CalleeMessagePlayer(calls,
                                        new[] { WampMessageType.v2Invocation },
                                        handler);

            IMessageRecorder <MockRaw> recorder =
                new ResponsiveMessageRecorder(calls,
                                              new Dictionary <WampMessageType, string>()
            {
                { WampMessageType.v2Registered, "registrationId" }
            });

            IWampClientProxy <MockRaw> built =
                clientBuilder.Create(player,
                                     recorder,
                                     welcome);

            player.Client = built;

            MockClient <IWampClientProxy <MockRaw> > result =
                new MockClient <IWampClientProxy <MockRaw> >(built, recorder);

            return(result);
        }
示例#4
0
        public static IEnumerable <TestCaseData> TestCases()
        {
            foreach (Type nestedType in typeof(TestHelpers.PubSub).GetNestedTypes())
            {
                var publications =
                    GetCalls(nestedType, Channel.PublisherToBroker, new[] { WampMessageType.v2Publish });

                var publicationAcks =
                    GetCalls(nestedType, Channel.BrokerToPublisher, new[] { WampMessageType.v2Published })
                    .ToArray();

                var publicationErrors =
                    GetCalls(nestedType, Channel.BrokerToPublisher, new[] { WampMessageType.v2Error });

                var subscriptions =
                    GetCalls(nestedType, Channel.SubscriberToBroker, new[] { WampMessageType.v2Subscribe });

                var subscriptionAcks =
                    GetCalls(nestedType, Channel.BrokerToSubscriber, new[] { WampMessageType.v2Subscribed })
                    .ToArray();

                var events =
                    GetCalls(nestedType, Channel.BrokerToSubscriber, new[] { WampMessageType.v2Event })
                    .ToArray();

                BrokerScenario scenario = new BrokerScenario();

                scenario.Publications      = publications;
                scenario.PublicationAcks   = publicationAcks;
                scenario.PublicationErrors = publicationErrors;
                scenario.Subscriptions     = subscriptions;
                scenario.Events            = events;

                MockClient <IWampClientProxy <MockRaw> > subscriber = GetSubscriber(nestedType, scenario.ClientBuilder, scenario.Handler, events.Concat(subscriptionAcks));
                MockClient <IWampClientProxy <MockRaw> > publisher  = GetPublisher(nestedType, scenario.ClientBuilder, publicationAcks);

                scenario.Subscriber = subscriber;
                scenario.Publisher  = publisher;

                TestCaseData testCase = new TestCaseData(scenario);
                testCase.SetName(string.Format("PubSubIntegrationTest.{0}",
                                               nestedType.Name));

                yield return(testCase);
            }
        }
        public IEnumerable <TestCaseData> TestCases()
        {
            foreach (Type nestedType in typeof(TestHelpers.Rpc).GetNestedTypes())
            {
                var scenarioCalls =
                    GetCalls(nestedType, Channel.CallerToDealer, MessageTypes.Rpc)
                    .Concat(GetCalls(nestedType, Channel.DealerToCaller, MessageTypes.Rpc))
                    .GroupBy(x => x.GetRequestId())
                    .Where(x => x.Key != null);

                var registrations =
                    GetCalls(nestedType, Channel.CalleeToDealer,
                             new WampMessageType[] { WampMessageType.v2Register });

                foreach (var currentCase in scenarioCalls)
                {
                    DealerScenario scenario = new DealerScenario();

                    MockClient <IWampClientProxy <MockRaw> > callee = GetCallee(nestedType, scenario.ClientBuilder, scenario.Handler);
                    MockClient <IWampClientProxy <MockRaw> > caller = GetCaller(nestedType, scenario.ClientBuilder);

                    WampMessage <MockRaw> request =
                        currentCase.FirstOrDefault(x => x.MessageType == WampMessageType.v2Call);

                    WampMessage <MockRaw>[] responses =
                        currentCase.Where(x => x.MessageType != WampMessageType.v2Call)
                        .ToArray();

                    scenario.Call = new DealerCall()
                    {
                        Request   = request,
                        Responses = responses
                    };
                    scenario.Registrations = registrations;
                    scenario.Callee        = callee;
                    scenario.Caller        = caller;

                    TestCaseData testCase = new TestCaseData(scenario);
                    testCase.SetName(string.Format("DealerIntegrationTest.{0}.{1}",
                                                   nestedType.Name,
                                                   request.Arguments[2].Value));

                    yield return(testCase);
                }
            }
        }
        private static MockClient <IWampClientProxy <MockRaw> > GetCaller(Type scenario, WampMockClientBuilder <MockRaw> builder)
        {
            WampMessage <MockRaw> welcome =
                GetCalls(scenario, Channel.DealerToCaller,
                         new WampMessageType[] { WampMessageType.v2Welcome })
                .FirstOrDefault();

            NullPlayer <MockRaw> nullPlayer =
                new NullPlayer <MockRaw>();

            IMessageRecorder <MockRaw> messageRecorder =
                new MessageRecorder <MockRaw>();

            IWampClientProxy <MockRaw> built =
                builder.Create(nullPlayer,
                               messageRecorder,
                               welcome);

            MockClient <IWampClientProxy <MockRaw> > result =
                new MockClient <IWampClientProxy <MockRaw> >(built, messageRecorder);

            return(result);
        }