Exemplo n.º 1
0
        public async Task Should_keep_track_of_only_the_last_value()
        {
            ILatestFilter <ConsumeContext <A> > latestFilter = null;

            IPipe <ConsumeContext <A> > pipe = Pipe.New <ConsumeContext <A> >(x =>
            {
                x.UseLatest(l => l.Created = filter => latestFilter = filter);
                x.UseExecute(payload =>
                {
                });
            });

            latestFilter.ShouldNotBe(null);

            for (int i = 0; i <= 100; i++)
            {
                var context = new TestConsumeContext <A>(new A {
                    Index = i
                });
                await pipe.Send(context);
            }

            ConsumeContext <A> latest = await latestFilter.Latest;

            latest.Message.Index.ShouldBe(100);
        }
Exemplo n.º 2
0
        public async Task Should_keep_track_of_only_the_last_value()
        {
            ILatestFilter <IInputContext <A> > latestFilter = null;

            IPipe <IInputContext <A> > pipe = Pipe.New <IInputContext <A> >(x =>
            {
                x.UseLatest(l => l.Created = filter => latestFilter = filter);
                x.UseExecute(payload =>
                {
                });
            });

            Assert.That(latestFilter, Is.Not.Null);

            var inputContext = new InputContext(new object());

            var limit = 100;

            for (var i = 0; i <= limit; i++)
            {
                var context = new InputContext <A>(inputContext, new A {
                    Index = i
                });
                await pipe.Send(context);
            }

            IInputContext <A> latest = await latestFilter.Latest;

            Assert.That(latest.Value.Index, Is.EqualTo(limit));
        }