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