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

        }
Example #3
0
        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);
        }
Example #8
0
        [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);
        }
Example #11
0
 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" } });
 }
Example #14
0
        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);
            }
              }
        }
Example #15
0
        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 };
        }
Example #18
0
        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());
 }
Example #21
0
 /// <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);
 }
Example #22
0
        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;
        }
Example #25
0
 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;
        }
Example #30
0
 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;
 }