public void ComposingMiddlewaresShouldProducesACompositeMiddleware()
        {
            // Given
            var calls = new List <string>();

            VoidSyncMiddlewareFunc <string> func = str =>
            {
                calls.Add("Func");
            };

            VoidSyncMiddleware <string> MakeMiddleware(int count)
            {
                return((str, next) =>
                {
                    calls !.Add("Before" + count);
                    next(str);
                    calls.Add("After" + count);
                });
            }

            var middleware1 = MakeMiddleware(1);
            var middleware2 = MakeMiddleware(2);
            var middleware3 = MakeMiddleware(3);

            var context = "Hello world!";

            // When
            var middleware = middleware1.Compose(middleware2, middleware3);

            func.Combine(middleware)(context);

            // Then
            calls.Should().Equal("Before1", "Before2", "Before3", "Func", "After3", "After2", "After1");
        }
        public void CombineAMiddlewareAndAFuncShouldReturnAFuncThatCombinesThem()
        {
            // Given
            var calls = new List <string>();

            VoidSyncMiddlewareFunc <string> func = str =>
            {
                calls.Add($"Func: {str}");
            };

            VoidSyncMiddleware <string> middleware = (str, next) =>
            {
                calls.Add($"Before: {str}");
                next(str);
                calls.Add($"After: {str}");
            };

            var context = "Hello";

            // When
            middleware.Combine(func)(context);

            // Then
            calls.Should().Equal("Before: Hello", "Func: Hello", "After: Hello");
        }
Пример #3
0
 public static VoidSyncMiddlewareFunc <TContext> Combine <TContext>(
     this VoidSyncMiddleware <TContext> middleware,
     VoidSyncMiddlewareFunc <TContext> func) =>
 context => middleware(context, func);