public void Post_Legg_til_prosjekt_Bad_Request() { var commandBus = new Mock<IProsjektLogikk>(); commandBus.Setup(c => c.RegistrerProsjekt(It.IsAny<Prosjekt>(), It.IsAny<string>())).Returns(true); // Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>(); var httpConfiguration = new HttpConfiguration(); WebApiConfig.Register(httpConfiguration); var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"], new HttpRouteValueDictionary { { "controller", "ProsjektApi" } }); var controller = new ProsjektApiController(commandBus.Object) { Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/ProsjektApi/") { Properties = { { HttpPropertyKeys.HttpConfigurationKey, httpConfiguration }, { HttpPropertyKeys.HttpRouteDataKey, httpRouteData } } } }; // Act var pros = new Prosjekt(); pros.Arbeidsplass = ""; // The ASP.NET pipeline doesn't run, so validation don't run. controller.ModelState.AddModelError("Arbeidsplass", "mock error message"); var response = controller.Post(pros); // Assert Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); }
public void Post_Bruker_Bad_request() { var commandBus = new Mock<IBrukerLogikk>(); commandBus.Setup(c => c.RegistrerBruker(It.IsAny<Registrer>())).Returns(true); // Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>(); var httpConfiguration = new HttpConfiguration(); WebApiConfig.Register(httpConfiguration); var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"], new HttpRouteValueDictionary { { "controller", "BrukerApi" } }); var controller = new BrukerApiController(commandBus.Object) { Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/BrukerApi/") { Properties = { { HttpPropertyKeys.HttpConfigurationKey, httpConfiguration }, { HttpPropertyKeys.HttpRouteDataKey, httpRouteData } } } }; Registrer nyBruker = new Registrer(); nyBruker.Email = ""; // The ASP.NET pipeline doesn't run, so validation don't run. controller.ModelState.AddModelError("Email", "mock error message"); var response = controller.Post(nyBruker); // Assert commandBus.Verify(e => e.RegistrerBruker(nyBruker), Times.Never); Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); // Act }
public void GetSlotPageById_WithSlotHavingAnImage_ReturnedSlotHasImageUrl() { //Arrange HttpConfiguration config = new HttpConfiguration(); var route = config.Routes.MapHttpRoute ( name: "GetMediaContentById", routeTemplate: "mediacontent/{id}" ); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "id", "1" } }); HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Get, "http://localhost:80/slotpage/1"); req.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, config); req.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, routeData); _urlHelper = new TWG.EASDataService.Api.Helpers.UrlHelper(new System.Web.Http.Routing.UrlHelper(req)); _objectUnderTest = new SlotController(_slotService, _urlHelper); _objectUnderTest.Request = req; var slot = new Slot() { Id = 1, Headline = "test slot", Image = new Image() { Name = "dummy image", Id = 1000, Extension = "jpg" } }; SlotPage sp = new SlotPage() { Id = 1, PageName = "Test", Slots = { slot } }; _slotRepository.Stub(r => r.GetSlotPageById(Arg<int>.Is.Anything)).Return(sp); //Act var result = _objectUnderTest.GetSlotPageById(1); //Assert Image img = result.Slots.FirstOrDefault().Image; Assert.AreNotEqual(string.Empty,img.Url); }
public void SelectAction_WithDirectRoutes_RespectsRouteOrder() { // Arrange var actionSelector = new ApiControllerActionSelector(); HttpControllerContext context = ContextUtil.CreateControllerContext(); context.Request = new HttpRequestMessage { Method = HttpMethod.Get }; var controllerDescriptor = new HttpControllerDescriptor(context.Configuration, "MultipleGet", typeof(MultipleGetController)); context.ControllerDescriptor = controllerDescriptor; ReflectedHttpActionDescriptor firstDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetA"].Single(); HttpRouteData[] subRouteData = new HttpRouteData[2]; subRouteData[0] = new HttpRouteData(new HttpRoute()); subRouteData[1] = new HttpRouteData(new HttpRoute()); context.RouteData.Values.Add(RouteCollectionRoute.SubRouteDataKey, subRouteData); subRouteData[0].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { firstDirectRouteAction }); subRouteData[0].Route.DataTokens.Add("order", 1); ReflectedHttpActionDescriptor secondDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetB"].Single(); subRouteData[1].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { secondDirectRouteAction }); subRouteData[1].Route.DataTokens.Add("order", 2); // Act HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(context); // Assert Assert.Same(secondDirectRouteAction, actionDescriptor); }
public void Post_Bruker_Ok() { Registrer nyBruker = new Registrer() { Fornavn = "Mats", Etternavn = "Lokken", Email = "*****@*****.**", Telefonnummer = "93686771", BekreftPassord = "password" }; var commandBus = new Mock<IBrukerLogikk>(); commandBus.Setup(c => c.RegistrerBruker(It.IsAny<Registrer>())).Returns(true); // Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>(); var httpConfiguration = new HttpConfiguration(); WebApiConfig.Register(httpConfiguration); var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"], new HttpRouteValueDictionary { { "controller", "BrukerApi" } }); var controller = new BrukerApiController(commandBus.Object) { Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/BrukerApi/") { Properties = { { HttpPropertyKeys.HttpConfigurationKey, httpConfiguration }, { HttpPropertyKeys.HttpRouteDataKey, httpRouteData } } } }; // Act var response = controller.Post(nyBruker); // Assert Assert.AreEqual(HttpStatusCode.Created, response.StatusCode); // var newCategory = JsonConvert.DeserializeObject<CategoryModel>(response.Content.ReadAsStringAsync().Result); Assert.AreEqual(string.Format("http://localhost/api/BrukerApi/{0}", nyBruker.id), response.Headers.Location.ToString()); }
public async Task PostData_SendInvalidJson_BadRequest() { try { var config = new HttpConfiguration(); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "RequestData" } }); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/"); request.Content = new StringContent(invalidRequestJson, Encoding.UTF8, "application/json"); request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration()); RequestDataController controller = new RequestDataController(); controller.ControllerContext = new HttpControllerContext(config, routeData, request); controller.Request = request; controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; // Act var response = await controller.PostData(request); //var jsonString = await response.Content.ReadAsStringAsync(); // Assert Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); } catch (Exception ex) { Assert.Fail(ex.Message); } }
public void Post_HttpStatus_should_be_created_and_header_should_contains_the_location() { Mock<IPostRepository> repository = new Mock<IPostRepository>(); PostsController controller = new PostsController(repository.Object); HttpConfiguration config = new HttpConfiguration(); HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/"); IHttpRoute route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); HttpRouteData routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "posts" } }); controller.ControllerContext = new HttpControllerContext(config, routeData, request); controller.Request = request; controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; controller.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; HttpResponseMessage response = controller.Post(new Post() { Title = "test", Date = DateTime.Today, Body = "blablabla" }); Assert.Equal(HttpStatusCode.Created, response.StatusCode); Assert.NotNull(response.Headers.Location); }
[TestMethod] public void Post_MAl_Bad_request_Modelstate() { var commandBus = new Mock<IVaktLogikk>(); commandBus.Setup(c => c.RegistrerMal(It.IsAny<MalerSkjema>(),It.IsAny<string>())).Returns(true); // Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>(); var httpConfiguration = new HttpConfiguration(); WebApiConfig.Register(httpConfiguration); var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"], new HttpRouteValueDictionary { { "controller", "BrukerApi" } }); var controller = new MalerController(commandBus.Object) { Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/Maler/") { Properties = { { HttpPropertyKeys.HttpConfigurationKey, httpConfiguration }, { HttpPropertyKeys.HttpRouteDataKey, httpRouteData } } } }; MalerSkjema nyMal = new MalerSkjema(); nyMal.startTid = ""; // The ASP.NET pipeline doesn't run, so validation don't run. controller.ModelState.AddModelError("startTIid", "mock error message"); var response = controller.Post(nyMal); // Assert commandBus.Verify(e => e.RegistrerMal(nyMal,"brukernavn"), Times.Never); Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode); // Act }
public void TopicsController_Post() { //a var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/topics"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{content}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { {"controller", "topics"} }); _controller.ControllerContext = new HttpControllerContext(config, routeData, request); _controller.Request = request; _controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; var newTopic = new Topic() { Title = "test", Body = "testtest" }; //a var result = _controller.Post(newTopic); var json = result.Content.ReadAsStringAsync().Result; var topic = JsonConvert.DeserializeObject<Topic>(json); //a Assert.AreEqual(HttpStatusCode.Created, result.StatusCode); Assert.IsNotNull(topic); Assert.IsTrue(topic.Id > 0); Assert.IsTrue(topic.Created > DateTime.MinValue); }
public void TopicsControllerPost() { // Testing POST is harder than it should be but we need to do some work: var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/topics"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "topics" } }); _controller.ControllerContext = new HttpControllerContext(config, routeData, request); _controller.Request = request; _controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; var newTopic = new Topic() { Title = "Test title", Body = "Test body" }; var result = _controller.Post(newTopic); Assert.AreEqual(HttpStatusCode.Created, result.StatusCode); var json = result.Content.ReadAsStringAsync().Result; var topic = JsonConvert.DeserializeObject<Topic>(json); Assert.IsNotNull(topic); Assert.AreEqual("Test title", topic.Title); Assert.AreEqual("Test body", topic.Body); Assert.AreNotEqual(0, topic.Id); }
public void Post_Mal_Ok() { MalerSkjema nyMal = new MalerSkjema() { ProsjektId = 1, Tittel = "Dagvakt1", startTid = "07.30", sluttTid = "14.45" }; var commandBus = new Mock<IVaktLogikk>(); commandBus.Setup(c => c.RegistrerMal(It.IsAny<MalerSkjema>(), It.IsAny<string>())).Returns(true); // Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>(); var httpConfiguration = new HttpConfiguration(); WebApiConfig.Register(httpConfiguration); var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"], new HttpRouteValueDictionary { { "controller", "Maler" } }); var controller = new MalerController(commandBus.Object) { Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/Maler/") { Properties = { { HttpPropertyKeys.HttpConfigurationKey, httpConfiguration }, { HttpPropertyKeys.HttpRouteDataKey, httpRouteData } } } }; // Act var response = controller.Post(nyMal); // Assert Assert.AreEqual(HttpStatusCode.Created, response.StatusCode); Assert.AreEqual(string.Format("http://localhost/api/Maler"), response.Headers.Location.ToString()); }
public InitController(String controllerName) { this.config = new HttpConfiguration(); this.request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/"+controllerName+"Controller"); this.route = config.Routes.MapHttpRoute(controllerName, "api/{controller}/{id}"); this.routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", controllerName } }); }
public static void ClassInit(TestContext testContext) { Configuration = new HttpConfiguration(); GetRequest = new HttpRequestMessage(HttpMethod.Get, "https://localhost/FACCTS.Server/api/CourtCase"); var route = Configuration.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); RouteData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "CourtCase" } }); }
public void TestCreatePlan() { var plandto = CA<PlanDto>(); var plan = CA<Plan>(); var config = new HttpConfiguration(); using (var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/plans")) { var routeData = new HttpRouteData(config.Routes.MapHttpRoute("defaultapi", "api/{controller}/{id}"), new HttpRouteValueDictionary {{"controller", "plans"}}); mController.ControllerContext = new HttpControllerContext(config, routeData, request); mController.Request = request; mController.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; mController.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; mMapper.Setup(m => m.Map<Plan>(plandto)).Returns(plan); mRepo.Setup(r => r.Add(It.Is<Plan>(s => IsEqual(s, plan)))); mMapper.Setup(m => m.Map<PlanDto>(plan)).Returns(plandto); using (var response = mController.PostPlan(plandto)) { Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created)); Assert.That(response.Headers.Location.AbsoluteUri, Is.EqualTo("http://localhost/api/plans/" + plandto.ID)); var result = response.Content.ReadAsStringAsync(); result.Wait(); var actual = JsonConvert.DeserializeObject<PlanDto>(result.Result); Compare(actual, plandto); } } }
public async Task PostTest() { var config = new HttpConfiguration(); var httpRequest = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/links"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "links" } }); var mockSettings = new Mock<IApplicationSettings>(MockBehavior.Strict); const string accessToken = "foo"; mockSettings.Setup(m => m.PostLinkAccessToken).Returns(accessToken); var controller = new LinksController(mockSettings.Object); controller.ControllerContext = new HttpControllerContext(config, routeData, httpRequest); controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; controller.Request.Headers.Add("Linx-Access-Token", accessToken); var request = new LinkModel() { Channel = "#foobar", Url = "http://mnd.fi/", User = "******" }; HttpResponseMessage response = await controller.PostLink(request); Assert.IsNotNull(response.Headers.Location); }
public DepositControllerTest() { var aEventLog = new EventLog(); var aMockRepo = new Mock<IAccountRepository>(); aMockRepo.Setup(aRepo => aRepo.GetAccount()).Returns(new Account(0, aEventLog)); /********************************************************************************************* build mock data for ControllerContext so that context-dependent properties can be tested (headers, routing, etc...) *********************************************************************************************/ var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/account"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/v{version}/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "Deposit" } }); /********************************************************************************************* build the Controller (class under test) and initialize it with the ControllerContext *********************************************************************************************/ _controller = new DepositController(aMockRepo.Object) { ControllerContext = new HttpControllerContext(config, routeData, request), Request = request }; _controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; }
public void SetUp() { var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://dragonapi.devjakobsen.dk/api/game"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "game" } }); gameController = new GameController(); UrlHelper urlHelper = new UrlHelper(request); gameController.ControllerContext = new HttpControllerContext(config, routeData, request); gameController.Request = request; gameController.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; gameController.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; gameController.Url = urlHelper; genreController = new GenreController(); var response = genreController.Get(1); var contentResult = response as OkNegotiatedContentResult<DTOGenre>; DTOGenre DtoGenre = contentResult.Content; genrefromDb = new Genre(); genrefromDb.Name = DtoGenre.Name; genrefromDb.Id = DtoGenre.Id; game = new Game() { Name = "Integration Test Game", Genre = genrefromDb }; }
protected RouteTest(string url, HttpMethod httpMethod) { HttpRequestMessage = new HttpRequestMessage(httpMethod, url); HttpRequestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, GlobalConfiguration.Configuration); // if (HttpRequestMessage == null) foreach (IHttpRoute httpRoute in GlobalConfiguration.Configuration.Routes) //GlobalConfiguration.Configuration.Routes.VirtualPathRoot = "sdf"; { IHttpRouteData routeData = httpRoute.GetRouteData("http://test.com/", HttpRequestMessage); if (routeData != null) { var d = routeData; } } var r = (IHttpRouteData)null; var route = new HttpRouteData(new HttpRoute()); HttpRouteData = GlobalConfiguration.Configuration.Routes.GetRouteData(HttpRequestMessage); HttpRequestMessage.Properties[HttpPropertyKeys.HttpRouteDataKey] = HttpRouteData; ControllerSelector = new DefaultHttpControllerSelector(GlobalConfiguration.Configuration); ControllerContext = new HttpControllerContext(GlobalConfiguration.Configuration, HttpRouteData, HttpRequestMessage); }
public void SetUp() { var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://dragonapi.devjakobsen.dk/api/player"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "player" } }); playerController = new PlayerController(); UrlHelper urlHelper = new UrlHelper(request); playerController.ControllerContext = new HttpControllerContext(config, routeData, request); playerController.Request = request; playerController.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; playerController.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; playerController.Url = urlHelper; var response = teamController.Get(1); var contentResult = response as OkNegotiatedContentResult<DTOTeam>; DTOTeam DtoTeam = contentResult.Content; Team teamFromDb = new Team(); teamFromDb.Name = DtoTeam.Name; teamFromDb.Id = DtoTeam.Id; List<Team> teams = new List<Team>() { teamFromDb }; player = new Player() { Name = "Integration Test Player", Teams = teams }; }
public void Post_Registrer_Prosjekt_Ok() { Prosjekt nyttProsjekt = new Prosjekt() { Arbeidsplass = "TestShop" }; var commandBus = new Mock<IProsjektLogikk>(); commandBus.Setup(c => c.RegistrerProsjekt(It.IsAny<Prosjekt>(), It.IsAny<string>())).Returns(true); // Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>(); var httpConfiguration = new HttpConfiguration(); WebApiConfig.Register(httpConfiguration); var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"], new HttpRouteValueDictionary { { "controller", "ProsjektApi" } }); var controller = new ProsjektApiController(commandBus.Object) { Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/ProsjektApi/") { Properties = { { HttpPropertyKeys.HttpConfigurationKey, httpConfiguration }, { HttpPropertyKeys.HttpRouteDataKey, httpRouteData } } } }; // Act var response = controller.Post(nyttProsjekt); // Assert Assert.AreEqual(HttpStatusCode.Created, response.StatusCode); // var newCategory = JsonConvert.DeserializeObject<CategoryModel>(response.Content.ReadAsStringAsync().Result); Assert.AreEqual(string.Format("http://localhost/api/ProsjektApi/{0}", nyttProsjekt.ProsjektId), response.Headers.Location.ToString()); }
/// <summary> /// A helper method to create a WebAPI HttpControllerContext which can be used to execute a controller manually /// </summary> /// <param name="method"></param> /// <param name="uri"></param> /// <param name="httpContext"></param> /// <returns></returns> internal static HttpControllerContext CreateContext(HttpMethod method, Uri uri, HttpContextBase httpContext) { var config = new HttpConfiguration(GlobalConfiguration.Configuration.Routes); IHttpRouteData route = new HttpRouteData(new HttpRoute()); var req = new HttpRequestMessage(method, uri); req.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; req.Properties[HttpPropertyKeys.HttpRouteDataKey] = route; req.Properties["MS_HttpContext"] = httpContext; return new HttpControllerContext(config, route, req); }
public IHttpRouteData GetRouteData(string virtualPathRoot, System.Net.Http.HttpRequestMessage request) { if (request == null) return null; SimulationUriParser parser = new SimulationUriParser(request.RequestUri.AbsolutePath); if (!parser.IsSimulation) return null; HttpRouteData d = new HttpRouteData(this); return d; }
private HttpActionContext InitializeActionContext(HttpRequestMessage request) { var configuration = new HttpConfiguration(); var route = configuration.Routes.MapHttpRoute(name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional }); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "Issues" } }); request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData; var controllerContext = new HttpControllerContext(configuration, routeData, request); var actionContext = new HttpActionContext { ControllerContext = controllerContext }; return actionContext; }
private static void SetupControllerForTests(ApiController controller) { var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/run"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "run" } }); controller.ControllerContext = new HttpControllerContext(config, routeData, request); controller.Request = request; controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; }
public HttpRequestMessage initRequest(string controllerName) { HttpRequestMessage Request = new HttpRequestMessage(); HttpConfiguration config = new HttpConfiguration(); IHttpRoute route = config.Routes.MapHttpRoute(controllerName, "api/{controller}/{id}"); HttpRouteData routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", controllerName } }); Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; Request.Properties["requestId"] = new Guid().ToString(); Request.SetRouteData(routeData); return Request; }
private void ConfigureWebApiContextForPost(TopicsController topicsController) { // This is basically boilerplate code for testing a post in WebApi... This will probably get easier some day, but not yet. var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/topics"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "topics" } }); topicsController.ControllerContext = new HttpControllerContext(config, routeData, request); topicsController.Request = request; topicsController.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; }
/// <summary> /// Registers the context. /// </summary> /// <param name="controller">The controller.</param> /// <param name="controllerName">Name of the controller.</param> public static void RegisterContext(ApiController controller, string controllerName) { var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/" + controllerName); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional }); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", controllerName } }); controller.ControllerContext = new HttpControllerContext(config, routeData, request); controller.Request = request; controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; controller.Request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, routeData); }
public void Init() { _ctrl = new UsersController(new FakeUsersRepository()); var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/be/api"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "users" } }); _ctrl.ControllerContext = new HttpControllerContext(config, routeData, request); _ctrl.Request = request; _ctrl.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; }
public static CalcController ConfigureForGet(this CalcController controller, int value) { var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Get, string.Format("http://localhost/api/calc/c/{0}", value)); IHttpRoute route = config.Routes.MapHttpRoute(name: "CalcApi", routeTemplate: "api/calc/c/{value}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "value", value } }); controller.ControllerContext = new HttpControllerContext(config, routeData, request); controller.Request = request; controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; return controller; }
private static TasksController SetupControllerForTest(ITaskRepository repository) { var config = new HttpConfiguration(); var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/tasks"); var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}"); var routeData = new HttpRouteData(route, new HttpRouteValueDictionary { { "controller", "tasks" } }); var controller = new TasksController(repository); controller.ControllerContext = new HttpControllerContext(config, routeData, request); controller.Request = request; controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config; return controller; }