public async Task CertificateAuthenticationOption_GetHealthAuthenticated_ResultsOk() { // Arrange string subject = $"subject-{Guid.NewGuid()}"; var authenticatedProjectArguments = new WebApiProjectOptions() .WithCertificateSubjectAuthentication($"CN={subject}"); using (var project = await WebApiProject.StartNewAsync(authenticatedProjectArguments, _outputWriter)) using (var certificate = SelfSignedCertificate.CreateWithSubject(subject)) { project.TearDownOptions = TearDownOptions.KeepProjectDirectory; var clientCertificate = Convert.ToBase64String(certificate.RawData); // Act using (HttpResponseMessage response = await project.Health.GetAsync( request => request.Headers.Add("X-ARR-ClientCert", clientCertificate))) { // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.OK, response.StatusCode); } } }
public async Task JwtAuthenticationOption_GetSwaggerDocs_ContainsJwtSecurityScheme() { // Arrange string key = $"secret-{Guid.NewGuid()}"; string issuer = $"issuer-{Guid.NewGuid()}"; string audience = $"audience-{Guid.NewGuid()}"; string jwtToken = CreateToken(key, issuer, audience); var jwtHeader = AuthenticationHeaderValue.Parse("Bearer " + jwtToken); var options = new WebApiProjectOptions().WithJwtAuthentication(key, issuer, audience); using (var project = await WebApiProject.StartNewAsync(options, _outputWriter)) { // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); var reader = new OpenApiStreamReader(); using (Stream json = await response.Content.ReadAsStreamAsync()) { OpenApiDocument document = reader.Read(json, out OpenApiDiagnostic diagnostic); Assert.NotNull(document.Components); (string schemeName, OpenApiSecurityScheme componentScheme) = Assert.Single(document.Components.SecuritySchemes); Assert.Equal(SecuritySchemeType.Http, componentScheme.Type); OpenApiSecurityRequirement requirement = Assert.Single(document.SecurityRequirements); Assert.NotNull(requirement); (OpenApiSecurityScheme requirementScheme, IList <string> scopes) = Assert.Single(requirement); Assert.Equal("jwt", requirementScheme.Reference.Id); } } } }
public async Task GetSwaggerDocs_ReturnsDocsWithHealthEndpointResponseExample() { // Arrange var options = new WebApiProjectOptions(); using (var project = await WebApiProject.StartNewAsync(options, _outputWriter)) // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); string json = await response.Content.ReadAsStringAsync(); OpenApiDocument document = LoadOpenApiDocument(json); OpenApiOperation healthOperation = SelectGetHealthEndpoint(document); OpenApiResponse okResponse = healthOperation.Responses .Single(r => r.Key == "200").Value; OpenApiObject example = SelectHealthPointOkExample(okResponse); Assert.Contains("entries", example.Keys); var entriesCollection = (OpenApiObject)example["entries"]; Assert.Contains("api", entriesCollection.Keys); Assert.Contains("database", entriesCollection.Keys); } }
public async Task GetSabotagedEndpoint_TracksFailedResponse_ReturnsFailedResponse() { // Arrange var optionsWithSerilogLogging = new WebApiProjectOptions().WithSerilogLogging(ApplicationInsightsConfig.InstrumentationKey); using (var project = WebApiProject.CreateNew(Configuration, optionsWithSerilogLogging, Logger)) { project.AddTypeAsFile <SaboteurController>(); await project.StartAsync(); // Act using (HttpResponseMessage response = await project.Root.GetAsync(SaboteurController.Route)) { // Assert Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); await RetryAssertUntilTelemetryShouldBeAvailableAsync(async client => { EventsResults <EventsRequestResult> results = await client.Events.GetRequestEventsAsync(ApplicationInsightsConfig.ApplicationId, filter: OnlyLastHourFilter); Assert.Contains(results.Value, result => { return(result.Request.Url.Contains("sabotage") && result.Request.ResultCode == "500"); }); }); } } }
public async Task AppSettingsFile_GetsLoaded_WhenIncludeAppSettingsProjectOptionIsAdded(bool isToggled) { // Arrange var projectOptions = new WebApiProjectOptions().WithIncludeAppSettings(); using (var project = WebApiProject.CreateNew(projectOptions, _outputWriter)) { project.AddTypeAsFile <FeatureToggledController>(namespaces: "Controllers"); project.UpdateFileInProject( "appsettings.json", contents => AddJsonBoolValue(contents, key: FeatureToggle, value: isToggled)); await project.StartAsync(); // Act using (HttpResponseMessage response = await project.Root.GetAsync(Route)) { // Assert Assert.NotNull(response); Assert.True( response.IsSuccessStatusCode == isToggled, "Only when the feature toggle in the 'appsettings.json' is activated, should the controller response successful"); } } }
public async Task SharedAccessKeyAuthenticationOption_GetsSwaggerDocs_ContainsSharedAccessKeySecurityScheme() { // Arrange const string headerName = "x-shared-access-key"; const string secretKey = "MySecretKey"; string secretValue = Guid.NewGuid().ToString("N"); var authenticatedArguments = new WebApiProjectOptions() .WithSharedAccessAuthentication(headerName, secretKey, secretValue); using (var project = await WebApiProject.StartNewAsync(_configuration, authenticatedArguments, _outputWriter)) // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); var reader = new OpenApiStreamReader(); using (Stream json = await response.Content.ReadAsStreamAsync()) { OpenApiDocument document = reader.Read(json, out OpenApiDiagnostic diagnostic); Assert.NotNull(document.Components); (string schemeName, OpenApiSecurityScheme componentScheme) = Assert.Single(document.Components.SecuritySchemes); Assert.Equal("shared-access-key", schemeName); Assert.Equal(ParameterLocation.Header, componentScheme.In); Assert.Equal(headerName, componentScheme.Name); OpenApiSecurityRequirement requirement = Assert.Single(document.SecurityRequirements); Assert.NotNull(requirement); (OpenApiSecurityScheme requirementScheme, IList <string> scopes) = Assert.Single(requirement); Assert.Equal(headerName, requirementScheme.Name); } } }
public async Task ExampleProvidersIncluded_WithoutExcludeOpenApiDocs() { var options = new WebApiProjectOptions(); using (var project = await WebApiProject.StartNewAsync(options, _outputWriter)) { Assert.True(project.ContainsFile(Path.Combine("ExampleProviders", "HealthReportResponseExampleProvider.cs"))); } }
public async Task SecurityHeaders_BasicHttpCall_ServerHeaderNotReturned() { // Arrange using (WebApiProject project = await WebApiProject.StartNewAsync(_configuration, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert var containsAnyServerHeader = response.Headers.Any(header => header.Key.Equals("Server", StringComparison.InvariantCultureIgnoreCase)); Assert.False(containsAnyServerHeader); } }
public async Task GetSwaggerDocs_WithBuildConfiguration_ReturnsOk() { // Arrange using (var project = await WebApiProject.StartNewAsync(_outputWriter)) // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.OK, response.StatusCode); } }
public async Task Health_Get_Succeeds() { // Arrange using (WebApiProject project = await WebApiProject.StartNewAsync(_outputWriter)) { // Act HealthStatus status = await project.Health.GetHealthAsync(); // Assert Assert.Equal(HealthStatus.Healthy, status); } }
public async Task GetSwaggerDocs_WithoutOpenApiAndCorrelation_ReturnsNoSwaggerDocs() { // Arrange var options = new WebApiProjectOptions().WithExcludeOpenApiDocs().WithExcludeCorrelation(); using (var project = await WebApiProject.StartNewAsync(options, _outputWriter)) // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); } }
public async Task GetHealth_OutOfTheBox_ReturnsOkWithCorrelationHeaders() { // Arrange using (var project = await WebApiProject.StartNewAsync(_outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.NotNull(response); AssertNonBlankResponseHeader(response, OperationHeaderName); AssertNonBlankResponseHeader(response, TransactionHeaderName); } }
public async Task GetSwaggerDocs_WithBuildConfiguration_Returns(BuildConfiguration buildConfiguration, HttpStatusCode expectedStatusCode) { // Arrange var configuration = TestConfig.Create(buildConfiguration); using (var project = await WebApiProject.StartNewAsync(configuration, _outputWriter)) // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.NotNull(response); Assert.Equal(expectedStatusCode, response.StatusCode); } }
public async Task GetHealth_WithConsoleLoggingProjectOption_ReturnsOk() { // Arrange var optionsWithDefaultLogging = new WebApiProjectOptions().WithConsoleLogging(); using (var project = await WebApiProject.StartNewAsync(optionsWithDefaultLogging, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.OK, response.StatusCode); } }
public async Task GetHealth_WithoutCorrelationProjectOption_ReturnsOkWithoutCorrelationHeaders() { // Arrange var optionsWithCorrelation = new WebApiProjectOptions().WithExcludeCorrelation(); using (var project = await WebApiProject.StartNewAsync(optionsWithCorrelation, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.NotNull(response); Assert.DoesNotContain(response.Headers, h => h.Key == OperationHeaderName); Assert.DoesNotContain(response.Headers, h => h.Key == TransactionHeaderName); } }
public async Task GetHealth_WithSerilogLoggingProjectOption_ReturnsOk() { // Arrange string instrumentationKey = _configuration.GetApplicationInsightsInstrumentationKey(); var optionsWithSerilogLogging = new WebApiProjectOptions().WithSerilogLogging(instrumentationKey); using (var project = await WebApiProject.StartNewAsync(optionsWithSerilogLogging, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.OK, response.StatusCode); } }
public async Task Health_Get_Succeeds() { // Arrange using (WebApiProject project = await WebApiProject.StartNewAsync(_configuration, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); string healthReportJson = await response.Content.ReadAsStringAsync(); var healthReport = JsonConvert.DeserializeObject <HealthReport>(healthReportJson, new TimeSpanConverter()); Assert.NotNull(healthReport); Assert.Equal(HealthStatus.Healthy, healthReport.Status); } }
public async Task GetEnumEndpoint_WithEnumInput_ReturnsOk() { // Arrange using (var project = WebApiProject.CreateNew(_outputWriter)) { project.AddTypeAsFile <EnumController>(); project.AddTypeAsFile <TestEnum>(); await project.StartAsync(); using (var content = new StringContent("\"One\"", Encoding.UTF8, "application/json")) using (HttpResponseMessage response = await project.Root.GetAsync(EnumController.GetRoute, content)) { // Assert Assert.True(HttpStatusCode.OK == response.StatusCode, await response.Content.ReadAsStringAsync()); } } }
public async Task GetHealthWithoutBearerToken_WithJwtAuthenticationOption_ReturnsUnauthorized() { // Arrange string key = $"secret-{Guid.NewGuid()}"; string issuer = $"issuer-{Guid.NewGuid()}"; string audience = $"audience-{Guid.NewGuid()}"; var options = new WebApiProjectOptions().WithJwtAuthentication(key, issuer, audience); using (var project = await WebApiProject.StartNewAsync(options, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); } }
public ActionResult Register(LoadProjectsViewModel model, HttpPostedFileBase imageFile) { JSonResult objResult = new JSonResult(); string response = string.Empty; try { Session objSession = new Session() { UserId = AutenticationManager.GetUser().IdUsuario, }; List <MProject> entList = new List <MProject>(); List <ModelProjectResult> entListData = new List <ModelProjectResult>(); entListData = (List <ModelProjectResult>)Session["ListProjects"]; foreach (ModelProjectResult item in entListData) { MProject mProject = new MProject(); mProject.ProjectCode = item.ProjectCode; mProject.Description = item.Description; mProject.Type = item.Type; mProject.Status = item.Status; mProject.StartDate = Convert.ToInt32(Extension.ToFormatDateYYYYMMDD(item.StartDateStr)); mProject.EndDate = Convert.ToInt32(Extension.ToFormatDateYYYYMMDD(item.EndDateStr));//item.EndDate; mProject.Title = item.Title; mProject.AwardId = item.AwardId; mProject.AwardStatus = item.AwardStatus; entList.Add(mProject); } response = new WebApiProject().InsertProject(entList, objSession); string statusCode = response.Split('|')[0]; string statusMessage = response.Split('|')[1]; objResult.isError = statusCode.Equals("2"); objResult.message = string.Format(MessageResource.SaveSuccess, "Projects");; } catch (Exception ex) { objResult.message = string.Format(MessageResource.SaveError + "Error :" + ex.Message, "Projects"); } return(Json(objResult)); }
public async Task GetHealth_WithSerilogAndCertificateAuthentication_ReturnsUnauthorized() { // Arrange string subject = $"subject-{Guid.NewGuid()}"; string instrumentationKey = _configuration.GetApplicationInsightsInstrumentationKey(); var optionsWithSerilogAndCertificateAuth = new WebApiProjectOptions() .WithSerilogLogging(instrumentationKey) .WithCertificateSubjectAuthentication($"CN={subject}"); using (var project = await WebApiProject.StartNewAsync(_configuration, optionsWithSerilogAndCertificateAuth, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); } }
public async Task AppSettingsFile_DoesntGetsLoaded_WhenNoIncludeAppSettingsProjectOptionIsAdded() { // Arrange using (var project = WebApiProject.CreateNew(_outputWriter)) { project.AddTypeAsFile <FeatureToggledController>(namespaces: "Controllers"); await project.StartAsync(); // Act using (HttpResponseMessage response = await project.Root.GetAsync(Route)) { // Assert Assert.NotNull(response); Assert.False( response.IsSuccessStatusCode, "When no '--include-appsettings' project is added, the feature toggled controller should not response successful"); } } }
public async Task GetSwaggerDocs_WithOpenApiAndCorrelation_ReturnsDocsWithCorrelationHeaders() { // Arrange using (var project = await WebApiProject.StartNewAsync(_outputWriter)) // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { Assert.Equal(HttpStatusCode.OK, response.StatusCode); string json = await response.Content.ReadAsStringAsync(); OpenApiDocument document = LoadOpenApiDocument(json); IDictionary <string, OpenApiHeader> headers = SelectHealthCorrelationResponseHeaders(document); Assert.Contains("RequestId", headers); Assert.Contains("X-Transaction-Id", headers); IList <OpenApiParameter> parameters = SelectHealthCorrelationParameters(document); Assert.Single(parameters, parameter => parameter.Name == "X-Transaction-Id"); } }
public async Task CertificateAuthenticationOption_GetHealthUnauthenticated_ResultsUnauthorized() { // Arrange string subject = $"subject-{Guid.NewGuid()}"; var authenticatedProjectArguments = new WebApiProjectOptions() .WithCertificateSubjectAuthentication($"CN={subject}"); using (var project = await WebApiProject.StartNewAsync(authenticatedProjectArguments, _outputWriter)) { // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); } } }
public async Task GetHealthWithBearerToken_WithJwtAuthenticationOption_ReturnsOk() { // Arrange string key = $"secret-{Guid.NewGuid()}"; string issuer = $"issuer-{Guid.NewGuid()}"; string audience = $"audience-{Guid.NewGuid()}"; string jwtToken = CreateToken(key, issuer, audience); var jwtHeader = AuthenticationHeaderValue.Parse("Bearer " + jwtToken); var options = new WebApiProjectOptions().WithJwtAuthentication(key, issuer, audience); using (var project = await WebApiProject.StartNewAsync(options, _outputWriter)) // Act using (HttpResponseMessage response = await project.Health.GetAsync(request => request.Headers.Authorization = jwtHeader)) { // Assert Assert.NotNull(response); Assert.Equal(HttpStatusCode.OK, response.StatusCode); } }
public async Task GetHealth_OutOfTheBox_AndTransactionIdRequestHeader_ReturnsOkWithCorrelationHeadersAndSameTransactionId() { // Arrange var expectedTransactionId = $"transaction-{Guid.NewGuid():N}"; using (var project = await WebApiProject.StartNewAsync(_outputWriter)) { // Act using (HttpResponseMessage response = await project.Health.GetAsync( request => request.Headers.Add(TransactionHeaderName, expectedTransactionId))) { // Assert AssertNonBlankResponseHeader(response, OperationHeaderName); string actualTransactionId = AssertNonBlankResponseHeader(response, TransactionHeaderName); Assert.Equal(expectedTransactionId, actualTransactionId); } } }
public async Task GetSwaggerDocs_WithExcludeCorrelation_ReturnsDocsWithoutCorrelationHeaders() { // Arrange var options = new WebApiProjectOptions().WithExcludeCorrelation(); using (var project = await WebApiProject.StartNewAsync(options, _outputWriter)) // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); string json = await response.Content.ReadAsStringAsync(); OpenApiDocument document = LoadOpenApiDocument(json); IDictionary <string, OpenApiHeader> headers = SelectHealthCorrelationResponseHeaders(document); Assert.Empty(headers); IList <OpenApiParameter> parameters = SelectHealthCorrelationParameters(document); Assert.Empty(parameters); } }
public async Task SharedAccessKeyAuthenticationOption_GetHealthUnauthenticated_ResultsUnauthorized() { // Arrange const string headerName = "x-shared-access-key"; const string secretKey = "MySecretKey"; string secretValue = Guid.NewGuid().ToString("N"); var unauthenticatedArguments = new WebApiProjectOptions() .WithSharedAccessAuthentication(headerName, secretKey, secretValue); using (var project = await WebApiProject.StartNewAsync(_configuration, unauthenticatedArguments, _outputWriter)) { // Act using (HttpResponseMessage response = await project.Health.GetAsync()) { // Assert Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode); } } }
public JsonResult Search(ProjectViewModel model) { JSonResult objResult = new JSonResult(); try { List <MProject> entList = new List <MProject>(); MProject proj = new MProject(); proj.StartDate = 0; proj.EndDate = 0; proj.Title = ""; proj.Status = ""; entList = new WebApiProject().GetProjects(proj); model.ProjectCode = model.ProjectCode ?? ""; model.Description = model.Description ?? ""; if (!model.ProjectCode.Equals("")) { entList = entList.Where(p => p.ProjectCode == model.ProjectCode).ToList(); } if (!model.Description.Equals("")) { entList = entList.Where(p => p.Description == model.Description).ToList(); } objResult.data = entList; } catch (Exception) { objResult.data = null; objResult.isError = true; objResult.message = string.Format(MessageResource.ControllerGetExceptionMessage, "Project"); } return(Json(objResult)); }
public async Task CertificateAuthenticationOption_GetSwaggerDocs_ContainsCertificateSecurityScheme() { // Arrange string subject = $"subject-{Guid.NewGuid()}"; var authenticatedProjectArguments = new WebApiProjectOptions() .WithCertificateSubjectAuthentication($"CN={subject}"); using (var project = await WebApiProject.StartNewAsync(authenticatedProjectArguments, _outputWriter)) { // Act using (HttpResponseMessage response = await project.Swagger.GetSwaggerDocsAsync()) { // Assert Assert.Equal(HttpStatusCode.OK, response.StatusCode); var reader = new OpenApiStreamReader(); const string headerName = "X-ARR-ClientCert"; using (Stream json = await response.Content.ReadAsStreamAsync()) { OpenApiDocument document = reader.Read(json, out OpenApiDiagnostic diagnostic); Assert.NotNull(document.Components); (string schemeName, OpenApiSecurityScheme componentScheme) = Assert.Single(document.Components.SecuritySchemes); Assert.Equal("certificate", schemeName); Assert.Equal(ParameterLocation.Header, componentScheme.In); Assert.Equal(headerName, componentScheme.Name); OpenApiSecurityRequirement requirement = Assert.Single(document.SecurityRequirements); Assert.NotNull(requirement); (OpenApiSecurityScheme requirementScheme, IList <string> scopes) = Assert.Single(requirement); Assert.Equal(headerName, requirementScheme.Name); } } } }