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);
}
}
}
}
