public async Task NoResponseIsSetForValidParameters()
{
var parameterName = "one";
var parameterValue = new object();
var mockValidator = new Mock <IValidator>();
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var mockDependencyScope = new Mock <IDependencyScope>();
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
var messageValidator = new ValidateMessageAttribute();
mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction");
mockDependencyScope.Setup(scope => scope.GetService(It.IsAny <Type>()))
.Returns(mockValidator.Object)
.Verifiable("Tthe validator should have been requested.");
mockValidator.Setup(validator => validator.Validate(It.Is <object>(param => param == parameterValue)))
.Returns(Enumerable.Empty <Error>())
.Verifiable("The validator should have been used to validate the parameter.");
actionContext.ActionArguments.Add(parameterName, parameterValue);
request.SetConfiguration(httpConfiguration);
request.SetRouteData(routeData);
request.Properties.Add(HttpPropertyKeys.DependencyScope, mockDependencyScope.Object);
await messageValidator.OnActionExecutingAsync(actionContext, new CancellationToken());
actionContext.Response.Should().BeNull("because no response should be set when there are no failures");
}
public void AuthenticateDoesNotSucceedWithUnexpectedCallerCertificate()
{
var config = new ClientCertificateAuthenticationConfiguration
{
Enabled = true,
EnforceLocalCertificateValidation = false,
SerializedCertificateClaimsMapping = "{\"NOT-REAL-THUMPRINT\":{\"urn:ordering:security:privilege:sudo\":\"true\"}}"
};
var mockClock = new Mock <IClock>();
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var mockDependencyScope = new Mock <IDependencyScope>();
var callerCertificate = new X509Certificate2(Convert.FromBase64String(ClientCertificateAuthenticationHandlerTests.Base64Certificate), ClientCertificateAuthenticationHandlerTests.CertificatePassword);
var handler = new ClientCertificateAuthenticationHandler(config, mockClock.Object);
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var requestContext = new HttpRequestContext();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
var authcontext = new HttpAuthenticationContext(actionContext, null);
requestContext.ClientCertificate = callerCertificate;
controllerContext.RequestContext = requestContext;
controllerContext.Request = request;
request.Properties.Add(HttpPropertyKeys.DependencyScope, mockDependencyScope.Object);
request.Properties.Add(HttpPropertyKeys.RequestContextKey, requestContext);
request.Properties.Add(HttpPropertyKeys.ClientCertificateKey, requestContext.ClientCertificate);
var result = handler.Authenticate(new Dictionary <string, string>(), authcontext);
result.Should().BeNull("because the caller certificate does not exist in the claims mapping for known certificates");
}
public void Post_should_return_Created_if_order_good()
{
// arrange
const int OrderId = 123;
var order = new Order(new OrderItem[]
{
new OrderItem()
{
Name = "Name",
Quantity = 1
}
})
{
Id = OrderId
};
var mockOrderService = new Mock <IOrderService>();
mockOrderService.Setup(x => x.Exists(It.IsAny <int>()))
.Returns(false);
var orderController = new OrderController(mockOrderService.Object);
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:2345/api/Order");
var config = new HttpConfiguration();
request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
orderController.Request = request;
orderController.Configuration = config;
config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
var route = config.Routes["DefaultApi"];
var httpRouteData = new HttpRouteData(route, new HttpRouteValueDictionary(new { controller = "Order" }));
orderController.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = httpRouteData;
// act
var result = orderController.Post(request, order);
// assert
Assert.Equal(HttpStatusCode.Created, result.StatusCode);
}
public async Task ExceptionHeaderDoesNotContainUnsafeCharacters()
{
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var mockLogger = new Mock <ILogger>();
var exception = new InvalidOperationException("One cannot simply walk into Mordor");
var errorConfiguration = new ErrorHandlingConfiguration {
ExceptionDetailsEnabled = true
};
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage(HttpMethod.Get, "http://api.someservice.com/collection/thing");
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
var errorContext = new HttpActionExecutedContext(actionContext, exception);
mockLogger.Setup(logger => logger.ForContext(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>())).Returns(mockLogger.Object);
mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction");
request.SetConfiguration(httpConfiguration);
request.SetRouteData(routeData);
request.Headers.TryAddWithoutValidation(HttpHeaders.CorrelationId, "Not-A-Real-Value");
var exceptionFilter = new GlobalExceptionFilter(errorConfiguration, mockLogger.Object);
await exceptionFilter.OnExceptionAsync(errorContext, CancellationToken.None);
errorContext.Response.Should().NotBeNull("because the response should have been set");
IEnumerable <string> headers;
errorContext.Response.Headers.TryGetValues(HttpHeaders.ExceptionDetails, out headers).Should().BeTrue("because the exception details header should have been set");
headers.Count().Should().Be(1, "because a single exception detail header should exist");
headers.First().Should().NotContain(Environment.NewLine, "because new lines are not allowed in header values");
}
public void UpdateShouldFunctionAndReturnStatusCodeOK()
{
//Arrange
var _doorrepo = new Mock <IEntityBaseRepository <Door> >();
_doorrepo.Setup(x => x.GetSingle(1)).Returns(new Door {
});
var _errorrepo = new Mock <IEntityBaseRepository <Error> >();
var _uow = new Mock <IUnitOfWork>();
var AutoMapperMock = new Mock <IMapper>();
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/door/");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "door" }
});
var controller = new DoorController(_doorrepo.Object, _errorrepo.Object, _uow.Object);
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
DoorDTO newDoor = new DoorDTO {
Id = 2, Make = "NewDoor"
};
DoorDTO updatedoor = doorsDTO.First();
updatedoor.Make = "Updated";
//Act
var _response = controller.Update(request, updatedoor);
// Assert
Assert.AreEqual(_response.StatusCode, HttpStatusCode.OK);
}
public void Route_ActionName()
{
// Arrange
ApiController api = new UsersRpcController();
HttpRouteData route = new HttpRouteData(new HttpRoute());
route.Values.Add("action", "Admin");
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, routeData: route, request: new HttpRequestMessage()
{
Method = HttpMethod.Post
});
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersRpcController));
// Act
HttpResponseMessage message = api.ExecuteAsync(controllerContext, CancellationToken.None).Result;
User user = message.Content.ReadAsAsync <User>().Result;
// Assert
Assert.Equal("Yao", user.FirstName);
Assert.Equal("Huang", user.LastName);
}
public async Task AuthorizeAsyncHonorsTheCancellationToken()
{
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var mockDependencyScope = new Mock <IDependencyScope>();
var mockAuthPolicy = new Mock <IAuthorizationPolicy>();
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction");
mockDependencyScope.Setup(scope => scope.GetServices(It.Is <Type>(param => param == typeof(IAuthorizationPolicy))))
.Returns(new [] { mockAuthPolicy.Object });
mockAuthPolicy.SetupGet(policy => policy.Enabled).Returns(true);
mockAuthPolicy.SetupGet(policy => policy.Policy).Returns(AuthorizationPolicy.AuthenticatedPrincipal);
mockAuthPolicy.Setup(policy => policy.Evaluate(It.Is <HttpActionContext>(context => context == actionContext))).Returns(HttpStatusCode.Forbidden);
request.SetConfiguration(httpConfiguration);
request.SetRouteData(routeData);
request.Properties.Add(HttpPropertyKeys.DependencyScope, mockDependencyScope.Object);
var cancellationToken = new CancellationToken(true);
var authAttribute = new OrderFulfillmentAuthorizeAttribute();
await authAttribute.OnAuthorizationAsync(actionContext, cancellationToken);
actionContext.Response.Should().BeNull("because cancellation should have occured before authorization took place");
mockDependencyScope.Verify(scope => scope.GetServices(It.Is <Type>(param => param == typeof(IAuthorizationPolicy))), Times.Never, "The cancellation should have taken place before a policy was sought");
}
protected virtual void SetupControllerForTests(ApiController controller)
{
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Post, GetControllerPath());
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "Account" }
});
var principal = new Mock <IPrincipal>();
principal.Setup(p => p.Identity).Returns(Identity);
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.RequestContext.Principal = principal.Object;
controller.Request = request;
controller.Request.SetConfiguration(config);
var owinContext = new OwinContext();
owinContext.Set(UserManager);
request.SetOwinContext(owinContext);
}
public void DeleteMethodTest()
{
var httpconfiguration = new HttpConfiguration();
WebApiConfig.Register(httpconfiguration);
var httpRouteData = new HttpRouteData(httpconfiguration.Routes["DefaultApi"],
new HttpRouteValueDictionary
{
{ "controller", "Cars" }
});
var controller = new CarsController()
{
Request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost:6664/api/cars")
{
Properties =
{
{
HttpPropertyKeys.HttpConfigurationKey, httpconfiguration
},
{
HttpPropertyKeys.HttpRouteDataKey, httpRouteData
},
}
}
};
var response = controller.Delete(22);
//var response2 = controller.GetbyId(2);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); // if it finds a car with that id then it deletes and compares status code which is
//OK with the returned status code which should be OK since it has deleted it succesfully
//var car2 = response.Content.ReadAsAsync<Car>().Result;
//var car = response2.Content.ReadAsAsync<Car>().Result;
//Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
//Assert.AreEqual(HttpStatusCode.NotFound , response2.StatusCode);
}
public void Init()
{
// Arrange
var context = new DiffDbContext();
var repository = new EfDiffRepository(context);
_ctrl = new DiffController(repository);
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/v1/Diff");
var route = config.Routes.MapHttpRoute("Diffs", "v1/{controller}/{diffId}/{side}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary
{
{ "controller", "Diff" },
{ "side", "^left$|^right$|^$" },
{ "diffId", @"\d+" }
});
_ctrl.ControllerContext = new HttpControllerContext(config, routeData, request);
_ctrl.Request = request;
_ctrl.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
}
public void GetGames_should_return_all_games_with_pagination()
{
//Arrange
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:58326/api/games");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "games" }
});
_gamesController.ControllerContext = new HttpControllerContext(config, routeData, request);
_gamesController.Request = request;
_gamesController.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
_gameService.Setup(x => x.GetAll(It.IsAny <PaginationParameters>(), It.IsAny <FilterParameters>())).Returns(new PagedList <GameDTO>(new List <GameDTO>(), 5, 1, 10));
//Act
var response = _gamesController.GetGames(It.IsAny <FilterParameters>(), It.IsAny <PaginationParameters>());
//Assert
Assert.IsTrue((response as ResponseMessageResult).Response.Headers.Contains("X-Pagination"));
}
public void Post_should_store_StoreDataStep_type()
{
// assemble
FlowTemplate captured = null;
A.CallTo(() => _flowTemplateService.Add(A <FlowTemplate> ._))
.Invokes((FlowTemplate item) => captured = item);
var instance = new FlowTemplateDto
{
Name = "Example Step",
Steps = new List <FlowTemplateStepDto>
{
new FlowTemplateStepDto {
StepTypeName = "StoreDataStep"
},
}
};
var controller = new FlowTemplatesController(_flowTemplateService);
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/FlowTemplates");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "FlowTemplates" }
});
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
controller.Request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, routeData);
// act
controller.Post(instance);
// assert
A.CallTo(() => _flowTemplateService.Add(A <FlowTemplate> ._)).MustHaveHappened(Repeated.Exactly.Once);
Assert.IsType <StoreDataStep>(captured.Steps[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 void Post_Logginn_NOT_Found_I_DB()
{
LogInn bruker = new LogInn();
bruker.Brukernavn = "*****@*****.**";
bruker.Passord = "passord123";
var commandBus = new Mock <IBrukerLogikk>();
commandBus.Setup(c => c.BrukerIdb(bruker)).Returns(true);
// Mapper.CreateMap<CategoryFormModel, CreateOrUpdateCategoryCommand>();
var httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"],
new HttpRouteValueDictionary {
{ "controller", "Authenticate" }
});
var controller = new AuthenticateController(commandBus.Object)
{
Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/Authenticate/")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
LogInn nyBruker = new LogInn();
nyBruker.Brukernavn = "*****@*****.**";
nyBruker.Passord = "yolo1231";
var response = controller.Post(nyBruker);
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
// Act
}
public async Task AuthorizeAsyncFailsWhenTheSinglePolicyIsUnsatisfied()
{
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var mockDependencyScope = new Mock <IDependencyScope>();
var mockAuthPolicy = new Mock <IAuthorizationPolicy>();
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
var expectedStatus = HttpStatusCode.Unauthorized;
mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction");
mockDependencyScope.Setup(scope => scope.GetServices(It.Is <Type>(param => param == typeof(IAuthorizationPolicy))))
.Returns(new [] { mockAuthPolicy.Object });
mockAuthPolicy.SetupGet(policy => policy.Enabled).Returns(true);
mockAuthPolicy.SetupGet(policy => policy.Policy).Returns(AuthorizationPolicy.AuthenticatedPrincipal);
mockAuthPolicy.Setup(policy => policy.Evaluate(It.Is <HttpActionContext>(context => context == actionContext))).Returns(expectedStatus);
request.SetConfiguration(httpConfiguration);
request.SetRouteData(routeData);
request.Properties.Add(HttpPropertyKeys.DependencyScope, mockDependencyScope.Object);
var authAttribute = new OrderFulfillmentAuthorizeAttribute(AuthorizationPolicy.AuthenticatedPrincipal);
await authAttribute.OnAuthorizationAsync(actionContext, CancellationToken.None);
actionContext.Response.Should().NotBeNull("because a failed authorization should set the result");
actionContext.Response.StatusCode.Should().Be(expectedStatus, "because callers are forbidden when authorization fails.");
}
public void GenerateChallengeProducesTheChallenge()
{
var config = new SharedSecretAuthenticationConfiguration
{
PrimaryKey = "its-a-key!",
PrimarySecret = "zomg!",
SecondaryKey = "another-key",
SecondarySecret = "another-secret"
};
var headerTokens = new Dictionary <string, string>
{
{ "Authentication", "SharedSecret" }
};
var handler = new SharedSecretAuthenticationHandler(config);
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
var authcontext = new HttpAuthenticationChallengeContext(actionContext, new UnauthorizedResult(new [] { new AuthenticationHeaderValue("TEST", "") }, request));
request.Headers.Add(Core.Infrastructure.HttpHeaders.ApplicationKey, "bad-key");
request.Headers.Add(Core.Infrastructure.HttpHeaders.ApplicationSecret, "bad secret");
var result = handler.GenerateChallenge(headerTokens, authcontext);
result.Should().NotBeNull("because a challenge should always be generated");
result.Scheme.Should().Be(handler.HandlerType.ToString(), "because the scheme should match the authentication type");
}
public void AuthenticateSuceedsWithSecondaryKeyAndSecret()
{
var config = new SharedSecretAuthenticationConfiguration
{
PrimaryKey = "its-a-key!",
PrimarySecret = "zomg!",
SecondaryKey = "another-key",
SecondarySecret = "another-secret"
};
var headerTokens = new Dictionary <string, string>
{
{ "Authentication", "SharedSecret" }
};
var handler = new SharedSecretAuthenticationHandler(config);
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
var authcontext = new HttpAuthenticationContext(actionContext, null);
request.Headers.Add(Core.Infrastructure.HttpHeaders.ApplicationKey, config.SecondaryKey);
request.Headers.Add(Core.Infrastructure.HttpHeaders.ApplicationSecret, config.SecondarySecret);
var result = handler.Authenticate(headerTokens, authcontext);
result.Should().NotBeNull("because the primary secret was used in the header");
result.Should().BeOfType <ClaimsPrincipal>("because authentication should return a claims principal");
}
public void GetShowDataIDDoesNotExistsShouldFailTest()
{
StaticCache.LoadStaticCache();
ShowController sc = new ShowController();
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:22121/api/show/GetShowData");
var route = config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "show" }
});
sc.ControllerContext = new HttpControllerContext(config, routeData, request);
request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
var response = sc.GetShowData(100);
Assert.AreEqual(response.StatusCode, HttpStatusCode.NotFound);
}
public void PostTeleTextWithStringParam()
{
// Set up Prerequisites
var sampleText = "SAMPLE TEXT";
var config = new HttpConfiguration();
var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:58592/api/teletext");
var route = config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "TeleText" }
});
var controller = new TeleTextController();
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
// Act
var result = controller.Post(sampleText);
// Assert
Assert.AreEqual(HttpStatusCode.Created, result.StatusCode);
}
protected HttpActionExecutedContext GetActionExcecutedContextWithMockWebApiSettings(DateTime date)
{
var routes = new HttpRouteCollection("/");
var route = routes.MapHttpRoute("DefaultApi", "{controller}/{date}");
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary(new { date = date.ToString("yyyy-MM-dd") }));
var executingContext = GetActionContext(HttpMethod.Get, string.Format("http://any.where/test/{0}", date.ToString("yyyy-MM-dd")), routeData);
var mock = new Mock <IDependencyResolver>();
mock.Setup(m => m.GetService(typeof(WebAPISettings))).Returns(new WebAPISettings
{
CacheDurationFuture = new TimeSpan(5, 0, 0),
CacheDurationToday = new TimeSpan(0, 0, 30),
CacheDurationPast = new TimeSpan(42, 0, 0, 0)
});
executingContext.ControllerContext.Configuration.DependencyResolver = mock.Object;
var response = GetResponseMessage("#just some content stuff", executingContext);
return(GetActionExecutedContext(response, executingContext));
}
/// <summary>
/// Establishes the Request and ControllerContext properties of the specified ApiController with test-specific values
/// </summary>
/// <param name="controller">The WebApiController to set up</param>
/// <param name="method">Defaults to "GET"</param>
/// <param name="controllerName">Defaults to "ctrl"</param>
/// <param name="actionName">Defaults to "method"</param>
/// <param name="id">Defaults to missing</param>
public static void SetupForUnitTest(this ApiController controller, HttpMethod method = null, string controllerName = "ctrl", string actionName = "method", string id = null)
{
var config = new HttpConfiguration();
WebApiConfig.Register(config);
var url = string.Format("http://localhost/api/v1/{0}/{1}{2}", controllerName, actionName, id == null ? "" : "/" + id);
var request = new HttpRequestMessage(method ?? HttpMethod.Get, url);
var httpRouteValueDictionary = new HttpRouteValueDictionary {
{ "controller", controllerName }, { "action", "method" }
};
if (id != null)
{
httpRouteValueDictionary.Add("id", id);
}
var routeData = new HttpRouteData(config.Routes[0], httpRouteValueDictionary);
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
}
public void Post_Sjef_OK()
{
Sjef innBruker = new Sjef()
{
BrukerId = 1,
ProsjektId = 1
};
var commandBus = new Mock <IBrukerLogikk>();
commandBus.Setup(c => c.GiBrukerAdminTilgang(It.IsAny <Sjef>(), 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", "SjefApi" }
});
var controller = new SjefController(commandBus.Object)
{
Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/SjefApi/")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
// Act
var response = controller.Post(innBruker);
// Assert
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
Assert.AreEqual(string.Format("http://localhost/api/SjefApi"), response.Headers.Location.ToString());
}
public void Delete_ProsjektDeltakelse_Bad_Request()
{
var pros = new ProsjektrequestMelding();
pros.MeldingId = 0;
var commandBus = new Mock <IProsjektLogikk>();
commandBus.Setup(c => c.RegistrerProsjektdeltakelse(pros, 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", "ProsjektDeltakelseApi" }
});
var controller = new ProsjektDeltakelseApiController(commandBus.Object)
{
Request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/ProsjektDeltakelseApi/")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
// Act
// The ASP.NET pipeline doesn't run, so validation don't run.
controller.ModelState.AddModelError("MeldingId", "mock error message");
var response = controller.Delete(0);
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task AuthorizeAsyncWhenNoPoliciesAreActive()
{
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var mockDependencyScope = new Mock <IDependencyScope>();
var mockPrincipalPolicy = new Mock <IAuthorizationPolicy>();
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction");
mockDependencyScope.Setup(scope => scope.GetServices(It.Is <Type>(param => param == typeof(IAuthorizationPolicy))))
.Returns(new [] { mockPrincipalPolicy.Object });
mockPrincipalPolicy.SetupGet(policy => policy.Enabled).Returns(true);
mockPrincipalPolicy.SetupGet(policy => policy.Policy).Returns(AuthorizationPolicy.AuthenticatedPrincipal);
mockPrincipalPolicy.Setup(policy => policy.Evaluate(It.Is <HttpActionContext>(context => context == actionContext))).Returns(HttpStatusCode.Unauthorized);
request.SetConfiguration(httpConfiguration);
request.SetRouteData(routeData);
request.Properties.Add(HttpPropertyKeys.DependencyScope, mockDependencyScope.Object);
var authAttribute = new OrderFulfillmentAuthorizeAttribute(new AuthorizationPolicy[0]);
await authAttribute.OnAuthorizationAsync(actionContext, CancellationToken.None);
actionContext.Response.Should().NotBeNull("because there should have been a policy failure");
actionContext.Response.StatusCode.Should().Be(HttpStatusCode.Unauthorized, "because an enabled policy should have failed");
}
public void AuthenticateDoesNotSucceedWithMismatchedSecret()
{
var config = new SharedSecretAuthenticationConfiguration
{
PrimaryKey = "its-a-key!",
PrimarySecret = "zomg!",
SecondaryKey = "not primary",
SecondarySecret = "other secret"
};
var headerTokens = new Dictionary <string, string>
{
{ "Authentication", "SharedSecret" }
};
var handler = new SharedSecretAuthenticationHandler(config);
var mockActionDescriptor = new Mock <HttpActionDescriptor>();
var httpConfiguration = new HttpConfiguration();
var routeData = new HttpRouteData(new HttpRoute());
var request = new HttpRequestMessage();
var controllerDescriptor = new HttpControllerDescriptor {
Configuration = httpConfiguration, ControllerName = "generic"
};
var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request)
{
ControllerDescriptor = controllerDescriptor
};
var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object);
var authcontext = new HttpAuthenticationContext(actionContext, null);
request.Headers.Add(Core.Infrastructure.HttpHeaders.ApplicationKey, config.PrimaryKey);
request.Headers.Add(Core.Infrastructure.HttpHeaders.ApplicationSecret, config.SecondarySecret);
var result = handler.Authenticate(headerTokens, authcontext);
result.Should().BeNull("because an invalid key/secret combo was specified in the header");
}
public void TopicsController_Post()
{
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" }
});
_ctrl.ControllerContext = new HttpControllerContext(config, routeData, request);
_ctrl.Request = request;
_ctrl.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
var newTopic = new Topic()
{
Title = "A new Test Topic",
Body = "This is the body of new test topic"
};
var result = _ctrl.Post(newTopic);
Assert.AreEqual(HttpStatusCode.Created, result.StatusCode);
var json = result.Content.ReadAsStringAsync().Result;
var topic = JsonConvert.DeserializeObject <Topic>(json);
Assert.IsNotNull(topic);
Assert.IsTrue(topic.Id > 0);
Assert.IsTrue(topic.Created > DateTime.MinValue);
}
public void PUT_Bruker_Ok()
{
Profil nyBruker = new Profil()
{
Fornavn = "Mats",
Etternavn = "Lokken",
Telefonnummer = "93686771"
};
var commandBus = new Mock <IBrukerLogikk>();
commandBus.Setup(c => c.EndreBrukerInfo(It.IsAny <Profil>(), 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", "Profil" }
});
var controller = new ProfilController(commandBus.Object)
{
Request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/Profil/")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
// Act
var response = controller.Put(nyBruker);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
// var newCategory = JsonConvert.DeserializeObject<CategoryModel>(response.Content.ReadAsStringAsync().Result);
}
public void Post_Logginn_Ok()
{
LogInn nyBruker = new LogInn()
{
Brukernavn = "*****@*****.**",
Passord = "password"
};
var commandBus = new Mock <IBrukerLogikk>();
commandBus.Setup(c => c.BrukerIdb(It.IsAny <LogInn>())).Returns(true);
var httpConfiguration = new HttpConfiguration();
WebApiConfig.Register(httpConfiguration);
var httpRouteData = new HttpRouteData(httpConfiguration.Routes["DefaultApi"],
new HttpRouteValueDictionary {
{ "controller", "Authenticate" }
});
var controller = new AuthenticateController(commandBus.Object)
{
Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/Authenticate/")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
// Act
var response = controller.Post(nyBruker);
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
// Assert.AreEqual(string.Format("http://localhost/api/Authenticate/", nyBruker.Brukernavn), response.Headers.Location.ToString());
}
public static void Create(ApiController controller, string requestType, string service)
{
var config = new HttpConfiguration();
HttpMethod requestMethod = HttpMethod.Post;
switch (requestType)
{
case "post": requestMethod = HttpMethod.Post;
break;
case "get": requestMethod = HttpMethod.Get;
break;
case "delete": requestMethod = HttpMethod.Delete;
break;
case "put": requestMethod = HttpMethod.Put;
break;
default:
throw new ArgumentException("Invalid request type");
}
var request = new HttpRequestMessage(requestMethod, "http://localhost/api/" + service);
var route = config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
var routeData = new HttpRouteData(route);
routeData.Values.Add("id", RouteParameter.Optional);
routeData.Values.Add("controller", service);
controller.ControllerContext = new HttpControllerContext(config, routeData, request);
controller.Request = request;
controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
controller.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
}
public void Post_Vakt_Bad_request()
{
var commandBus = new Mock <IVaktLogikk>();
commandBus.Setup(c => c.RegistrerVakt(It.IsAny <Vaktskjema>(), 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", "VaktApi" }
});
var controller = new Jobbplan.Controllers.VaktApiController(commandBus.Object)
{
Request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/VaktApi/")
{
Properties =
{
{ HttpPropertyKeys.HttpConfigurationKey, httpConfiguration },
{ HttpPropertyKeys.HttpRouteDataKey, httpRouteData }
}
}
};
Vaktskjema vakter = new Vaktskjema();
vakter.start = "";
vakter.end = "";
// The ASP.NET pipeline doesn't run, so validation don't run.
controller.ModelState.AddModelError("start", "mock error message");
var response = controller.Post(vakter);
// Assert
commandBus.Verify(e => e.RegistrerVakt(vakter, "mats"), Times.Never);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
// Act
}
