public async Task Cycles()
        {
            // arrange
            var port    = TcpHelper.Default.GetFreeDynamicPort();
            var logger  = new NullLogger <OutkeepHttpApiHostedService>();
            var options = new OutkeepHttpApiServerOptions
            {
                ApiUri = new Uri($"http://localhost:{port}")
            };
            var loggerProviders = new ILoggerProvider[] { NullLoggerProvider.Instance };
            var grainFactory    = Mock.Of <IGrainFactory>();

            // act
            var service = new OutkeepHttpApiHostedService(logger, Options.Create(options), loggerProviders, grainFactory);
            await service.StartAsync(default).ConfigureAwait(false);
Example #2
0
        public void ConfiguresOptions()
        {
            // arrange
            var groupName = "V1";
            var version   = new ApiVersion(1, 2);
            var title     = "Test";

            var descriptions = new List <ApiVersionDescription>
            {
                new ApiVersionDescription(version, groupName, false)
            };

            var provider = Mock.Of <IApiVersionDescriptionProvider>(x =>
                                                                    x.ApiVersionDescriptions == descriptions);

            var options = new OutkeepHttpApiServerOptions
            {
                Title = title
            };

            var configurator = new SwaggerGenOptionsConfigurator(provider, Options.Create(options));

            // act
            var target = new SwaggerGenOptions();

            configurator.Configure(target);

            // assert parameters are camel case
            Assert.True(target.SwaggerGeneratorOptions.DescribeAllParametersInCamelCase);

            // assert swagger page is added
            Assert.Contains(target.SwaggerGeneratorOptions.SwaggerDocs, x => x.Key == groupName && x.Value.Version == version.ToString() && x.Value.Title == title);

            // assert version is removed from parameters
            Assert.Contains(target.OperationFilterDescriptors, x => x.Type == typeof(RemoveVersionFromParametersOperationFilter));

            // assert version is replaced in path
            Assert.Contains(target.DocumentFilterDescriptors, x => x.Type == typeof(ReplaceVersionParameterInPathDocumentFilter));

            // assert comments are enabled
            Assert.Contains(target.SchemaFilterDescriptors, x => x.Type == typeof(XmlCommentsSchemaFilter));

            // assert annotations are enabled
            Assert.Contains(target.DocumentFilterDescriptors, x => x.Type == typeof(AnnotationsDocumentFilter));
            Assert.Contains(target.OperationFilterDescriptors, x => x.Type == typeof(AnnotationsOperationFilter));
            Assert.Contains(target.ParameterFilterDescriptors, x => x.Type == typeof(AnnotationsParameterFilter));
            Assert.Contains(target.SchemaFilterDescriptors, x => x.Type == typeof(AnnotationsSchemaFilter));
        }
Example #3
0
        public async Task Lifecycle()
        {
            // arrange
            var endpointOptions = new EndpointOptions
            {
                SiloPort    = 1234,
                GatewayPort = 2345
            };
            var httpApiOptions = new OutkeepHttpApiServerOptions
            {
                ApiUri = new Uri("http://localhost:3456")
            };

            // act
            var service = new ConsoleTitleService(Options.Create(endpointOptions), Options.Create(httpApiOptions));
            await service.StartAsync(default).ConfigureAwait(false);
Example #4
0
 public ConsoleTitleService(IOptions <EndpointOptions> endpointOptions, IOptions <OutkeepHttpApiServerOptions> httpApiOptions)
 {
     _endpointOptions = endpointOptions?.Value ?? throw new ArgumentNullException(nameof(endpointOptions));
     _httpApiOptions  = httpApiOptions?.Value ?? throw new ArgumentNullException(nameof(httpApiOptions));
 }