public void WithContentHeadersDictionaryShouldPopulateCorrectHeaders()
{
var httpRequestMessage = MyWebApi
.Controller <WebApiController>()
.WithHttpRequestMessage(request => request
.WithStringContent(StringContent)
.WithContentHeaders(new Dictionary <string, IEnumerable <string> >
{
{ TestHeader, new[] { TestHeaderValue, AnotherTestHeaderValue } },
}))
.AndProvideTheHttpRequestMessage();
Assert.IsTrue(httpRequestMessage.Content.Headers.Contains(TestHeader));
Assert.IsTrue(httpRequestMessage.Content.Headers.First(h => h.Key == TestHeader).Value.Contains(TestHeaderValue));
Assert.IsTrue(httpRequestMessage.Content.Headers.First(h => h.Key == TestHeader).Value.Contains(AnotherTestHeaderValue));
}
public void WithStringContentAndActionShouldNotThrowExceptionWithCorrectAssertions()
{
var request = new HttpRequestMessage();
request.Headers.Add("StringContent", "StringContent");
MyWebApi
.Controller <WebApiController>()
.Calling(c => c.HttpResponseMessageWithStringContent())
.ShouldReturn()
.HttpResponseMessage()
.WithStringContent(content =>
{
Assert.AreEqual("Test string", content);
});
}
public void WithHttpRequestMessageShouldPopulateCorrectRequestAndReturnOk()
{
var request = new HttpRequestMessage
{
Method = HttpMethod.Post
};
request.Headers.Add("TestHeader", "TestHeaderValue");
MyWebApi
.Controller <WebApiController>()
.WithHttpRequestMessage(request)
.Calling(c => c.CustomRequestAction())
.ShouldReturn()
.Ok();
}
public void LinkGenerationShouldWorkCorrectlyWithCustomBaseAddress()
{
MyWebApi
.IsUsingDefaultHttpConfiguration(TestObjectFactory.GetCustomInlineConstraintResolver())
.WithBaseAddress("http://mytestedasp.net");
MyWebApi
.Controller <WebApiController>()
.Calling(c => c.WithGeneratedLink(1))
.ShouldReturn()
.Created()
.AtLocation("http://mytestedasp.net/api/test?id=1");
RemoteServer.DisposeGlobal();
MyWebApi.IsUsing(TestObjectFactory.GetHttpConfigurationWithRoutes());
}
public void WithAuthenticationHeaderChallengesShouldThrowExceptionWhenResultDoesNotContainExactlyAllProvidedHeadersWithWrongDataAndBuilder()
{
MyWebApi
.Controller <WebApiController>()
.Calling(c => c.UnauthorizedActionWithChallenges())
.ShouldReturn()
.Unauthorized()
.WithAuthenticationHeaderChallenges(
authHeaders =>
authHeaders
.ContainingHeader(header => header.WithScheme("TestScheme").WithParameter("TestParameter"))
.AndAlso()
.ContainingHeader(header => header.WithScheme("YetAnotherScheme").WithParameter("YetAnotherParameter"))
.AndAlso()
.ContainingHeader(header => header.WithScheme("Scheme")));
}
public void WithModelStateShouldThrowExceptionWhenModelStateHasMoreErrors()
{
var requestModelWithErrors = TestObjectFactory.GetRequestModelWithErrors();
var modelState = new ModelStateDictionary();
modelState.AddModelError("Integer", "The field Integer must be between 1 and 2147483647.");
modelState.AddModelError("RequiredString", "The RequiredString field is not required.");
modelState.AddModelError("RequiredString", "The RequiredString field is required.");
MyWebApi
.Controller <WebApiController>()
.Calling(c => c.BadRequestWithModelState(requestModelWithErrors))
.ShouldReturn()
.BadRequest()
.WithModelState(modelState);
}
public void AddRatingShouldAddARatingAndReturnItsInt()
{
MyWebApi
.Controller <UserRatingsController>()
.WithResolvedDependencies(DummyServices.GetDummyUserRatingsService())
.Calling(c => c.AddRating(new UserRatingResponseModel
{
ClientId = "Test",
HitmanId = "Test2",
Rating = 1
}))
.ShouldReturn()
.Ok()
.WithResponseModelOfType <int>()
.Passing(r => r == DummyRepositories.NumberOfTestObjects - 1);
}
public void ContainingFormattersShouldNotThrowExceptionWhenActionResultHasCorrectMediaTypeFormattersAsParams()
{
var mediaTypeFormatters = TestObjectFactory.GetFormatters().ToList();
MyWebApi
.Controller <WebApiController>()
.Calling(c => c.OkResultWithContentNegotiatorAction())
.ShouldReturn()
.Ok()
.ContainingMediaTypeFormatters(
mediaTypeFormatters[0],
mediaTypeFormatters[1],
mediaTypeFormatters[2],
mediaTypeFormatters[3],
mediaTypeFormatters[4]);
}
public void IsUsingShouldOverrideTheDefaultConfiguration()
{
// run two test cases in order to check the configuration is global
var configs = new List <HttpConfiguration>();
for (int i = 0; i < 2; i++)
{
var controller = MyWebApi.Controller <WebApiController>().Controller;
var actualConfig = controller.Configuration;
Assert.IsNotNull(actualConfig);
configs.Add(actualConfig);
}
Assert.AreSame(configs[0], configs[1]);
}
public void GET_profiles_name_Should_Return_Named_User_Profile()
{
MyWebApi
.Routes()
.ShouldMap("api/profiles/Wizard")
.To <ProfilesController>(c => c.GetProfileByName("Wizard"));
MyWebApi
.Controller <ProfilesController>()
.WithTestRig(rig)
.WithAuthenticatedUser(rig.WizardUser())
.Calling(c => c.GetProfileByName("Wizard"))
.ShouldReturn()
.Ok()
.WithResponseModelOfType <ProfileDto>()
.Passing(dto => dto.Name == "Wizard" && dto.Uri.EndsWith("/api/profiles/Wizard"));
}
public void ShouldHavePostAttribute()
{
var member = new Membership(12)
{
Id = 0,
FkHotel = 9,
Price = 1200.000M
};
// tests whether action has specific attribute type
MyWebApi
.Controller <MembershipController>()
.Calling(c => c.Post(member))
.ShouldHave()
.ActionAttributes(attributes => attributes
.ContainingAttributeOfType <HttpPostAttribute>());
}
public void AndProvideShouldReturnProperHttpRequestMessage()
{
var httpRequestMessage = MyWebApi
.Controller <WebApiController>()
.WithHttpRequestMessage(request
=> request
.WithMethod(HttpMethod.Get)
.WithHeader("TestHeader", "TestHeaderValue"))
.Calling(c => c.HttpResponseMessageAction())
.ShouldReturn()
.HttpResponseMessage()
.AndProvideTheHttpRequestMessage();
Assert.IsNotNull(httpRequestMessage);
Assert.AreEqual(HttpMethod.Get, httpRequestMessage.Method);
Assert.IsTrue(httpRequestMessage.Headers.Contains("TestHeader"));
}
public void ContainingContentHeadersShouldNotThrowExceptionWithCorrectDictionaryOfHeadersWithInvalidCount()
{
MyWebApi
.Controller <WebApiController>()
.Calling(c => c.HttpResponseMessageAction())
.ShouldReturn()
.HttpResponseMessage()
.ContainingContentHeaders(new Dictionary <string, IEnumerable <string> >
{
{ "TestHeader", new List <string> {
"TestHeaderValue"
} },
{ "AnotherTestHeader", new List <string> {
"TestHeaderValue"
} }
});
}
public async Task DeletingImagesShouldWorkCorrectly()
{
var dummyImageService = DummyServices.GetDummyImagesService();
var currentImagesCount = dummyImageService.All().Count();
var result = await MyWebApi
.Controller <ImagesController>()
.WithResolvedDependencies(dummyImageService)
.Calling(c => c.Delete(3))
.ShouldReturn()
.ResultOfType <Task <IHttpActionResult> >()
.AndProvideTheModel();
var newImageCount = dummyImageService.All().Count();
Assert.IsTrue(newImageCount == currentImagesCount - 1);
}
public void GetWithBothBiggerShouldReturnFiltered()
{
MyWebApi
.Controller <CommentsController>()
.WithResolvedDependencies(Services.GetCommentServices())
.Calling(c => c.Get("TestUser 1", new QueryRealEstates()
{
Skip = 3, Take = 3
}))
.ShouldReturn()
.Ok()
.WithResponseModelOfType <List <CommentResponseModel> >()
.Passing(model =>
{
Assert.AreEqual(0, model.Count);
});
}
public void WithoutAnyConfigurationShouldInstantiateDefaultOne()
{
MyWebApi.IsUsing(null);
var config = MyWebApi
.Controller <WebApiController>()
.WithHttpRequestMessage(request => request.WithMethod(HttpMethod.Get))
.Calling(c => c.CustomRequestAction())
.ShouldReturn()
.BadRequest()
.AndProvideTheController()
.Configuration;
Assert.IsNotNull(config);
MyWebApi.IsUsing(TestObjectFactory.GetHttpConfigurationWithRoutes());
}
public void CallingShouldHaveValidModelStateWhenThereAreNoModelErrors()
{
var requestModel = TestObjectFactory.GetValidRequestModel();
var controller = MyWebApi
.Controller <WebApiController>()
.Calling(c => c.OkResultActionWithRequestBody(1, requestModel))
.ShouldReturn()
.Ok()
.AndProvideTheController();
var modelState = controller.ModelState;
Assert.IsTrue(modelState.IsValid);
Assert.AreEqual(0, modelState.Values.Count);
Assert.AreEqual(0, modelState.Keys.Count);
}
public void WithAuthenticatedNotCalledShouldNotHaveAuthorizedUser()
{
var controllerBuilder = MyWebApi
.Controller <WebApiController>();
controllerBuilder
.Calling(c => c.AuthorizedAction())
.ShouldReturn()
.NotFound();
var controllerUser = controllerBuilder.AndProvideTheController().User;
Assert.AreEqual(false, controllerUser.IsInRole("Any"));
Assert.AreEqual(null, controllerUser.Identity.Name);
Assert.AreEqual(null, controllerUser.Identity.AuthenticationType);
Assert.AreEqual(false, controllerUser.Identity.IsAuthenticated);
}
public void WithAuthenticatedUserUsingPrincipalShouldWorkCorrectly()
{
var controllerBuilder = MyWebApi
.Controller <WebApiController>();
controllerBuilder
.WithAuthenticatedUser(TestObjectFactory.GetClaimsPrincipal())
.Calling(c => c.AuthorizedAction())
.ShouldReturn()
.NotFound();
var controllerUser = controllerBuilder.AndProvideTheController().User;
Assert.AreEqual("CustomUser", controllerUser.Identity.Name);
Assert.AreEqual(null, controllerUser.Identity.AuthenticationType);
Assert.IsFalse(controllerUser.Identity.IsAuthenticated);
}
public void GetShouldReturnOkWhenProjectIsNotNull()
{
MyWebApi
.Controller <ProjectsController>()
.WithResolvedDependencyFor(TestObjectFactory.GetProjectsService())
.WithAuthenticatedUser()
.Calling(c => c.Get("Valid"))
.ShouldReturn()
.Ok()
.WithResponseModelOfType <SoftwareProjectDetailsResponseModel>()
.Passing(pr =>
{
Assert.AreEqual(new DateTime(2015, 11, 5, 23, 47, 12), pr.CreatedOn);
Assert.AreEqual("Test", pr.Name);
Assert.AreEqual(0, pr.TotalUsers);
});
}
public void CallingShouldPopulateModelStateWhenThereAreModelErrors()
{
var requestModel = TestObjectFactory.GetRequestModelWithErrors();
var controller = MyWebApi
.Controller <WebApiController>()
.Calling(c => c.OkResultActionWithRequestBody(1, requestModel))
.ShouldReturn()
.Ok()
.AndProvideTheController();
var modelState = controller.ModelState;
Assert.IsFalse(modelState.IsValid);
Assert.AreEqual(2, modelState.Values.Count);
Assert.AreEqual("Integer", modelState.Keys.First());
Assert.AreEqual("RequiredString", modelState.Keys.Last());
}
public void WithHttpConfigurationShouldOverrideTheDefaultOne()
{
var config = new HttpConfiguration();
var controllerConfig = MyWebApi
.Controller <WebApiController>()
.WithHttpConfiguration(config)
.AndProvideTheController()
.Configuration;
var controllerConfigFromApi = MyWebApi
.Controller <WebApiController>()
.WithHttpConfiguration(config)
.AndProvideTheHttpConfiguration();
Assert.AreSame(config, controllerConfig);
Assert.AreSame(config, controllerConfigFromApi);
}
public void Initialize()
{
userManager = new UserManager(new UserRepository(new EFDbContext(ContextEnum.BeatBuddyTest)));
organisationManager = new OrganisationManager(new OrganisationRepository(new EFDbContext(ContextEnum.BeatBuddyTest)));
user = userManager.CreateUser("*****@*****.**", "matthias", "test", "acidshards", "");
_organisationControllerWithAuthenticatedUser = MyWebApi.Controller <OrganisationsController>()
.WithResolvedDependencyFor <IUserManager>(userManager)
.WithResolvedDependencyFor <IOrganisationManager>(organisationManager)
.WithAuthenticatedUser(
u => u.WithIdentifier("NewId")
.WithUsername(user.Email)
.WithClaim(new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.Email, user.Email))
.WithClaim(new System.Security.Claims.Claim("sub", user.Email))
);
organisation = organisationManager.CreateOrganisation("testorganisatie", "", user);
}
public void WithAuthenticatedUserShouldPopulateUserPropertyWithDefaultValues()
{
var controllerBuilder = MyWebApi
.Controller <WebApiController>()
.WithAuthenticatedUser();
controllerBuilder
.Calling(c => c.AuthorizedAction())
.ShouldReturn()
.Ok();
var controllerUser = controllerBuilder.AndProvideTheController().User;
Assert.AreEqual(false, controllerUser.IsInRole("Any"));
Assert.AreEqual("TestUser", controllerUser.Identity.Name);
Assert.AreEqual("Passport", controllerUser.Identity.AuthenticationType);
Assert.AreEqual(true, controllerUser.Identity.IsAuthenticated);
}
public void WithContentHeaderAndMultipleValuesShouldPopulateCorrectHeader()
{
var headers = new[]
{
TestHeaderValue, AnotherTestHeaderValue
};
var httpRequestMessage = MyWebApi
.Controller <WebApiController>()
.WithHttpRequestMessage(request => request
.WithStringContent(StringContent)
.WithContentHeader(TestHeader, headers))
.AndProvideTheHttpRequestMessage();
Assert.IsTrue(httpRequestMessage.Content.Headers.Contains(TestHeader));
Assert.IsTrue(httpRequestMessage.Content.Headers.First(h => h.Key == TestHeader).Value.Contains(TestHeaderValue));
Assert.IsTrue(httpRequestMessage.Content.Headers.First(h => h.Key == TestHeader).Value.Contains(AnotherTestHeaderValue));
}
public async Task PostingImagesShouldCreateAnImageAndReturnItsId()
{
Random random = new Random();
var result = await MyWebApi
.Controller <ImagesController>()
.WithResolvedDependencies(DummyServices.GetDummyImagesService())
.Calling(c => c.Post(new ImageRequestModel()
{
Name = "SUPER COOL TEST IMAGE",
Extension = "gif",
Data = "R0lGODlhAQABAIAAAP///////yH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==",
UserId = "1",
}))
.ShouldReturn()
.ResultOfType <Task <IHttpActionResult> >()
.AndProvideTheModel();
//.WithResponseModelOfType<int>()
//.Passing(c => c == DummyRepositories.NumberOfTestObjects + 1);
}
public void AtLocationWithBuilderShouldNotThrowExceptionIfTheLocationIsCorrect()
{
MyWebApi
.Controller <WebApiController>()
.Calling(c => c.RedirectActionWithUri())
.ShouldReturn()
.Redirect()
.AtLocation(location =>
location
.WithHost("somehost.com")
.AndAlso()
.WithAbsolutePath("/someuri/1")
.AndAlso()
.WithPort(80)
.AndAlso()
.WithScheme("http")
.AndAlso()
.WithFragment(string.Empty)
.AndAlso()
.WithQuery("?query=Test"));
}
public void WithSetupShouldSetCorrectPropertiesToController()
{
var actionContext = new HttpActionContext();
var user = TestObjectFactory.GetClaimsPrincipal();
var config = new HttpConfiguration();
var controller = MyWebApi
.Controller <WebApiController>()
.WithSetup(c =>
{
c.ActionContext = actionContext;
c.User = user;
c.Configuration = config;
})
.AndProvideTheController();
Assert.NotNull(controller);
Assert.AreSame(actionContext, controller.ActionContext);
Assert.AreSame(user, controller.User);
Assert.AreSame(config, controller.Configuration);
}
public void PostShouldValidateModelState()
{
MyWebApi
.Controller <ProjectsController>()
.WithResolvedDependencyFor(TestObjectFactory.GetProjectsService())
.Calling(c => c.Post(TestObjectFactory.GetInvalidModel()))
.ShouldHave()
.InvalidModelState();
//var controller = new ProjectsController(TestObjectFactory.GetProjectsService());
//controller.Configuration = new HttpConfiguration();
//var model = TestObjectFactory.GetInvalidModel();
//controller.Validate(model);
//var result = controller.Post(model);
//Assert.IsFalse(controller.ModelState.IsValid);
}
public void AndAlsoShouldBuildCorrectHttpRequestMessage()
{
var httpRequestMessage = MyWebApi
.Controller <WebApiController>()
.WithHttpRequestMessage(request
=> request
.WithMethod("GET")
.AndAlso()
.WithRequestUri(RequestUri)
.AndAlso()
.WithVersion("1.1")
.AndAlso()
.WithStringContent(StringContent))
.AndProvideTheHttpRequestMessage();
Assert.AreEqual(HttpMethod.Get, httpRequestMessage.Method);
Assert.AreEqual(new Uri(RequestUri), httpRequestMessage.RequestUri);
Assert.AreEqual(new Version(1, 1), httpRequestMessage.Version);
Assert.IsAssignableFrom <StringContent>(httpRequestMessage.Content);
Assert.AreEqual(StringContent, httpRequestMessage.Content.ReadAsStringAsync().Result);
}