示例#1
0
    public async Task DefaultAddressBinderBindsToHttpPort5000()
    {
        var logger    = new MockLogger();
        var addresses = new ServerAddressesFeature();
        var services  = new ServiceCollection();

        services.AddLogging();
        var options = new KestrelServerOptions()
        {
            ApplicationServices = services.BuildServiceProvider()
        };

        var endpoints = new List <ListenOptions>();

        var addressBindContext = TestContextFactory.CreateAddressBindContext(
            addresses,
            options,
            logger,
            listenOptions =>
        {
            endpoints.Add(listenOptions);
            return(Task.CompletedTask);
        });

        await AddressBinder.BindAsync(options.ListenOptions, addressBindContext, CancellationToken.None);

        Assert.Contains(endpoints, e => e.IPEndPoint.Port == 5000 && !e.IsTls);
    }
示例#2
0
    public TestInput(KestrelTrace log = null, ITimeoutControl timeoutControl = null)
    {
        _memoryPool = PinnedBlockMemoryPoolFactory.Create();
        var options = new PipeOptions(pool: _memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
        var pair    = DuplexPipe.CreateConnectionPair(options, options);

        Transport   = pair.Transport;
        Application = pair.Application;

        var connectionFeatures = new FeatureCollection();

        connectionFeatures.Set(Mock.Of <IConnectionLifetimeFeature>());

        Http1ConnectionContext = TestContextFactory.CreateHttpConnectionContext(
            serviceContext: new TestServiceContext
        {
            Log = log ?? new KestrelTrace(NullLoggerFactory.Instance)
        },
            connectionContext: Mock.Of <ConnectionContext>(),
            transport: Transport,
            timeoutControl: timeoutControl ?? Mock.Of <ITimeoutControl>(),
            memoryPool: _memoryPool,
            connectionFeatures: connectionFeatures);

        Http1Connection = new Http1Connection(Http1ConnectionContext);
        Http1Connection.HttpResponseControl = Mock.Of <IHttpResponseControl>();
        Http1Connection.Reset();
    }
示例#3
0
    public void LogsInformationWhenKestrelAddressesAreOverridden()
    {
        var logger = new TestApplicationErrorLogger();

        var overriddenAddress = "http://localhost:5000";
        var addresses         = new ServerAddressesFeature();

        addresses.InternalCollection.Add(overriddenAddress);

        var options = new KestrelServerOptions();

        options.ListenAnyIP(8080);

        var addressBindContext = TestContextFactory.CreateAddressBindContext(
            addresses,
            options,
            logger,
            endpoint => Task.CompletedTask);

        addressBindContext.ServerAddressesFeature.PreferHostingUrls = true;

        var bindTask = AddressBinder.BindAsync(options.ListenOptions, addressBindContext, CancellationToken.None);

        Assert.True(bindTask.IsCompletedSuccessfully);

        var log = Assert.Single(logger.Messages);

        Assert.Equal(LogLevel.Information, log.LogLevel);
        Assert.Equal(CoreStrings.FormatOverridingWithPreferHostingUrls(nameof(addressBindContext.ServerAddressesFeature.PreferHostingUrls), overriddenAddress), log.Message);
    }
        public override void Initialize(TestContext context, MethodInfo methodInfo, object[] testMethodArguments, ITestOutputHelper testOutputHelper)
        {
            base.Initialize(context, methodInfo, testMethodArguments, testOutputHelper);

            _pipelineFactory = PinnedBlockMemoryPoolFactory.Create();
            var options = new PipeOptions(_pipelineFactory, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
            var pair    = DuplexPipe.CreateConnectionPair(options, options);

            _transport   = pair.Transport;
            _application = pair.Application;

            var connectionFeatures = new FeatureCollection();

            connectionFeatures.Set(Mock.Of <IConnectionLifetimeFeature>());

            _serviceContext = new TestServiceContext(LoggerFactory)
            {
                Scheduler = PipeScheduler.Inline
            };

            _timeoutControl         = new Mock <ITimeoutControl>();
            _http1ConnectionContext = TestContextFactory.CreateHttpConnectionContext(
                serviceContext: _serviceContext,
                connectionContext: Mock.Of <ConnectionContext>(),
                transport: pair.Transport,
                timeoutControl: _timeoutControl.Object,
                memoryPool: _pipelineFactory,
                connectionFeatures: connectionFeatures);

            _http1Connection = new TestHttp1Connection(_http1ConnectionContext);
        }
示例#5
0
        public virtual void GlobalSetup()
        {
            _memoryPool = SlabMemoryPoolFactory.Create();
            _httpFrame  = new Http2Frame();

            var options = new PipeOptions(_memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);

            _connectionPair = DuplexPipe.CreateConnectionPair(options, options);

            _httpRequestHeaders = new HttpRequestHeaders();
            _httpRequestHeaders.HeaderMethod    = new StringValues("GET");
            _httpRequestHeaders.HeaderPath      = new StringValues("/");
            _httpRequestHeaders.HeaderScheme    = new StringValues("http");
            _httpRequestHeaders.HeaderAuthority = new StringValues("localhost:80");

            _headersBuffer = new byte[1024 * 16];
            _hpackEncoder  = new HPackEncoder();

            var serviceContext = TestContextFactory.CreateServiceContext(
                serverOptions: new KestrelServerOptions(),
                dateHeaderValueManager: new DateHeaderValueManager(),
                systemClock: new MockSystemClock(),
                log: new MockTrace());

            serviceContext.DateHeaderValueManager.OnHeartbeat(default);
示例#6
0
    public StartLineTests()
    {
        MemoryPool = PinnedBlockMemoryPoolFactory.Create();
        var options = new PipeOptions(MemoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
        var pair    = DuplexPipe.CreateConnectionPair(options, options);

        Transport = pair.Transport;

        var serviceContext = TestContextFactory.CreateServiceContext(
            serverOptions: new KestrelServerOptions(),
            httpParser: new HttpParser <Http1ParsingHandler>());

        var connectionContext = TestContextFactory.CreateHttpConnectionContext(
            serviceContext: serviceContext,
            connectionContext: Mock.Of <ConnectionContext>(),
            transport: Transport,
            timeoutControl: new TimeoutControl(timeoutHandler: null),
            memoryPool: MemoryPool,
            connectionFeatures: new FeatureCollection());

        Http1Connection = new Http1Connection(connectionContext);

        Parser         = new HttpParser <Http1ParsingHandler>(showErrorDetails: true);
        ParsingHandler = new Http1ParsingHandler(Http1Connection);
    }
        public HttpProtocolFeatureCollection()
        {
            var memoryPool = SlabMemoryPoolFactory.Create();
            var options    = new PipeOptions(memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
            var pair       = DuplexPipe.CreateConnectionPair(options, options);

            var serviceContext = TestContextFactory.CreateServiceContext(
                serverOptions: new KestrelServerOptions(),
                httpParser: new HttpParser <Http1ParsingHandler>(),
                dateHeaderValueManager: new DateHeaderValueManager(),
                log: new MockTrace());

            var connectionContext = TestContextFactory.CreateHttpConnectionContext(
                serviceContext: serviceContext,
                connectionContext: null,
                transport: pair.Transport,
                memoryPool: memoryPool,
                connectionFeatures: new FeatureCollection());

            var http1Connection = new Http1Connection(connectionContext);

            http1Connection.Reset();

            _collection = http1Connection;
        }
示例#8
0
        public async Task WriteDataRateTimeoutAbortsConnection()
        {
            var mockConnectionContext = new Mock <ConnectionContext>();

            var httpConnectionContext = TestContextFactory.CreateHttpConnectionContext(
                serviceContext: new TestServiceContext(),
                connectionContext: mockConnectionContext.Object,
                connectionFeatures: new FeatureCollection(),
                transport: new DuplexPipe(Mock.Of <PipeReader>(), Mock.Of <PipeWriter>()));

            var httpConnection = new HttpConnection(httpConnectionContext);

            var aborted         = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
            var http1Connection = new Http1Connection(httpConnectionContext);

            httpConnection.Initialize(http1Connection);
            http1Connection.Reset();
            http1Connection.RequestAborted.Register(() =>
            {
                aborted.SetResult();
            });

            httpConnection.OnTimeout(TimeoutReason.WriteDataRate);

            mockConnectionContext
            .Verify(c => c.Abort(It.Is <ConnectionAbortedException>(ex => ex.Message == CoreStrings.ConnectionTimedBecauseResponseMininumDataRateNotSatisfied)),
                    Times.Once);

            await aborted.Task.DefaultTimeout();
        }
示例#9
0
        private TestHttp1Connection MakeHttp1Connection()
        {
            var options = new PipeOptions(_memoryPool, useSynchronizationContext: false);
            var pair    = DuplexPipe.CreateConnectionPair(options, options);

            _pair = pair;

            var serviceContext = TestContextFactory.CreateServiceContext(
                serverOptions: new KestrelServerOptions(),
                httpParser: new HttpParser <Http1ParsingHandler>(),
                dateHeaderValueManager: new DateHeaderValueManager());

            var connectionContext = TestContextFactory.CreateHttpConnectionContext(
                serviceContext: serviceContext,
                connectionContext: null,
                transport: pair.Transport,
                timeoutControl: new TimeoutControl(timeoutHandler: null),
                memoryPool: _memoryPool,
                connectionFeatures: new FeatureCollection());

            var http1Connection = new TestHttp1Connection(connectionContext);

            http1Connection.Reset();
            http1Connection.InitializeBodyControl(MessageBody.ZeroContentLengthKeepAlive);
            serviceContext.DateHeaderValueManager.OnHeartbeat(DateTimeOffset.UtcNow);

            return(http1Connection);
        }
示例#10
0
    public void GlobalSetup()
    {
        _memoryPool = PinnedBlockMemoryPoolFactory.Create();

        var options = new PipeOptions(_memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);

        _pipe = new Pipe(options);

        var serviceContext = TestContextFactory.CreateServiceContext(
            serverOptions: new KestrelServerOptions(),
            httpParser: new HttpParser <Http1ParsingHandler>(),
            dateHeaderValueManager: new DateHeaderValueManager());

        _frameWriter = new Http2FrameWriter(
            new NullPipeWriter(),
            connectionContext: null,
            http2Connection: null,
            maxStreamsPerConnection: 1,
            timeoutControl: null,
            minResponseDataRate: null,
            "TestConnectionId",
            _memoryPool,
            serviceContext);

        _responseHeaders = new HttpResponseHeaders();
        var headers = (IHeaderDictionary)_responseHeaders;

        headers.ContentType   = "application/json";
        headers.ContentLength = 1024;
    }
示例#11
0
        public void GlobalSetup()
        {
            _memoryPool = SlabMemoryPoolFactory.Create();

            var options = new PipeOptions(_memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);

            _pipe = new Pipe(options);

            var serviceContext = TestContextFactory.CreateServiceContext(
                serverOptions: new KestrelServerOptions(),
                httpParser: new HttpParser <Http1ParsingHandler>(),
                dateHeaderValueManager: new DateHeaderValueManager(),
                log: new MockTrace());

            _frameWriter = new Http2FrameWriter(
                new NullPipeWriter(),
                connectionContext: null,
                http2Connection: null,
                new OutputFlowControl(new SingleAwaitableProvider(), initialWindowSize: int.MaxValue),
                timeoutControl: null,
                minResponseDataRate: null,
                "TestConnectionId",
                _memoryPool,
                serviceContext);

            _responseHeaders = new HttpResponseHeaders();
            _responseHeaders.HeaderContentType   = "application/json";
            _responseHeaders.HeaderContentLength = "1024";
        }
        public void Setup()
        {
            _memoryPool = PinnedBlockMemoryPoolFactory.Create();
            var options = new PipeOptions(_memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
            var pair    = DuplexPipe.CreateConnectionPair(options, options);

            var serviceContext = TestContextFactory.CreateServiceContext(
                serverOptions: new KestrelServerOptions(),
                httpParser: new HttpParser <Http1ParsingHandler>(),
                dateHeaderValueManager: new DateHeaderValueManager(),
                log: new MockTrace());

            var connectionContext = TestContextFactory.CreateHttpConnectionContext(
                serviceContext: serviceContext,
                connectionContext: null,
                transport: pair.Transport,
                memoryPool: _memoryPool,
                connectionFeatures: new FeatureCollection(),
                timeoutControl: new TimeoutControl(timeoutHandler: null));

            var http1Connection = new Http1Connection(connectionContext);

            http1Connection.Reset();

            Http1Connection = http1Connection;
            Pipe            = new Pipe(new PipeOptions(_memoryPool));
        }
示例#13
0
 public void SetUp()
 {
     testContext = TestContextFactory.Get(opts => opts
                                          .UseEntryAssembly(typeof(WindsorRegistrationOptionsTestCase).Assembly)
                                          .RegisterTagHelpers(typeof(OverrideTagHelper).Assembly)
                                          .RegisterControllers(typeof(OverrideController).Assembly)
                                          .RegisterTagHelpers(typeof(OverrideViewComponent).Assembly));
 }
示例#14
0
 public static void RunTests(KontrolRegistry registry, ITestReporter reporter,
                             TestContextFactory contextFactory)
 {
     foreach (IKontrolModule module in registry.modules.Values)
     {
         RunTests(module, reporter, contextFactory);
     }
 }
 public override void SetUp()
 {
     testContext = TestContextFactory.Get(opts => opts
                                          .UseEntryAssembly(typeof(WindsorRegistrationOptionsTestCase).Assembly)
                                          .RegisterTagHelpers(Component.For <OverrideTagHelper>().LifestyleScoped().Named("tag-helpers"))
                                          .RegisterControllers(Component.For <OverrideController>().LifestyleScoped().Named("controllers"))
                                          .RegisterViewComponents(Component.For <OverrideViewComponent>().LifestyleScoped().Named("view-components")));
 }
示例#16
0
        public Http3HttpProtocolFeatureCollectionTests()
        {
            var streamContext = TestContextFactory.CreateHttp3StreamContext(transport: DuplexPipe.CreateConnectionPair(new PipeOptions(), new PipeOptions()).Application);

            var http3Stream = new TestHttp3Stream(streamContext);

            http3Stream.Reset();
            _http3Collection = http3Stream;
        }
示例#17
0
        public TestContextFixture()
        {
            SourcePath = Path.Combine(Directory.GetCurrentDirectory(), SOURCE_DIRECTORY);

            CompilationUnitFactory = new TestCompilationUnitFactory();
            DataProvider           = new TestDataProvider(Path.Combine(SourcePath, COMPILER_TESTS_FILE_NAME));
            TestContextFactory     = new TestContextFactory(SourcePath, DataProvider);
            FileComparer           = new IgnoredCharactersStringComparer("\r\n");
        }
        public void Setup()
        {
            var memoryPool = PinnedBlockMemoryPoolFactory.Create();
            var options    = new PipeOptions(memoryPool, readerScheduler: PipeScheduler.Inline, writerScheduler: PipeScheduler.Inline, useSynchronizationContext: false);
            var pair       = DuplexPipe.CreateConnectionPair(options, options);

            var serviceContext = TestContextFactory.CreateServiceContext(
                serverOptions: new KestrelServerOptions(),
                httpParser: new HttpParser <Http1ParsingHandler>(),
                dateHeaderValueManager: _dateHeaderValueManager,
                log: new MockTrace());

            var connectionContext = TestContextFactory.CreateHttpConnectionContext(
                serviceContext: serviceContext,
                connectionContext: null,
                transport: pair.Transport,
                memoryPool: memoryPool,
                connectionFeatures: new FeatureCollection());

            var http1Connection = new Http1Connection(connectionContext);

            http1Connection.Reset();
            serviceContext.DateHeaderValueManager.OnHeartbeat(DateTimeOffset.UtcNow);

            _responseHeadersDirect = (HttpResponseHeaders)http1Connection.ResponseHeaders;
            var context = new DefaultHttpContext(http1Connection);

            _response = context.Response;

            switch (Type)
            {
            case BenchmarkTypes.ContentLengthNumeric:
                SetContentLengthNumeric(1);
                GetContentLengthNumeric(1);
                break;

            case BenchmarkTypes.ContentLengthString:
                SetContentLengthString(1);
                GetContentLengthString(1);
                break;

            case BenchmarkTypes.Plaintext:
                SetPlaintext(1);
                GetPlaintext(1);
                break;

            case BenchmarkTypes.Common:
                SetCommon(1);
                GetCommon(1);
                break;

            case BenchmarkTypes.Unknown:
                SetUnknown(1);
                GetUnknown(1);
                break;
            }
        }
示例#19
0
        public static TestResult RunTest(IKontrolModule module, IKontrolFunction testFunction,
                                         TestContextFactory contextFactory)
        {
            TestRunnerContext testContext = contextFactory();

            try {
                testContext.ResetTimeout();
                object testReturn = testFunction.Invoke(testContext);

                switch (testReturn)
                {
                case bool booleanResult when !booleanResult:
                    return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount,
                                          "Returned false", testContext.Messages));

                case IAnyOption option when !option.Defined:
                    return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount,
                                          "Returned None", testContext.Messages));

                case IAnyResult result when !result.Success:
                    return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount,
                                          $"Returned Err({result.ErrorString})", testContext.Messages));

                case IAnyFuture future:
                    ContextHolder.CurrentContext.Value = testContext;
                    for (int i = 0; i < 100; i++)
                    {
                        testContext.IncrYield();
                        testContext.ResetTimeout();
                        IAnyFutureResult result = future.Poll();
                        if (result.IsReady)
                        {
                            return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount,
                                                  testContext.Messages));
                        }
                    }

                    return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount,
                                          "Future did not become ready", testContext.Messages));

                default:
                    return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount,
                                          testContext.Messages));
                }
            } catch (AssertException e) {
                return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount, e.Message,
                                      testContext.Messages));
            } catch (Exception e) {
                Console.Error.WriteLine(e);
                return(new TestResult(module.Name + "::" + testFunction.Name, testContext.AssertionsCount, e,
                                      testContext.Messages));
            } finally {
                ContextHolder.CurrentContext.Value = null;
            }
        }
示例#20
0
        public Http2HttpProtocolFeatureCollectionTests()
        {
            var context = TestContextFactory.CreateHttp2StreamContext(
                serviceContext: new TestServiceContext(),
                timeoutControl: Mock.Of <ITimeoutControl>());

            var http2Stream = new TestHttp2Stream(context);

            http2Stream.Reset();
            _http2Collection = http2Stream;
        }
示例#21
0
        // Create test data and pass repositories to access it in callback
        private void RunTest(Action <RepositoryEnq> test = null
                             , Action <RepositoryEnq, RepositoryEnq> testMulti = null)
        {
            using var factory = new TestContextFactory(_data);
            using var context = factory.GetContext();

            var repo = new RepositoryEnq(context);

            test?.Invoke(repo);
            testMulti?.Invoke(repo, new RepositoryEnq(context));
        }
示例#22
0
        private async Task RunTestAsync(Func <RepositoryEnq, Task> test = null
                                        , Func <RepositoryEnq, RepositoryEnq, Task> testMulti = null)
        {
            using var factory       = new TestContextFactory(_data);
            await using var context = factory.GetContext();

            RepositoryEnq repo = new RepositoryEnq(context);

            await(test?.Invoke(repo) ?? Task.CompletedTask);
            await(testMulti?.Invoke(repo, new RepositoryEnq(context)) ?? Task.CompletedTask);
        }
示例#23
0
    public Http3HttpProtocolFeatureCollectionTests()
    {
        var connectionFeatures = new TestConnectionFeatures().FeatureCollection;

        var streamContext = TestContextFactory.CreateHttp3StreamContext(
            transport: DuplexPipe.CreateConnectionPair(new PipeOptions(), new PipeOptions()).Application,
            connectionFeatures: connectionFeatures);

        var http3Stream = new TestHttp3Stream();

        http3Stream.Initialize(streamContext);
        _http3Collection = http3Stream;
    }
示例#24
0
        public Http1HttpProtocolFeatureCollectionTests()
        {
            var context = TestContextFactory.CreateHttpConnectionContext(
                connectionContext: Mock.Of <ConnectionContext>(),
                serviceContext: new TestServiceContext(),
                transport: Mock.Of <IDuplexPipe>(),
                connectionFeatures: new FeatureCollection(),
                timeoutControl: Mock.Of <ITimeoutControl>());

            _httpConnectionContext = context;
            _http1Connection       = new TestHttp1Connection(context);
            _http1Connection.Reset();
            _collection = _http1Connection;
        }
示例#25
0
        public void TestInit()
        {
            this._contextFactory = new TestContextFactory(_connection);

            var node     = new Uri(ConfigurationManager.AppSettings["Search-Uri"]);
            var settings = new ConnectionSettings(node);

            settings.ThrowExceptions(alwaysThrow: true);
            settings.PrettyJson(true);
            settings.DisableDirectStreaming();

            var client = new ElasticClient(settings);

            this._service = new SearchService(client, _contextFactory);
        }
示例#26
0
        public static void RunTests(IKontrolModule module, ITestReporter reporter, TestContextFactory contextFactory)
        {
            if (!module.TestFunctions.Any())
            {
                return;
            }

            reporter.BeginModule(module.Name);
            foreach (IKontrolFunction testFunction in module.TestFunctions)
            {
                reporter.Report(RunTest(module, testFunction, contextFactory));
            }

            reporter.EndModule(module.Name);
        }
示例#27
0
    public async Task WrapsAddressInUseExceptionAsIOException()
    {
        var addresses = new ServerAddressesFeature();

        addresses.InternalCollection.Add("http://localhost:5000");
        var options = new KestrelServerOptions();

        var addressBindContext = TestContextFactory.CreateAddressBindContext(
            addresses,
            options,
            NullLogger.Instance,
            endpoint => throw new AddressInUseException("already in use"));

        await Assert.ThrowsAsync <IOException>(() =>
                                               AddressBinder.BindAsync(options.ListenOptions, addressBindContext, CancellationToken.None));
    }
    public static WebTransportStream CreateStream(WebTransportStreamType type, Memory <byte>?memory = null)
    {
        var features = new FeatureCollection();

        features.Set <IStreamIdFeature>(new StreamId(streamCounter++));
        features.Set <IStreamDirectionFeature>(new DefaultStreamDirectionFeature(type != WebTransportStreamType.Output, type != WebTransportStreamType.Input));
        features.Set(Mock.Of <IConnectionItemsFeature>());
        features.Set(Mock.Of <IProtocolErrorCodeFeature>());

        var writer = new HttpResponsePipeWriter(new StreamWriterControl(memory));

        writer.StartAcceptingWrites();
        var transport = new DuplexPipe(new StreamReader(memory), writer);

        return(new WebTransportStream(TestContextFactory.CreateHttp3StreamContext("id", null, new TestServiceContext(), features, null, null, null, transport), type));
    }
示例#29
0
        private LibuvOuputProcessor CreateOutputProducer(PipeOptions pipeOptions, CancellationTokenSource cts = null)
        {
            var pair = DuplexPipe.CreateConnectionPair(pipeOptions, pipeOptions);

            var logger         = new TestApplicationErrorLogger();
            var serviceContext = new TestServiceContext
            {
                Log       = new TestKestrelTrace(logger),
                Scheduler = PipeScheduler.Inline
            };
            var transportContext = new TestLibuvTransportContext {
                Log = new LibuvTrace(logger)
            };

            var socket   = new MockSocket(_mockLibuv, _libuvThread.Loop.ThreadId, transportContext.Log);
            var consumer = new LibuvOutputConsumer(pair.Application.Input, _libuvThread, socket, "0", transportContext.Log);

            var connectionFeatures = new FeatureCollection();

            connectionFeatures.Set(Mock.Of <IConnectionLifetimeFeature>());

            var connectionContext = TestContextFactory.CreateHttpConnectionContext(
                serviceContext: serviceContext,
                connectionContext: Mock.Of <ConnectionContext>(),
                transport: pair.Transport,
                memoryPool: _memoryPool,
                connectionFeatures: connectionFeatures,
                timeoutControl: Mock.Of <ITimeoutControl>());

            var http1Connection = new Http1Connection(connectionContext);

            if (cts != null)
            {
                http1Connection.RequestAborted.Register(cts.Cancel);
            }

            var outputTask = WriteOutputAsync(consumer, pair.Application.Input, http1Connection);

            var processor = new LibuvOuputProcessor
            {
                ProcessingTask = outputTask,
                OutputProducer = (Http1OutputProducer)http1Connection.Output,
                PipeWriter     = pair.Transport.Output,
            };

            return(processor);
        }
示例#30
0
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            _logger.LogInformation("App Start at: {time}", DateTimeOffset.Now);

            var contextFactory = new TestContextFactory
            {
                Configuration = _configuration
            };

            await using (var dbContext = contextFactory.CreateDbContext(Array.Empty <string>()))
            {
                var db = dbContext.Database;
                await db.MigrateAsync(cancellationToken : cancellationToken);
            }

            _appLifetime.StopApplication();
        }