public IHttpActionResult WriteToLog(string app, [FromBody]LogEntryLevelModel logEntry)
{
IHttpActionResult result = null;
//If OccuredOn in post object is not valid format, C# defaults to {1/1/0001 12:00:00 AM}
if (ModelState.IsValid)
{
//LogMessage(app, logEntry.logLevel, logEntry);
//Is there a more compact way to build the AppLogEntryModel as an extension of the original logEntry parameter, plus the string app?
AppLogEntry queueEntry = new AppLogEntry();
queueEntry.App = app;
queueEntry.Level = logEntry.logLevel;
queueEntry.OccurredOn = logEntry.occuredOn;
queueEntry.Message = logEntry.message;
//Consumer.Notify(queueEntry);
Observer.OnNext(queueEntry);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Accepted);
result = new ResponseMessageResult(response);
}
else
{
result = BadRequest("Missing required details.");
}
return result;
}
private static ResponseMessageResult GetResponseMessageResult(
ExceptionHandlerContext context,
string errorNumber)
{
var errorData = new ExceptionResponse()
{
StatusCode = HttpStatusCode.InternalServerError,
Message = "Some unhandled error happened. The error has been logged and will be fixed. We appologise blah blah....",
ErrorNumber = errorNumber,
Stack = context.Exception.StackTrace
};
var response = context.Request.CreateResponse(errorData);
var result = new ResponseMessageResult(response);
return(result);
}
public async Task GetStatus_PreAuthorizedKeysDoNotMatch_ReturnsUnauthorized()
{
// Arrange
var statusControllerHelper = new Mock <IStatusControllerHelper>();
statusControllerHelper.Setup(r => r.GetStatus()).ReturnsAsync(new ServiceStatus()
{
NoErrors = true
});
var controller = CreateController(statusControllerHelper.Object, "mypreauthorizedkey");
// Act
ResponseMessageResult result = await controller.GetStatus("NOTmypreauthorizedkey") as ResponseMessageResult;
// Assert
Assert.AreEqual(HttpStatusCode.Unauthorized, result.Response.StatusCode);
}
public void LogoutSuccessfullyTest()
{
Guid id = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.LogOut(id)).Verifiable();
UserController userController = new UserController(mockUserService.Object);
userController.Request = createUserControllerRequest();
this.addTokenHeaderToRequest(userController.Request, id);
ResponseMessageResult response = (ResponseMessageResult)userController.LogOut();
Assert.AreEqual(HttpStatusCode.OK, response.Response.StatusCode);
}
public async Task HandleAsync_IfCatchBlockIsWebHostBufferedContent_WithoutContentType_HandlesWithCustomException()
{
IExceptionHandler innerHandler = CreateDummyHandler();
IExceptionHandler product = CreateProductUnderTest(innerHandler);
// Arrange
using (HttpRequestMessage expectedRequest = CreateRequest())
using (HttpResponseMessage originalResponse = CreateResponse())
{
originalResponse.Content = new StringContent("Error");
originalResponse.Content.Headers.ContentType = null;
expectedRequest.SetRequestContext(
new HttpRequestContext {
IncludeErrorDetail = true
}
);
ExceptionHandlerContext context = CreateValidContext(
expectedRequest,
WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent
);
context.ExceptionContext.Response = originalResponse;
CancellationToken cancellationToken = CancellationToken.None;
// Act
await product.HandleAsync(context, cancellationToken);
// Assert
IHttpActionResult result = context.Result;
ResponseMessageResult typedResult = Assert.IsType <ResponseMessageResult>(result);
using (HttpResponseMessage response = typedResult.Response)
using (
HttpResponseMessage expectedResponse = expectedRequest.CreateErrorResponse(
HttpStatusCode.InternalServerError,
new InvalidOperationException(
"The 'StringContent' type failed to serialize the response body.",
context.ExceptionContext.Exception
)
)
)
{
AssertErrorResponse(expectedResponse, response);
}
}
}
private bool IsDataValid(string serverName, string cpuLoad, string ramLoad, out ResponseMessageResult responseMessageResult)
{
bool returnVal = true;
string responseMessageResultMessage = string.Empty;
if (String.IsNullOrEmpty(serverName))
{
returnVal = false;
responseMessageResultMessage = "SERVER_NAME_IS_EMPTY";
}
double outCPULoad = 0;
if (!double.TryParse(cpuLoad, out outCPULoad))
{
returnVal = false;
if (string.IsNullOrEmpty(responseMessageResultMessage))
{
responseMessageResultMessage = "CPU_LOAD_NOT_DOUBLE";
}
else
{
responseMessageResultMessage = string.Format("{0},{1}", responseMessageResultMessage, "CPU_LOAD_NOT_DOUBLE");
}
}
double outRAMLoad = 0;
if (!double.TryParse(ramLoad, out outRAMLoad))
{
returnVal = false;
if (string.IsNullOrEmpty(responseMessageResultMessage))
{
responseMessageResultMessage = "CPU_LOAD_NOT_DOUBLE";
}
else
{
responseMessageResultMessage = string.Format("{0},{1}", responseMessageResultMessage, "RAM_LOAD_NOT_DOUBLE");
}
}
responseMessageResult = new ResponseMessageResult(Request.CreateErrorResponse(HttpStatusCode.NotFound, "responseMessageResultMessage"));
return(returnVal);
}
public void ErrorCreateBatchBadTokenTest()
{
BatchDTO batch = createBatchDTO();
UserDTO userDTO = createUserDTO();
Guid token = Guid.NewGuid();
var mockBatchService = new Mock <BatchService>();
mockBatchService.Setup(b => b.CreateBatch(batch)).Verifiable();
BatchController batchController = new BatchController(mockBatchService.Object, null);
batchController.Request = createBatchControllerRequest();
ResponseMessageResult response = (ResponseMessageResult)batchController.Post(batch);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
public void LoginErrorTest()
{
LoginDTO loginUser = createLoginDTO();
Guid id = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.LogIn(loginUser)).Throws(new UserOrPasswordNotFoundException());
UserController userController = new UserController(mockUserService.Object);
userController.Request = createUserControllerRequest();
ResponseMessageResult response = (ResponseMessageResult)userController.LogIn(loginUser);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
public async Task Put_ReturnsInternalServerError_IfStoreThrows()
{
// Arrange
WebHook webHook = CreateWebHook();
_storeMock.Setup(s => s.UpdateWebHookAsync(TestUser, webHook))
.Throws <Exception>();
// Act
IHttpActionResult actual = await _controller.Put(TestWebHookId, webHook);
// Assert
Assert.IsType <ResponseMessageResult>(actual);
ResponseMessageResult result = actual as ResponseMessageResult;
HttpError error = await result.Response.Content.ReadAsAsync <HttpError>();
Assert.Equal("Could not update WebHook due to error: Exception of type 'System.Exception' was thrown.", error.Message);
}
public static ResponseMessageResult As(this ResponseMessageResult self, string contentDisposition)
{
if (self.Response.Content.Headers.Contains("__isAttachmentForced"))
{
contentDisposition = "attachment";
}
if (self.Response.Content.Headers.ContentDisposition == null)
{
self.Response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue(contentDisposition);
}
else
{
self.Response.Content.Headers.ContentDisposition.DispositionType = contentDisposition;
}
return(self);
}
protected IHttpActionResult Pagination <T>(T data, int totalItems = 0, int limit = 20, int page = 1)
{
var x = new ResponseMessageResult(
Request.CreateResponse(HttpStatusCode.OK, data)
);
int totalPage = totalItems / limit;
totalPage = totalItems % limit == 0 ? totalPage : (totalPage + 1);
x.Response.Headers.Add(WebCommentApiHeaders.X_Status, HttpStatusCode.OK.ToString());
x.Response.Headers.Add(WebCommentApiHeaders.X_Paging_TotalItems, totalItems.ToString());
x.Response.Headers.Add(WebCommentApiHeaders.X_Paging_Limit, limit.ToString());
x.Response.Headers.Add(WebCommentApiHeaders.X_Paging_Count, totalPage.ToString());
x.Response.Headers.Add(WebCommentApiHeaders.X_Paging_Page, page.ToString());
x.Response.Headers.Add(WebCommentApiHeaders.X_Status, HttpStatusCode.OK.ToString());
return(x);
}
public IHttpActionResult PostProcesarArchivo(int id)
{
try
{
if (HttpContext.Current.Request.Files.AllKeys.Any())
{
// obtener el archivo publicado
var archivo = HttpContext.Current.Request.Files["ArchivoSeleccionado"];
Stream fs = archivo.InputStream;
var streamReader = new StreamReader(fs);
// leer el archivo
var archivoLeido = streamReader.ReadToEnd();
archivoLeido = archivoLeido.Replace("\n", "");
var listado = archivoLeido.Split('\r').ToList();
listado.Remove("");
var resultadoFinal = ProcesarDiasDeTrabajo(listado, id);
// descargar archivo generado en memoria
HttpResponseMessage httpResponseMessage = new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new StringContent(resultadoFinal)
};
httpResponseMessage.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = "ArchivoSalida.txt"
};
httpResponseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
ResponseMessageResult responseMessageResult = ResponseMessage(httpResponseMessage);
return(responseMessageResult);
}
else
{
return(null);
}
}
catch (Exception ex)
{
return(Json(ex.Message));
}
}
public void CreateUserTest()
{
UserDTO user = createUserDTO();
UserDTO userLogged = createUserDTO();
Guid token = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.AddUser(user)).Verifiable();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(userLogged);
UserController userController = new UserController(mockUserService.Object);
userController.Request = createUserControllerRequest();
this.addTokenHeaderToRequest(userController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)userController.Create(user);
Assert.AreEqual(HttpStatusCode.OK, response.Response.StatusCode);
}
public void CreateUserInvalidTokenTest()
{
UserDTO user = createUserDTO();
string invalidToken = "test";
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.AddUser(user)).Verifiable();
UserController userController = new UserController(mockUserService.Object);
userController.Request = createUserControllerRequest();
userController.Request.Headers.Add("UserToken", invalidToken);
ResponseMessageResult response = (ResponseMessageResult)userController.Create(user);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
public async Task <IHttpActionResult> Root()
{
var root = new
{
service = "RevolutionPi Variable Server",
version = Assembly.GetAssembly(GetType()).GetName().Version.ToString(),
varlist = "GET ~/variables",
readvar = "GET ~/variables/{varname}",
readprop = "GET ~/variables/{varname}/{propname}"
};
var httpResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(root, JsonSerializerSettings), Encoding.UTF8, "application/json")
};
var result = new ResponseMessageResult(httpResponse);
return(await Task.FromResult(result));
}
public async Task HandleAsync_IfCatchBlockIsWebHostBufferedContent_WithCreateException_HandlesWithCustomException()
{
IExceptionHandler innerHandler = CreateDummyHandler();
IExceptionHandler product = CreateProductUnderTest(innerHandler);
// Arrange
using (HttpRequestMessage expectedRequest = CreateRequest())
using (HttpResponseMessage originalResponse = CreateResponse())
using (HttpConfiguration configuration = CreateConfiguration())
{
configuration.Services.Clear(typeof(IContentNegotiator));
originalResponse.Content = new StringContent("Error");
expectedRequest.SetRequestContext(
new HttpRequestContext
{
IncludeErrorDetail = true,
Configuration = configuration
}
);
ExceptionHandlerContext context = CreateValidContext(
expectedRequest,
WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent
);
context.ExceptionContext.Response = originalResponse;
CancellationToken cancellationToken = CancellationToken.None;
// Act
await product.HandleAsync(context, cancellationToken);
// Assert
IHttpActionResult result = context.Result;
ResponseMessageResult typedResult = Assert.IsType <ResponseMessageResult>(result);
using (HttpResponseMessage response = typedResult.Response)
{
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
Assert.Null(response.Content);
Assert.Same(expectedRequest, response.RequestMessage);
}
}
}
public void UpdateSupplierReturnsNoContent()
{
var mockSupplierService = new Mock <ISupplierService>();
mockSupplierService.Setup(x => x.UpdateSupplier(It.IsAny <int>(), It.IsAny <Supplier>())).Returns(true);
var controller = new SuppliersController(mockSupplierService.Object);
controller.Request = new HttpRequestMessage();
controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
IHttpActionResult actionResult = controller.PutSupplier(0, new Supplier()
{
SupplierId = 0
});
ResponseMessageResult contentResult = Assert.IsType <ResponseMessageResult>(actionResult);
Assert.NotNull(contentResult);
Assert.Equal(contentResult.Response.StatusCode, HttpStatusCode.NoContent);
}
public void ErrorCreateInspectionBadTokenTest()
{
InspectionDTO inspection = new InspectionDTO();
Guid token = Guid.NewGuid();
var mockInspectionService = new Mock <InspectionService>();
mockInspectionService.Setup(b => b.CreateInspection(inspection)).Verifiable();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Throws(new UserNotExistException());
InspectionController inspectionController = new InspectionController(mockInspectionService.Object, mockUserService.Object);
inspectionController.Request = createInspectionControllerRequest();
ResponseMessageResult response = (ResponseMessageResult)inspectionController.Post(inspection);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
public static ResponseMessageResult AsInline(this ResponseMessageResult self)
{
string type = "inline";
if (self.Response.Content.Headers.Contains("__isAttachmentForced"))
{
type = "attachment";
}
if (self.Response.Content.Headers.ContentDisposition == null)
{
self.Response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue(type);
}
else
{
self.Response.Content.Headers.ContentDisposition.DispositionType = type;
}
return(self);
}
public void HandleAsync_IfCatchBlockIsWebHostBufferedContent_WithFailedNegotiation_HandlesWithCustomException()
{
IExceptionHandler innerHandler = CreateDummyHandler();
IExceptionHandler product = CreateProductUnderTest(innerHandler);
// Arrange
using (HttpRequestMessage expectedRequest = CreateRequest())
using (HttpResponseMessage originalResponse = CreateResponse())
using (HttpConfiguration configuration = CreateConfiguration())
{
configuration.Formatters.Clear();
originalResponse.Content = new StringContent("Error");
expectedRequest.SetRequestContext(new HttpRequestContext
{
IncludeErrorDetail = true,
Configuration = configuration
});
ExceptionHandlerContext context = CreateValidContext(expectedRequest,
WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
context.ExceptionContext.Response = originalResponse;
CancellationToken cancellationToken = CancellationToken.None;
// Act
Task task = product.HandleAsync(context, cancellationToken);
task.WaitUntilCompleted();
// Assert
Assert.Equal(TaskStatus.RanToCompletion, task.Status);
IHttpActionResult result = context.Result;
Assert.IsType(typeof(ResponseMessageResult), result);
ResponseMessageResult typedResult = (ResponseMessageResult)result;
using (HttpResponseMessage response = typedResult.Response)
{
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
Assert.Null(response.Content);
Assert.Same(expectedRequest, response.RequestMessage);
}
}
}
public async Task <IHttpActionResult> GetFile(int id)
{
var homework = await StudentHelper.GetHomeworkById(id);
if (homework != null)
{
MemoryStream stream = new MemoryStream(homework.data);
HttpResponseMessage httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StreamContent(stream)
};
httpResponseMessage.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = homework.month
};
httpResponseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(homework.contenttype);
ResponseMessageResult responseMessageResult = ResponseMessage(httpResponseMessage);
return(responseMessageResult);
}
return(NotFound());
}
public void LoginSuccessfullyTest()
{
LoginDTO loginUser = createLoginDTO();
UserDTO userDTO = createUserDTO();
UserLoggedDTO userLoggedDTO = createUserLoggedDTO();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.LogIn(loginUser)).Returns(userLoggedDTO);
mockUserService.Setup(us => us.GetUserLoggedIn(userLoggedDTO.Token)).Returns(userDTO);
UserController userController = new UserController(mockUserService.Object);
userController.Request = createUserControllerRequest();
ResponseMessageResult response = (ResponseMessageResult)userController.LogIn(loginUser);
Assert.AreEqual(HttpStatusCode.OK, response.Response.StatusCode);
}
public async Task <IHttpActionResult> GetVariableNames()
{
var config = Request.GetOwinContext().Get <PiConfiguration>("PiConfig");
var varlist = config.Devices
.SelectMany(d => d.Variables)
.Select(v => new
{
name = v.Name,
type = v.Type.ToString(),
length = v.LengthText,
});
var httpResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(varlist, JsonSerializerSettings), Encoding.UTF8, "application/json")
};
var result = new ResponseMessageResult(httpResponse);
return(await Task.FromResult(result));
}
public IHttpActionResult PostCargarArchivo(string cedula)
{
BMArchivo objArchivo = new BMArchivo();
string ArchivoRespuesta = String.Empty;
HttpResponseMessage response = new HttpResponseMessage();
try
{
if (HttpContext.Current.Request.Files.AllKeys.Any())
{
var archivo = HttpContext.Current.Request.Files["ArchivoCargado"];
Stream a = archivo.InputStream;
StreamReader sr = new StreamReader(a);
ArchivoRespuesta = objArchivo.CargarArchivo(sr, cedula);
response.StatusCode = HttpStatusCode.OK;
response.Content = new StringContent(ArchivoRespuesta);
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = "ArchivoSalida.txt"
};
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
}
else
{
return(null);
}
}
catch (Exception ex)
{
}
ResponseMessageResult responseMessageResult = ResponseMessage(response);
return(responseMessageResult);
}
public IHttpActionResult GetMap([FromBody] JObject json)
{
dynamic jsonToPath = JsonConvert.DeserializeObject(json.ToString());
string path = jsonToPath.Path;
byte[] dataBytes = File.ReadAllBytes(path);
MemoryStream dataStream = new MemoryStream(dataBytes);
HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StreamContent(dataStream)
};
result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = "Map.jpeg"
};
result.Content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
ResponseMessageResult response = ResponseMessage(result);
return(response);
}
public async Task HandleAsync_HandlesExceptionViaCreateErrorResponse()
{
IExceptionHandler product = CreateProductUnderTest();
// Arrange
using (HttpRequestMessage expectedRequest = CreateRequest())
{
expectedRequest.SetRequestContext(
new HttpRequestContext {
IncludeErrorDetail = true
}
);
ExceptionHandlerContext context = CreateValidContext(expectedRequest);
CancellationToken cancellationToken = CancellationToken.None;
// Act
await product.HandleAsync(context, cancellationToken);
// Assert
IHttpActionResult result = context.Result;
ResponseMessageResult typedResult = Assert.IsType <ResponseMessageResult>(result);
using (HttpResponseMessage response = typedResult.Response)
{
Assert.NotNull(response);
using (
HttpResponseMessage expectedResponse = expectedRequest.CreateErrorResponse(
HttpStatusCode.InternalServerError,
context.ExceptionContext.Exception
)
)
{
AssertErrorResponse(expectedResponse, response);
}
Assert.Same(expectedRequest, response.RequestMessage);
}
}
}
public void HandleAsync_IfCatchBlockIsWebHostBufferedContent_HandlesWithCustomException()
{
IExceptionHandler innerHandler = CreateDummyHandler();
IExceptionHandler product = CreateProductUnderTest(innerHandler);
// Arrange
using (HttpRequestMessage expectedRequest = CreateRequest())
using (HttpResponseMessage originalResponse = CreateResponse())
{
originalResponse.Content = new StringContent("Error");
originalResponse.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
expectedRequest.SetRequestContext(new HttpRequestContext {
IncludeErrorDetail = true
});
ExceptionHandlerContext context = CreateValidContext(expectedRequest,
WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
context.ExceptionContext.Response = originalResponse;
CancellationToken cancellationToken = CancellationToken.None;
// Act
Task task = product.HandleAsync(context, cancellationToken);
task.WaitUntilCompleted();
// Assert
Assert.Equal(TaskStatus.RanToCompletion, task.Status);
IHttpActionResult result = context.Result;
Assert.IsType(typeof(ResponseMessageResult), result);
ResponseMessageResult typedResult = (ResponseMessageResult)result;
using (HttpResponseMessage response = typedResult.Response)
using (HttpResponseMessage expectedResponse = expectedRequest.CreateErrorResponse(
HttpStatusCode.InternalServerError, new InvalidOperationException("The 'StringContent' type " +
"failed to serialize the response body for content type 'text/plain'.",
context.ExceptionContext.Exception)))
{
AssertErrorResponse(expectedResponse, response);
}
}
}
public void DeleteVehicleTest()
{
VehicleDTO vehicle = CreateVehicle();
UserDTO user = createUserDTO();
Guid token = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(user);
var mockVehicleService = new Mock <VehicleService>();
mockVehicleService.Setup(vs => vs.DeleteVehicle("TEST1234")).Verifiable();
VehicleController vehicleController = new VehicleController(mockUserService.Object, mockVehicleService.Object, null);
vehicleController.Request = createUserControllerRequest();
addTokenHeaderToRequest(vehicleController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)vehicleController.Delete("TEST1234");
Assert.AreEqual(HttpStatusCode.OK, response.Response.StatusCode);
}
public async Task GetStatus_HelperReturnsWithErrors_ReturnsInternalServerErrorWithCorrectContent()
{
// Arrange
var statusControllerHelper = new Mock <IStatusControllerHelper>();
statusControllerHelper.Setup(r => r.GetStatus()).ReturnsAsync(new ServiceStatus()
{
NoErrors = false, ServiceName = "MyServiceName"
});
var controller = CreateController(statusControllerHelper.Object, "mypreauthorizedkey");
// Act
ResponseMessageResult result = await controller.GetStatus("mypreauthorizedkey") as ResponseMessageResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.InternalServerError, result.Response.StatusCode);
var content = await result.Response.Content.ReadAsAsync <ServiceStatus>();
Assert.AreEqual("MyServiceName", content.ServiceName);
}
public async Task <IHttpActionResult> Post([FromBody] JObject json)
{
var alexaRequest = new SkillRequest(json);
Trace.TraceInformation(alexaRequest.Json);
var skill = new Skill.UserGroupSkill();
skill.HandleRequest(alexaRequest);
var skillResponse = skill.Response;
Trace.TraceInformation(skillResponse.Json);
var httpResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(skillResponse.Json, Encoding.UTF8, "application/json")
};
var result = new ResponseMessageResult(httpResponse);
return(await Task.FromResult(result));
}
public void CreateVehicleDuplicatedVinTest()
{
VehicleDTO vehicle = CreateVehicle();
UserDTO user = createUserDTO();
Guid token = Guid.NewGuid();
var mockUserService = new Mock <UserService>();
mockUserService.Setup(us => us.GetUserLoggedIn(token)).Returns(user);
var mockVehicleService = new Mock <VehicleService>();
mockVehicleService.Setup(vs => vs.AddVehicle(vehicle)).Throws(new VehicleVinDuplicatedException());
VehicleController vehicleController = new VehicleController(mockUserService.Object, mockVehicleService.Object, null);
vehicleController.Request = createUserControllerRequest();
addTokenHeaderToRequest(vehicleController.Request, token);
ResponseMessageResult response = (ResponseMessageResult)vehicleController.Create(vehicle);
Assert.AreEqual(HttpStatusCode.BadRequest, response.Response.StatusCode);
}
public IHttpActionResult WriteToLog(string app, LogLevel logLevel, [FromBody]LogEntryModel logEntry)
{
IHttpActionResult result = null;
//If OccuredOn in post object is not valid format, C# defaults to {1/1/0001 12:00:00 AM}
if (ModelState.IsValid)
{
//LogMessage(app, logLevel, logEntry);
//Repetition w/ other post action, how to dry code with slight variation on accessing logLevel
AppLogEntry queueEntry = new AppLogEntry();
queueEntry.App = app;
queueEntry.Level = logLevel;
queueEntry.OccurredOn = logEntry.occuredOn;
queueEntry.Message = logEntry.message;
//Consumer.Notify(queueEntry);
Observer.OnNext(queueEntry);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Accepted);
result = new ResponseMessageResult(response);
}
else
{
result = BadRequest("Missing required details.");
}
return result;
}
