public void VoidActionShouldNotThrowExceptionWithCorrectResponse()
{
MyController <MvcController>
.Instance()
.Calling(c => c.CustomResponseAction())
.ShouldHave()
.HttpResponse(response => response
.WithContentType(ContentType.ApplicationJson)
.AndAlso()
.WithStatusCode(HttpStatusCode.InternalServerError)
.AndAlso()
.ContainingHeader("TestHeader", "TestHeaderValue")
.ContainingCookie("TestCookie", "TestCookieValue", new CookieOptions
{
HttpOnly = true,
Secure = true,
Domain = "testdomain.com",
Expires = new DateTimeOffset(new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc)),
Path = "/"
}))
.AndAlso()
.ShouldReturn()
.Ok();
}
public void AddProduct_WithValidData_ShouldReturnProductShowReceiptViewModel()
=> MyController <ReceiptController>
.Instance()
.WithDependencies(
this.receiptService,
this.productService,
this.userManager)
.WithUser("testUser")
.WithHttpRequest(x =>
x.WithLocation("/Receipt/Add")
.AndAlso()
.WithMethod(HttpMethod.Post))
.Calling(x => x.AddProduct(new ReceiptAddProductInputModel()
{
Id = this.dbContext.Products.FirstOrDefault().Id,
Quantity = 4
}))
.ShouldHave()
.ValidModelState()
.AndAlso()
.ShouldReturn()
.ResultOfType <ActionResult <ProductShowReceiptViewModel> >()
.AndAlso()
.ShouldPassForThe <ActionResult <ProductShowReceiptViewModel> >(x => x.Value.ProductName == "testProduct");
public void WithJsonSerializerSettingsShouldThrowExceptionWithActionSettings()
{
var jsonSettings = new JsonSerializerSettings
{
CheckAdditionalContent = true,
NullValueHandling = NullValueHandling.Ignore
};
Test.AssertException <JsonResultAssertionException>(
() =>
{
MyController <MvcController>
.Instance()
.Calling(c => c.JsonWithSpecificSettingsAction(jsonSettings))
.ShouldReturn()
.Json(json => json
.WithJsonSerializerSettings(settings =>
{
settings.WithAdditionalContentChecking(false);
settings.WithNullValueHandling(NullValueHandling.Ignore);
}));
},
"When calling JsonWithSpecificSettingsAction action in MvcController expected JSON result serializer settings to have disabled checking for additional content, but in fact it was enabled.");
}
public void WithResponseCookieBuilderShouldNotThrowExceptionWithCorrectCookie()
{
MyController <MvcController>
.Instance()
.Calling(c => c.CustomVoidResponseAction())
.ShouldHave()
.HttpResponse(response => response
.ContainingCookie(cookie => cookie
.WithName("TestCookie")
.AndAlso()
.WithValue("TestCookieValue")
.AndAlso()
.WithSecurity(true)
.AndAlso()
.WithHttpOnly(true)
.AndAlso()
.WithMaxAge(null)
.AndAlso()
.WithDomain("testdomain.com")
.AndAlso()
.WithExpiration(new DateTimeOffset(new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc)))
.AndAlso()
.WithPath("/")));
}
public void WithCacheOptionsShouldSetCorrectValues()
{
MyController <MemoryCacheController>
.Instance()
.WithMemoryCache(memoryCache => memoryCache
.WithEntry("FullEntry", "FullEntryValid", new MemoryCacheEntryOptions
{
AbsoluteExpiration = new DateTimeOffset(new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc)),
AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1),
Priority = CacheItemPriority.High,
SlidingExpiration = TimeSpan.FromMinutes(5)
}))
.Calling(c => c.FullMemoryCacheAction(From.Services <IMemoryCache>()))
.ShouldReturn()
.Ok(ok => ok
.WithModel(new CacheEntryMock("FullEntry")
{
Value = "FullEntryValid",
AbsoluteExpiration = new DateTimeOffset(new DateTime(2016, 1, 1, 1, 1, 1, DateTimeKind.Utc)),
AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1),
Priority = CacheItemPriority.High,
SlidingExpiration = TimeSpan.FromMinutes(5)
}));
}
public void ContainingEntryWithOptionsShouldThrowExceptionWithIncorrectSlidingExpiration()
{
var cacheValue = new byte[] { 127, 127, 127 };
Test.AssertException <DataProviderAssertionException>(
() =>
{
MyController <MvcController>
.Instance()
.Calling(c => c.AddDistributedCacheAction())
.ShouldHave()
.DistributedCache(cache => cache
.ContainingEntry("test", cacheValue, new DistributedCacheEntryOptions
{
AbsoluteExpiration = new DateTimeOffset(new DateTime(2020, 1, 1, 1, 1, 1, DateTimeKind.Utc)),
AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1),
SlidingExpiration = TimeSpan.FromMinutes(3)
}))
.AndAlso()
.ShouldReturn()
.Ok();
},
"When calling AddDistributedCacheAction action in MvcController expected distributed cache to have entry with the given options, but in fact they were different.");
}
public void WithMultipleLicensesNoExceptionShouldBeThrown()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithTestConfiguration(config =>
{
config.AddJsonFile("multilicenseconfig.json");
});
LicenseValidator.ClearLicenseDetails();
TestCounter.SetLicenseData(null, DateTime.MinValue, "MyTested.AspNetCore.Mvc.Tests");
Task.Run(async() =>
{
var tasks = new List <Task>();
for (int i = 0; i < 500; i++)
{
tasks.Add(Task.Run(() =>
{
MyController <MvcController>
.Instance()
.Calling(c => c.OkResultAction())
.ShouldReturn()
.Ok();
}));
}
await Task.WhenAll(tasks);
})
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
MyApplication.StartsFrom <DefaultStartup>();
}
public void ClearingSessionShouldReturnCorrectEmptyCollectionOfKeys()
{
this.SetDefaultSession();
IDictionary <string, string> entries = new Dictionary <string, string>
{
{ "testKey1", "testValue1" },
{ "testKey2", "testValue2" }
};
MyController <MvcController>
.Instance()
.WithSession(session =>
{
session.WithEntries(entries);
})
.WithoutSession()
.Calling(c => c.GetSessionKeysCount())
.ShouldReturn()
.Ok(ok => ok
.WithModel(0));
MyApplication.StartsFrom <DefaultStartup>();
}
public void WithoutSetReturnsCorrectDataWhenWholeRangeIsRemoved()
{
MyApplication
.StartsFrom <TestStartup>()
.WithServices(services => services.AddDbContext <CustomDbContext>());
var models = new List <CustomModel> {
new CustomModel
{
Id = 1,
Name = "Test"
}
};
MyController <DbContextController>
.Instance()
.WithData(models)
.WithoutData(data =>
data.WithoutSet <CustomModel>(
cm => cm.RemoveRange(models)))
.Calling(c => c.GetAll())
.ShouldReturn()
.NotFound();
}
public void WithoutDataByProvidingNonExistingModelAndKeyInBuilderShouldRemoveTheCorrectObject()
{
MyApplication
.StartsFrom <TestStartup>()
.WithServices(services => services.AddDbContext <CustomDbContext>());
var model = new CustomModel
{
Id = 1,
Name = "Test"
};
var keyToRemove = int.MaxValue;
MyController <DbContextController>
.Instance()
.WithData(model)
.WithoutData(data => data.WithoutEntityByKey <CustomModel>(keyToRemove))
.Calling(c => c.Get(model.Id))
.ShouldReturn()
.Ok(ok => ok
.WithModelOfType <CustomModel>()
.Passing(cm => cm.Name.Equals(model.Name)));
}
public void CreateGetShouldReturnRightModelsAndRightCountriesCount()
=> MyController <PredictionsController>
.Instance()
.WithUser()
.WithData(data => data
.WithEntities(entity => entity.AddRange(
new Country {
Name = "England"
},
new Country {
Name = "Finland"
},
new Country {
Name = "Russia"
})))
.Calling(x => x.Create())
.ShouldReturn()
.View(viewResult => viewResult
.WithModelOfType <CreatePredictionInputViewModel>()
.Passing(x =>
{
Assert.Equal(3, x.Countries.Count());
Assert.IsType <List <CountriesDropDownViewModel> >(x.Countries);
}));
public void WithControllerContextSetupShouldSetCorrectControllerContextForPocoController()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services =>
{
services.AddHttpContextAccessor();
});
MyController <FullPocoController>
.Instance()
.WithControllerContext(controllerContext =>
{
controllerContext.RouteData.Values.Add("testkey", "testvalue");
})
.ShouldPassForThe <FullPocoController>(controller =>
{
Assert.NotNull(controller);
Assert.NotNull(controller.CustomControllerContext);
Assert.True(controller.CustomControllerContext.RouteData.Values.ContainsKey("testkey"));
});
MyApplication.StartsFrom <DefaultStartup>();
}
public void WithRequestAsObjectShouldWorkWithSetRequestActionForPocoController()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services =>
{
services.AddHttpContextAccessor();
});
var httpContext = new HttpContextMock();
httpContext.Request.Form = new FormCollection(new Dictionary <string, StringValues> {
["Test"] = "TestValue"
});
MyController <FullPocoController>
.Instance()
.WithHttpRequest(httpContext.Request)
.Calling(c => c.WithRequest())
.ShouldReturn()
.Ok();
MyApplication.StartsFrom <DefaultStartup>();
}
public void Result_WithValidISIN_ShouldRedirectToDetailsView(string searchTerm)
{
var shareClass = ShareClassTestData
.GenerateShareClasses()
.FirstOrDefault(sc => sc.ScIsinCode == searchTerm);
var date = DateTime.Today.ToString(GlobalConstants.RequiredWebDateTimeFormat);
var routeValues = new
{
area = EndpointsConstants.ShareClassArea,
id = shareClass.ScId,
date = date
};
MyController <SearchController>
.Instance()
.WithData(data => data.WithEntities <ApplicationDbContext>(shareClass))
.Calling(c => c.Result(searchTerm))
.ShouldReturn()
.RedirectToRoute(
EndpointsConstants.RouteDetails + EndpointsConstants.ShareClassArea,
routeValues);
}
public void WithIdShouldSetIdCorrectly()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services =>
{
services.AddMemoryCache();
services.AddDistributedMemoryCache();
services.AddSession();
});
MyController <MvcController>
.Instance()
.WithSession(session => session
.WithId("TestId")
.AndAlso()
.WithEntry("HasId", "HasIdValue"))
.Calling(c => c.FullSessionAction())
.ShouldReturn()
.Ok(ok => ok
.WithModel("TestId"));
MyApplication.StartsFrom <DefaultStartup>();
}
public void CreateShouldReturnCreatedResultWhenValidModelState(
string country,
string state,
string city,
string description,
string postalCode,
string phoneNumber)
=> MyController <AddressesController>
.Instance(instance => instance
.WithUser())
.Calling(c => c.Create(new AddressesRequestModel
{
Country = country,
State = state,
City = city,
Description = description,
PostalCode = postalCode,
PhoneNumber = phoneNumber
}))
.ShouldHave()
.ValidModelState()
.AndAlso()
.ShouldReturn()
.Created();
public void HomeControllerShouldReturnView() => MyController <HomeController> .Instance() .Calling(c => c.Index()) .ShouldReturn() .View();
public void DetailsShouldReturnNotFoundWhenInvalidArticleId() => MyController <ArticlesController> .Instance() .Calling(c => c.Details(int.MaxValue)) .ShouldReturn() .NotFound();
public void IHttpContextAccessorShouldWorkCorrectlyAsynchronously()
{
MyApplication
.StartsFrom <DefaultStartup>()
.WithServices(services =>
{
services.AddHttpContextAccessor();
});
Task
.Run(async() =>
{
HttpContext firstContextAsync = null;
HttpContext secondContextAsync = null;
HttpContext thirdContextAsync = null;
HttpContext fourthContextAsync = null;
HttpContext fifthContextAsync = null;
var tasks = new List <Task>
{
Task.Run(() =>
{
MyController <HttpContextController>
.Instance()
.ShouldPassForThe <HttpContextController>(controller =>
{
firstContextAsync = controller.Context;
});
}),
Task.Run(() =>
{
MyController <HttpContextController>
.Instance()
.ShouldPassForThe <HttpContextController>(controller =>
{
secondContextAsync = controller.Context;
});
}),
Task.Run(() =>
{
MyController <HttpContextController>
.Instance()
.ShouldPassForThe <HttpContextController>(controller =>
{
thirdContextAsync = controller.Context;
});
}),
Task.Run(() =>
{
MyController <HttpContextController>
.Instance()
.ShouldPassForThe <HttpContextController>(controller =>
{
fourthContextAsync = controller.Context;
});
}),
Task.Run(() =>
{
MyController <HttpContextController>
.Instance()
.ShouldPassForThe <HttpContextController>(controller =>
{
fifthContextAsync = controller.Context;
});
})
};
await Task.WhenAll(tasks);
Assert.NotNull(firstContextAsync);
Assert.NotNull(secondContextAsync);
Assert.NotNull(thirdContextAsync);
Assert.NotNull(fourthContextAsync);
Assert.NotNull(fifthContextAsync);
Assert.IsAssignableFrom <HttpContextMock>(firstContextAsync);
Assert.IsAssignableFrom <HttpContextMock>(secondContextAsync);
Assert.IsAssignableFrom <HttpContextMock>(thirdContextAsync);
Assert.IsAssignableFrom <HttpContextMock>(fourthContextAsync);
Assert.IsAssignableFrom <HttpContextMock>(fifthContextAsync);
Assert.NotSame(firstContextAsync, secondContextAsync);
Assert.NotSame(firstContextAsync, thirdContextAsync);
Assert.NotSame(secondContextAsync, thirdContextAsync);
Assert.NotSame(thirdContextAsync, fourthContextAsync);
Assert.NotSame(fourthContextAsync, fifthContextAsync);
Assert.NotSame(thirdContextAsync, fifthContextAsync);
})
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
MyApplication.StartsFrom <DefaultStartup>();
}
public void EditGetShouldReturnNotFoundWhenInvalidId() => MyController <ArticlesController> .Instance() .Calling(c => c.Edit(With.Any <int>())) .ShouldReturn() .NotFound();
public void ConfirmDeleteShouldReturnNotFoundWhenInvalidId() => MyController <ArticlesController> .Instance() .Calling(c => c.ConfirmDelete(With.Any <int>())) .ShouldReturn() .NotFound();
public void IndexShouldReturnView() => MyController <ContactsController> .Instance() .Calling(c => c.Index()) .ShouldReturn() .View();
public void ErrorShouldReturnErrorView() => MyController <HomeController> .Instance() .Calling(c => c.Error()) .ShouldReturn() .View(v => v.WithModelOfType(typeof(ErrorViewModel)));
public void PrivacyShouldReturnView() => MyController <HomeController> .Instance() .Calling(c => c.Privacy()) .ShouldReturn() .View();
public void UserControllerActions_ShouldBeAllowedOnlyForAuthorizedUsers() => MyController <UserController> .Instance() .ShouldHave() .Attributes(attributes => attributes.RestrictingForAuthorizedRequests());
public void WithEntitiesShouldSetupDbContext()
{
MyApplication
.StartsFrom <TestStartup>()
.WithServices(services =>
{
services.AddDbContext <CustomDbContext>(options =>
options.UseSqlServer("Server=(localdb)\\MSSQLLocalDB;Database=TestDb;Trusted_Connection=True;MultipleActiveResultSets=true;Connect Timeout=30;"));
});
MyController <DbContextController>
.Instance()
.WithData(data => data
.WithEntities <CustomDbContext>(db => db
.Models.Add(new CustomModel
{
Id = 1, Name = "Test"
})))
.Calling(c => c.Find(1))
.ShouldReturn()
.Ok(ok => ok
.WithModelOfType <CustomModel>()
.Passing(m => m.Name == "Test"));
MyController <DbContextController>
.Instance()
.WithData(data => data
.WithEntities(db => db.Add(new CustomModel
{
Id = 1,
Name = "Test"
})))
.Calling(c => c.Find(1))
.ShouldReturn()
.Ok(ok => ok
.WithModelOfType <CustomModel>()
.Passing(m => m.Name == "Test"));
MyController <DbContextController>
.Instance()
.WithData(data => data
.WithEntities(
new CustomModel
{
Id = 1,
Name = "Test 1"
},
new CustomModel
{
Id = 2,
Name = "Test 2"
}))
.Calling(c => c.Find(1))
.ShouldReturn()
.Ok(ok => ok
.WithModelOfType <CustomModel>()
.Passing(m => m.Name == "Test 1"));
MyController <DbContextController>
.Instance()
.WithData(data => data
.WithEntities <CustomDbContext>(db => db
.Models.Add(new CustomModel
{
Id = 2,
Name = "Test"
})))
.Calling(c => c.Find(1))
.ShouldReturn()
.NotFound();
MyController <DbContextController>
.Instance()
.WithData(data => data
.WithEntities <CustomDbContext>(
new CustomModel
{
Id = 2,
Name = "Test 2"
},
new CustomModel
{
Id = 3,
Name = "Test 3"
}))
.Calling(c => c.Find(1))
.ShouldReturn()
.NotFound();
MyController <DbContextController>
.Instance()
.Calling(c => c.Find(1))
.ShouldReturn()
.NotFound();
MyApplication.StartsFrom <DefaultStartup>();
}
public void WithSetShouldSetupMultipleDbContext()
{
MyApplication
.StartsFrom <TestStartup>()
.WithServices(services =>
{
services.AddDbContext <CustomDbContext>(options =>
options.UseSqlServer("Server=(localdb)\\MSSQLLocalDB;Database=TestDb;Trusted_Connection=True;MultipleActiveResultSets=true;Connect Timeout=30;"));
services.AddDbContext <AnotherDbContext>(options =>
options.UseSqlServer("Server=(localdb)\\MSSQLLocalDB;Database=AnotherTestDb;Trusted_Connection=True;MultipleActiveResultSets=true;Connect Timeout=30;"));
});
var modelName = "Test";
var anotherModelName = "Another Test";
MyController <MultipleDbContextController>
.Instance()
.WithData(data => data
.WithSet <CustomDbContext, CustomModel>(set => set
.Add(new CustomModel
{
Id = 1,
Name = modelName
}))
.WithSet <AnotherDbContext, AnotherModel>(set => set
.Add(new AnotherModel
{
Id = 1,
FullName = anotherModelName
})))
.Calling(c => c.Find(1))
.ShouldReturn()
.Ok(ok => ok
.WithModel(new
{
Model = modelName,
AnotherModel = anotherModelName
}));
MyController <MultipleDbContextController>
.Instance()
.WithData(data => data
.WithSet <CustomDbContext, CustomModel>(set => set
.Add(new CustomModel
{
Id = 2,
Name = modelName
})))
.Calling(c => c.Find(1))
.ShouldReturn()
.NotFound();
MyController <MultipleDbContextController>
.Instance()
.WithData(data => data
.WithSet <AnotherDbContext, AnotherModel>(set => set
.Add(new AnotherModel
{
Id = 2,
FullName = anotherModelName
})))
.Calling(c => c.Find(1))
.ShouldReturn()
.NotFound();
MyController <DbContextController>
.Instance()
.Calling(c => c.Find(1))
.ShouldReturn()
.NotFound();
MyApplication.StartsFrom <DefaultStartup>();
}
public void WithStatusCodeShouldNotThrowExceptionWithCorrectStatusCode()
{
MyApplication
.StartsFrom <TestStartup>()
.WithServices(services =>
{
services.AddActionContextAccessor();
});
var context = new PCHUBDbContext();
var mock = new Mock <ILogger <HomeController> >();
ILogger <HomeController> logger = mock.Object;
var model = new IndexViewModel();
//or use this short equivalent
logger = Mock.Of <ILogger <HomeController> >();
var service = new HomeService(context);
var mapperConfiguration = new MapperConfiguration(config =>
{
config.AddProfile <AdminProfile>();
config.AddProfile <ProductsProfile>();
config.AddProfile <UsersProfile>();
config.AddProfile <ApiProfile>();
});
var mapper = new Mapper(mapperConfiguration);
MyController <HomeController>
.Instance(
instance => instance
.WithDependencies(
logger,
service,
mapper
))
.Calling(c => c.Index())
.ShouldReturn()
.View(view => view.WithModelOfType <IndexViewModel>().Passing(model => model.Boxes.Any()));
MyRouting
.Configuration()
.ShouldMap(request => request
.WithLocation("/Home/Index")
.WithMethod(HttpMethod.Get))
.To <HomeController>(c => c.Index());
MyController <HomeController>
.Instance(instance => instance
.WithDependencies(
logger,
service,
mapper
)
.WithUser(user => user
.WithUsername("obelix")))
.Calling(c => c.Index())
.ShouldReturn()
.View(view => view.WithModelOfType <IndexViewModel>().Passing(model => model.Categories.Any()));
MyRouting
.Configuration()
.ShouldMap(request => request
.WithLocation("/Home/Error")
.WithMethod(HttpMethod.Get))
.To <HomeController>(c => c.Error());
MyRouting
.Configuration()
.ShouldMap(request => request
.WithLocation("/Home/Privacy")
.WithMethod(HttpMethod.Get))
.To <HomeController>(c => c.Privacy());
// Task<ActionResult<List<ApiProductHistoryViewModel>>> ReviewedProducts()
MyController <HomeController>
.Instance(instance => instance
.WithDependencies(
logger,
service,
mapper
)
.WithUser(user => user
.WithUsername("obelix")))
.Calling(c => c.ReviewedProducts())
.ShouldReturn()
.ActionResult(result => result.Object(obj => obj.WithModelOfType <List <ApiProductHistoryViewModel> >().Passing(x => x.Any())));
}
public void ErrorReturnsView() => MyController <HomeController> .Instance() .Calling(c => c.Error()) .ShouldReturn() .View();
public void WithHttpRequestShouldWorkCorrectlyWithDefaultValues()
{
var stream = new MemoryStream();
var requestCookies = new CustomRequestCookieCollection
{
["MyRequestCookie"] = "MyRequestCookieValue",
["AnotherRequestCookie"] = "AnotherRequestCookieValue"
};
var files = new[]
{
new FormFile(stream, 0, 0, "FirstFile", "FirstFileName"),
new FormFile(stream, 0, 0, "SecondFile", "SecondFileName"),
};
MyController <MvcController>
.Instance()
.WithHttpRequest(request => request
.WithBody(stream)
.WithContentLength(1)
.WithContentType(ContentType.ApplicationJson)
.AndAlso()
.WithCookie("MyCookie", "MyCookieValue")
.WithCookies(new Dictionary <string, string>
{
{ "MyDictCookie", "MyDictCookieValue" },
{ "AnotherDictCookie", "AnotherDictCookieValue" }
})
.WithCookies(requestCookies)
.WithCookies(new
{
ObjectCookie = "ObjectCookieValue",
AnotherObjectCookie = "AnotherObjectCookieValue"
})
.AndAlso()
.WithFormField("Field", "FieldValue")
.WithFormField("MultiField", "FirstFieldValue", "SecondFieldValue")
.WithFormFields(new Dictionary <string, IEnumerable <string> >
{
{ "MyDictField", new[] { "MyDictFieldValue" } },
{ "AnotherDictField", new[] { "AnotherDictFieldValue" } }
})
.AndAlso()
.WithFormFiles(files)
.AndAlso()
.WithHeader("MyHeader", "MyHeaderValue")
.WithHeader("MultiHeader", "FirstHeaderValue", "SecondHeaderValue")
.WithHeaders(new Dictionary <string, IEnumerable <string> >
{
{ "MyDictHeader", new[] { "MyDictHeaderValue" } },
{ "AnotherDictHeader", new[] { "AnotherDictHeaderValue" } }
})
.AndAlso()
.WithHost("mytestedasp.net")
.WithMethod("POST")
.WithPath("/all")
.WithPathBase("/api")
.WithProtocol("protocol")
.WithQueryString("?key=value&another=yetanother")
.WithHttps())
.ShouldPassForThe <HttpRequest>(builtRequest =>
{
Assert.Same(stream, builtRequest.Body);
Assert.Equal(1, builtRequest.ContentLength);
Assert.Same(ContentType.ApplicationJson, builtRequest.ContentType);
Assert.Equal(7, builtRequest.Cookies.Count);
Assert.Equal("MyCookieValue", builtRequest.Cookies["MyCookie"]);
Assert.Equal("MyDictCookieValue", builtRequest.Cookies["MyDictCookie"]);
Assert.Equal("AnotherDictCookieValue", builtRequest.Cookies["AnotherDictCookie"]);
Assert.Equal("MyRequestCookieValue", builtRequest.Cookies["MyRequestCookie"]);
Assert.Equal("AnotherRequestCookieValue", builtRequest.Cookies["AnotherRequestCookie"]);
Assert.Equal("ObjectCookieValue", builtRequest.Cookies["ObjectCookie"]);
Assert.Equal("AnotherObjectCookieValue", builtRequest.Cookies["AnotherObjectCookie"]);
Assert.Equal(4, builtRequest.Form.Count);
Assert.Equal("FieldValue", builtRequest.Form["Field"]);
Assert.Equal("FirstFieldValue,SecondFieldValue", builtRequest.Form["MultiField"]);
Assert.Equal("MyDictFieldValue", builtRequest.Form["MyDictField"]);
Assert.Equal("AnotherDictFieldValue", builtRequest.Form["AnotherDictField"]);
Assert.Equal(2, builtRequest.Form.Files.Count);
Assert.Same(files[0], builtRequest.Form.Files[0]);
Assert.Same(files[1], builtRequest.Form.Files[1]);
Assert.Equal(8, builtRequest.Headers.Count);
Assert.Equal("MyHeaderValue", builtRequest.Headers["MyHeader"]);
Assert.Equal("FirstHeaderValue,SecondHeaderValue", builtRequest.Headers["MultiHeader"]);
Assert.Equal("MyDictHeaderValue", builtRequest.Headers["MyDictHeader"]);
Assert.Equal("AnotherDictHeaderValue", builtRequest.Headers["AnotherDictHeader"]);
Assert.Equal("mytestedasp.net", builtRequest.Host.Value);
Assert.Equal("POST", builtRequest.Method);
Assert.Equal("/all", builtRequest.Path);
Assert.Equal("/api", builtRequest.PathBase);
Assert.Equal("protocol", builtRequest.Protocol);
Assert.Equal("?key=value&another=yetanother", builtRequest.QueryString.Value);
Assert.Equal("https", builtRequest.Scheme);
Assert.Equal(2, builtRequest.Query.Count);
Assert.Equal("value", builtRequest.Query["key"]);
Assert.Equal("yetanother", builtRequest.Query["another"]);
});
}