public void SecondLevelDomain(string urlText, string expectedSecondLevelDomain)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlText);
// Verify outcome
Assert.Equal(expectedSecondLevelDomain, url.SecondLevelDomain);
// Teardown
}
public void Scheme(UrlTestData urlData)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlData.Url);
// Verify outcome
Assert.Equal(urlData.Scheme, url.Scheme);
// Teardown
}
public void IsHttps_AbsoluteUrl(string urlText, bool expectedResult)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlText);
// Verify outcome
Assert.Equal(expectedResult, url.IsHttps);
// Teardown
}
public void HasParameter(string urlText, string parameter, bool expectedResult)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlText);
// Verify outcome
Assert.Equal(expectedResult, url.HasParameter(parameter));
// Teardown
}
//[InlineData("http://192.168.1.1/", true)]
public void IsDomainIPAddress(string urlText, bool expectedIsIPAddress)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlText);
// Verify outcome
Assert.Equal(expectedIsIPAddress, url.IsDomainAnIPAddress);
// Teardown
}
public void Normalized(UrlTestData urlData)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlData.Url);
// Verify outcome
Assert.Equal(urlData.Normalized, url.ToString());
// Teardown
}
public void Fragment(UrlTestData urlData)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlData.Url);
// Verify outcome
Assert.Equal(urlData.Fragment, url.Fragment);
// Teardown
}
public void RemoveParameter(string urlText, string parameter, string expectedQuery, string expectedPathAndQuery, string expectedPathAndQueryAndFragment)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlText).RemoveParameter(parameter);
// Verify outcome
Assert.Equal(expectedQuery, url.Query);
Assert.Equal(expectedPathAndQuery, url.PathAndQuery);
Assert.Equal(expectedPathAndQueryAndFragment, url.PathAndQueryAndFragment);
// Teardown
}
/// <summary>
/// Clones the client With a change
/// </summary>
public static Client With(this Client client, AbsoluteUrl baseUri)
=>
client != null ? new Client(
client.SerializationAdapter,
baseUri,
client.DefaultRequestHeaders,
client.logger is ILogger <Client> logger ? logger : null,
client.createHttpClient,
client.sendHttpRequestMessage,
client.getHttpRequestMessage,
client.ThrowExceptionOnFailure,
client.Name) : throw new ArgumentNullException(nameof(client));
public Response(
IHeadersCollection headersCollection,
int statusCode,
HttpRequestMethod httpRequestMethod,
byte[] responseData,
TResponseBody?body,
AbsoluteUrl requestUri
) : base(
headersCollection,
statusCode,
httpRequestMethod,
responseData,
requestUri) => Body = body;
public void FileName_HasFileName_And_Extension_HasExtension(string urlText, string expectedFileName, bool expectedHasFileName, string expectedExtension, bool expectedHasExtension)
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create(urlText);
// Verify outcome
Assert.Equal(expectedFileName, url.FileName);
Assert.Equal(expectedHasFileName, url.HasFileName);
Assert.Equal(expectedExtension, url.Extension);
Assert.Equal(expectedHasExtension, url.HasExtension);
// Teardown
}
public async Task TestPersonService()
{
var uri = new AbsoluteUrl("http://www.asdasd.com");
//Create a Person object to be sent as the Request
var requestPerson = new Person {
FirstName = "TestGuy", PersonKey = ""
};
//Create a Person object to be received from the Response
var responsePerson = new Person {
FirstName = "TestGuy", PersonKey = "123"
};
//Create mock objects
var clientFactoryMock = new Mock <CreateClient>();
var clientMock = new Mock <IClient>();
var serializationAdapterMock = new Mock <ISerializationAdapter>();
//Set the factory up to return the mock client
_ = clientFactoryMock.Setup(f => f.Invoke("Person", null)).Returns(clientMock.Object);
//Set the client up to return the response mock
var result = new Response <Person>
(
NullHeadersCollection.Instance,
200,
HttpRequestMethod.Post,
new byte[0],
responsePerson,
uri
);
_ = clientMock.Setup(c => c.SendAsync <Person, Person>(It.IsAny <IRequest <Person> >())).Returns(Task.FromResult(result));
#pragma warning disable CS8603 // Possible null reference return.
_ = clientMock.Setup(c => c.BaseUrl).Returns(uri);
#pragma warning restore CS8603 // Possible null reference return.
_ = serializationAdapterMock.Setup(c => c.Deserialize <Person>(It.IsAny <byte[]>(), It.IsAny <IHeadersCollection>())).Returns(responsePerson);
//Create the service and call SavePerson
var personService = new PersonService(clientFactoryMock.Object);
var returnPersonResponse = await personService.SavePerson(requestPerson);
Assert.AreEqual("123", returnPersonResponse?.Body?.PersonKey);
}
public void Create()
{
// Fixture setup
// Exercise system
var url = AbsoluteUrl.Create("http://*****:*****@example.com:8042/over/there/index.dtb?type=animal&name=narwhal#nose");
// Verify outcome
Assert.Equal("http", url.Scheme);
Assert.Equal("username:password", url.UserInfo);
Assert.Equal("example.com", url.Host);
Assert.Equal(8042, url.Port);
Assert.Equal("/over/there/index.dtb", url.Path);
Assert.Equal("type=animal&name=narwhal", url.Query);
Assert.Equal("nose", url.Fragment);
Assert.Equal("index.dtb", url.FileName);
Assert.Equal(".dtb", url.Extension);
// Teardown
}
/// <summary>
/// Construct a Request
/// </summary>
/// <param name="uri"></param>
/// <param name="bodyData"></param>
/// <param name="headers"></param>
/// <param name="httpRequestMethod"></param>
/// <param name="customHttpRequestMethod"></param>
/// <param name="cancellationToken"></param>
///
public Request(
AbsoluteUrl uri,
TBody?bodyData,
IHeadersCollection headers,
HttpRequestMethod httpRequestMethod,
string?customHttpRequestMethod = null,
CancellationToken cancellationToken = default)
{
BodyData = bodyData;
Uri = uri;
HttpRequestMethod = httpRequestMethod;
CancellationToken = cancellationToken;
CustomHttpRequestMethod = customHttpRequestMethod;
Headers = headers;
if (uri == null)
{
throw new ArgumentNullException(nameof(uri));
}
}
public void SaveSnapshot(string path)
{
if (!browser.AutoDownloadPagesResources)
{
DownloadResources();
}
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
else
{
Directory.GetFiles(path).ToList().ForEach(File.Delete);
}
foreach (var resource in Resources)
{
var guid = Guid.NewGuid();
resource.Content.Position = 0;
var fileName = guid.ToString("N");
RewriteHtml(resource, fileName);
if (!string.IsNullOrEmpty(resource.ContentType) && resource.ContentType.EndsWith("css", StringComparison.InvariantCultureIgnoreCase))
{
var textContent = resource.GetTextContent();
textContent = RewriteCssUrls(path, textContent, resource.AbsoluteUrl.ToString());
File.WriteAllText(Path.Combine(path, fileName), textContent);
}
else
{
File.WriteAllBytes(Path.Combine(path, fileName), resource.Content.ToArray());
}
}
var outerHtml = RewriteCssUrls(path, Html.OuterHtml, AbsoluteUrl.ToString());
File.WriteAllText(Path.Combine(path, "page.html"), outerHtml);
}
this AbsoluteUrl url,
IHeadersCollection?headersCollection = null,
CancellationToken cancellationToken = default)
{
if (url == null)
public static HttpServer GetSingleRequestServer(this AbsoluteUrl url, Func <HttpListenerContext, Task> func) => new(url, func);
