public ExternalLogin(
HttpClient client,
IHtmlDocument externalLogin,
DefaultUIContext context)
: base(client, externalLogin, context)
{
_emailForm = HtmlAssert.HasForm(Document);
Title = HtmlAssert.HasElement("#external-login-title", Document);
Description = HtmlAssert.HasElement("#external-login-description", Document);
}
public Register(HttpClient client, IHtmlDocument register, DefaultUIContext context)
: base(client, register, context)
{
_registerForm = HtmlAssert.HasForm("#registerForm", register);
if (context.ContosoLoginEnabled)
{
_externalLoginForm = HtmlAssert.HasForm("#external-account", register);
_contosoButton = HtmlAssert.HasElement("button[value=Contoso]", register);
}
}
public static Task <HttpResponseMessage> SendAsync(
this HttpClient client,
IHtmlFormElement form,
IEnumerable <KeyValuePair <string, string> > formValues)
{
var submitElement = Assert.Single(form.QuerySelectorAll("[type=submit]"));
var submitButton = Assert.IsAssignableFrom <IHtmlElement>(submitElement);
return(client.SendAsync(form, submitButton, formValues));
}
public EnableAuthenticator(
HttpClient client,
IHtmlDocument enableAuthenticator,
DefaultUIContext context)
: base(client, enableAuthenticator, context)
{
Assert.True(Context.UserAuthenticated);
_codeElement = HtmlAssert.HasElement("kbd", enableAuthenticator);
_sendCodeForm = HtmlAssert.HasForm("#send-code", enableAuthenticator);
}
public ResetAuthenticator(
HttpClient client,
IHtmlDocument resetAuthenticator,
DefaultUIContext context)
: base(client, resetAuthenticator, context)
{
Assert.True(Context.UserAuthenticated);
_resetAuthenticatorForm = HtmlAssert.HasForm("#reset-authenticator-form", resetAuthenticator);
_resetAuthenticatorButton = HtmlAssert.HasElement("#reset-authenticator-button", resetAuthenticator);
}
public static async Task <IHtmlDocument> RequestHtmlDocumentWithPostAsync(IHtmlFormElement form, IHtmlButtonElement submitBtn)
{
var factory = new WebApplicationFactory <Startup>();
var client = factory.CreateClient();
var response = await client.SendAsync(form, submitBtn);
var document = await HtmlHelpers.GetDocumentAsync(response);
return(document);
}
/// <summary>
/// 查找与指定元素绑定的 Label
/// </summary>
/// <param name="element">要查找绑定的 Label 的元素</param>
/// <returns>与元素绑定的 Label 集合，如果元素不支持绑定，则返回null</returns>
public static HtmlLabel[] Labels(this IHtmlFormElement element)
{
var control = element as IHtmlFocusableControl;
if (control == null)
{
return(null);
}
return(Labels(control));
}
private static HttpRequestMessage CreatePostRequest(IHtmlFormElement form,
IEnumerable <KeyValuePair <string, string> > formInputs)
{
var request = new HttpRequestMessage();
request.Method = new HttpMethod(form.Method);
request.RequestUri = new Uri(form.Action, UriKind.Relative);
request.Content = new FormUrlEncodedContent(formInputs);
return(request);
}
/// <summary>
/// 尝试获取与指定元素绑定的 Label 的文本
/// </summary>
/// <param name="element">要查找绑定的 Label 的元素</param>
/// <returns>绑定的 Label 的文本，如果元素不支持绑定或没找到则返回null</returns>
public static string LabelText(this IHtmlFormElement element)
{
var control = element as IHtmlFocusableControl;
if (control == null)
{
return(null);
}
return(LabelText(control));
}
public async Task Test1Async()
{
var context = BrowsingContext.New(Configuration.Default.WithDefaultLoader());
var queryDocument = await context.OpenAsync("https://google.com");
IHtmlFormElement form = queryDocument.QuerySelector("form") as IHtmlFormElement;
var resultDocument = await form.SubmitAsync(new { q = "anglesharp" });
Assert.True(resultDocument != null);
//
}
public static Task <HttpResponseMessage> SendAsync(
this HttpClient client,
IHtmlFormElement form,
IHtmlElement submitButton,
IEnumerable <KeyValuePair <string, string> > formValues)
{
foreach (var kvp in formValues)
{
/*
* var element = form[kvp.Key];
* var elementType = element.GetType();
*
* if (elementType is IHtmlInputElement || elementType is IHtmlTextAreaElement)
* {
*
* }
* else throw new Xunit.Sdk.IsAssignableFromException();
*/
try
{
var element = Assert.IsAssignableFrom <IHtmlInputElement>(form[kvp.Key]);
element.Value = kvp.Value;
}
catch
{
var element = Assert.IsAssignableFrom <IHtmlTextAreaElement>(form[kvp.Key]);
element.Value = kvp.Value;
}
}
var submit = form.GetSubmission(submitButton);
var target = (Uri)submit.Target;
if (submitButton.HasAttribute("formaction"))
{
var formaction = submitButton.GetAttribute("formaction");
target = new Uri(formaction, UriKind.Relative);
}
var submision = new HttpRequestMessage(new HttpMethod(submit.Method.ToString()), target)
{
Content = new StreamContent(submit.Body)
};
foreach (var header in submit.Headers)
{
submision.Headers.TryAddWithoutValidation(header.Key, header.Value);
submision.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
return(client.SendAsync(submision));
}
public ExternalLogin(
HttpClient client,
IHtmlDocument externalLogin,
DefaultUIContext context)
: base(client, externalLogin, context)
{
_emailForm = HtmlAssert.HasForm(Document);
var title = externalLogin.GetElementsByTagName("h4").FirstOrDefault(e => e.TextContent.StartsWith("Associate your"));
Assert.Equal("Associate your Contoso auth account.", title?.TextContent);
var info = externalLogin.QuerySelectorAll <IHtmlParagraphElement>(".text-info").FirstOrDefault(e => e.TextContent.Trim().StartsWith("You've successfully authenticated"));
Assert.StartsWith("You've successfully authenticated with Contoso auth.", info?.TextContent.Trim());
}
public Email(HttpClient client, IHtmlDocument manage, DefaultUIContext context)
: base(client, manage, context)
{
Assert.True(Context.UserAuthenticated);
_changeEmailForm = HtmlAssert.HasForm("#email-form", manage);
_emailInput = HtmlAssert.HasElement("#Email", manage);
_newEmailInput = HtmlAssert.HasElement("#Input_NewEmail", manage);
_changeEmailButton = HtmlAssert.HasElement("#change-email-button", manage);
if (!Context.EmailConfirmed)
{
_confirmEmailButton = HtmlAssert.HasElement("button#email-verification", manage);
}
}
public static async Task <IHtmlDocument> SendAsyncGetContent(
this HttpClient client,
IHtmlFormElement form,
IHtmlElement submitButton,
object formValuesObj
)
{
var formValues = new RouteValueDictionary(formValuesObj).Select(d => KeyValuePair.Create <string, string>(d.Key, d.Value.ToString()));
var resp = await client.SendAsync(form, submitButton, formValues);
var content = await HtmlHelpers.GetDocumentAsync(resp);
return(content);
}
public Login(
HttpClient client,
IHtmlDocument login,
DefaultUIContext context)
: base(client, login, context)
{
_loginForm = HtmlAssert.HasForm("#account", login);
_forgotPasswordLink = HtmlAssert.HasLink("#forgot-password", login);
if (Context.ContosoLoginEnabled)
{
_externalLoginForm = HtmlAssert.HasForm("#external-account", login);
_contosoButton = HtmlAssert.HasElement("button[value=Contoso]", login);
}
}
public static Task <HttpResponseMessage> SendAsync(
this HttpClient client,
IHtmlFormElement form,
IHtmlElement submitButton,
IEnumerable <KeyValuePair <string, string> > formValues)
{
foreach (var kvp in formValues)
{
switch (form[kvp.Key])
{
case IHtmlInputElement input:
input.Value = kvp.Value;
if (bool.TryParse(kvp.Value, out var isChecked))
{
input.IsChecked = isChecked;
}
break;
case IHtmlSelectElement select:
select.Value = kvp.Value;
break;
default:
throw new Exception($"Unknown form element: '{kvp.Key}'");
}
}
var submit = form.GetSubmission(submitButton);
var target = (Uri)submit.Target;
if (submitButton.HasAttribute("formaction"))
{
var formaction = submitButton.GetAttribute("formaction");
target = new Uri(formaction, UriKind.Relative);
}
var submision = new HttpRequestMessage(new HttpMethod(submit.Method.ToString()), target)
{
Content = new StreamContent(submit.Body)
};
foreach (var header in submit.Headers)
{
submision.Headers.TryAddWithoutValidation(header.Key, header.Value);
submision.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
return(client.SendAsync(submision));
}
/// <summary>
/// Submits the given form by using the dictionary which contains name
/// value pairs of input fields to submit.
/// </summary>
/// <param name="form">The form to submit.</param>
/// <param name="fields">The fields to use as values.</param>
/// <param name="createInputIfNoFound">What to do if some field/s have not found in the form. If true, then new input will be created.
/// If false, KeyNotFoundException will be thrown.
/// The default is false.
/// </param>
/// <returns>The task eventually resulting in the response.</returns>
public static Task <IDocument> Submit(this IHtmlFormElement form, IDictionary <String, String> fields, bool createInputIfNoFound = false)
{
if (form == null)
{
throw new ArgumentNullException("form");
}
if (fields == null)
{
throw new ArgumentNullException("fields");
}
form.SetFieldsValues(fields, createInputIfNoFound);
return(form.Submit());
}
public Index(HttpClient client, IHtmlDocument manage, DefaultUIContext context)
: base(client, manage, context)
{
Assert.True(Context.UserAuthenticated);
_profileLink = HtmlAssert.HasLink("#profile", manage);
_changePasswordLink = HtmlAssert.HasLink("#change-password", manage);
_twoFactorLink = HtmlAssert.HasLink("#two-factor", manage);
_personalDataLink = HtmlAssert.HasLink("#personal-data", manage);
_updateProfileForm = HtmlAssert.HasForm("#profile-form", manage);
if (!Context.EmailConfirmed)
{
_confirmEmailButton = HtmlAssert.HasElement("button#email-verification", manage);
}
}
public static Task <HttpResponseMessage> SendAsync(
this HttpClient client,
IHtmlFormElement form,
IEnumerable <KeyValuePair <string, string> > formValues)
{
Assert.That(form.QuerySelectorAll("[type=submit]") != null);
var submitElement = form.QuerySelectorAll("[type=submit]");
Assert.IsInstanceOf <IHtmlElement>(submitElement);
var submitButton = submitElement as IHtmlElement;
return(client.SendAsync(form, submitButton, formValues));
}
public static Task <HttpResponseMessage> SendAsync(
this HttpClient client,
IHtmlFormElement form,
IHtmlElement submitButton,
IEnumerable <KeyValuePair <string, string> > formValues)
{
foreach (var kvp in formValues)
{
try
{
var element = Assert.IsAssignableFrom <IHtmlInputElement>(form[kvp.Key]);
element.Value = kvp.Value;
}
catch (Exception)
{
var element = Assert.IsAssignableFrom <IHtmlSelectElement>(form[kvp.Key]);
foreach (var item in element.Options)
{
if (item.Value == kvp.Value)
{
item.IsSelected = true;
break;
}
}
}
}
var submit = form.GetSubmission(submitButton);
var target = (Uri)submit.Target;
if (submitButton.HasAttribute("formaction"))
{
var formaction = submitButton.GetAttribute("formaction");
target = new Uri(formaction, UriKind.Relative);
}
var submission = new HttpRequestMessage(new HttpMethod(submit.Method.ToString()), target)
{
Content = new StreamContent(submit.Body)
};
foreach (var header in submit.Headers)
{
submission.Headers.TryAddWithoutValidation(header.Key, header.Value);
submission.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
return(client.SendAsync(submission));
}
/// <summary>
/// Set the field values of given form by using the dictionary which contains name value pairs of input fields.
/// </summary>
/// <param name="form">The form to set</param>
/// <param name="fields">The fields to use as values.</param>
/// <param name="createInputIfNoFound">What to do if some field/s have not found in the form. If true, then new input will be created.
/// If false, KeyNotFoundException will be thrown.
/// The default is false.
/// </param>
public static void SetFieldsValues(this IHtmlFormElement form, IDictionary <string, string> fields, bool createInputIfNoFound = false)
{
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
if (fields == null)
{
throw new ArgumentNullException(nameof(fields));
}
// The actual execution of these queries is deferred.
var inputs = form.Elements.OfType <IHtmlInputElement>();
var selects = form.Elements.OfType <IHtmlSelectElement>();
foreach (var field in fields)
{
// try to match to an input element.
var input = inputs.FirstOrDefault(e => e.Name == field.Key);
if (input != null)
{
input.Value = field.Value;
continue;
}
// try to match to an select element.
var select = selects.FirstOrDefault(s => s.Name == field.Key);
if (select != null)
{
select.Value = field.Value;
continue;
}
// if no match, create new element or throw an excpetion.
if (createInputIfNoFound)
{
var newElementHtml = $@"<input type='hidden' name='{field.Key}' value='{field.Value}' />";
form.Insert(AdjacentPosition.BeforeEnd, newElementHtml);
}
else
{
throw new KeyNotFoundException($"Field {field.Key} not found");
}
}
}
public Index(HttpClient client, IHtmlDocument manage, DefaultUIContext context)
: base(client, manage, context)
{
Assert.True(Context.UserAuthenticated);
_profileLink = HtmlAssert.HasLink("#profile", manage);
_emailLink = HtmlAssert.HasLink("#email", manage);
_changePasswordLink = HtmlAssert.HasLink("#change-password", manage);
_twoFactorLink = HtmlAssert.HasLink("#two-factor", manage);
if (Context.ContosoLoginEnabled)
{
_externalLoginLink = HtmlAssert.HasLink("#external-login", manage);
}
_personalDataLink = HtmlAssert.HasLink("#personal-data", manage);
_updateProfileForm = HtmlAssert.HasForm("#profile-form", manage);
_userNameInput = HtmlAssert.HasElement("#Username", manage);
_updateProfileButton = HtmlAssert.HasElement("#update-profile-button", manage);
}
public static Task <HttpResponseMessage> SendAsync(
this HttpClient client,
IHtmlFormElement form,
IHtmlElement submitButton,
IEnumerable <KeyValuePair <string, string> > formValues)
{
foreach (var formValue in formValues)
{
if (form[formValue.Key] is IHtmlInputElement elementAsInput)
{
elementAsInput.Value = formValue.Value;
}
else if (form[formValue.Key] is IHtmlSelectElement)
{
var matchingSelect = form.QuerySelectorAll("select")
.OfType <IHtmlSelectElement>()
.FirstOrDefault(s => s.Children.OfType <IHtmlOptionElement>().Any(o => o.Value == formValue.Value));
if (matchingSelect != null)
{
matchingSelect.Value = formValue.Value;
}
}
}
var documentRequest = form.GetSubmission(submitButton);
var requestUri = submitButton.HasAttribute("formaction") ?
new Uri(submitButton.GetAttribute("formaction"), UriKind.Relative) :
documentRequest.Target;
var request = new HttpRequestMessage(new HttpMethod(documentRequest.Method.ToString()), requestUri)
{
Content = new StreamContent(documentRequest.Body)
};
foreach (var header in documentRequest.Headers)
{
request.Headers.TryAddWithoutValidation(header.Key, header.Value);
request.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
return(client.SendAsync(request));
}
public static Task <HttpResponseMessage> SendAsync(
this HttpClient client,
IHtmlFormElement form,
IHtmlElement submitButton,
IEnumerable <KeyValuePair <string, string> > formValues)
{
Assert.NotNull(form);
Assert.NotNull(submitButton);
foreach (KeyValuePair <string, string> kvp in formValues)
{
AngleSharp.Dom.IElement input = form[kvp.Key];
Assert.NotNull(input);
IHtmlInputElement element = Assert.IsAssignableFrom <IHtmlInputElement>(input);
element.Value = kvp.Value;
}
var submit = form.GetSubmission();
Assert.NotNull(submit);
var target = (Uri)submit.Target;
if (submitButton.HasAttribute("formaction"))
{
var formaction = submitButton.GetAttribute("formaction");
target = new Uri(formaction, UriKind.Relative);
}
var submission = new HttpRequestMessage(new HttpMethod(submit.Method.ToString()), target)
{
Content = new StreamContent(submit.Body)
};
foreach (var header in submit.Headers)
{
submission.Headers.TryAddWithoutValidation(header.Key, header.Value);
submission.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
}
return(client.SendAsync(submission));
}
public async Task <HttpResponseMessage> PostBackWithHtmlForm(string pageUri, CssSelectorForDom selector, Dictionary <string, string> postFormValue, string expectedRedirectedPage = null)
{
var response = await Client.GetAsync($"{RootUri}/{pageUri}");
var content = await HtmlHelper.GetDocumentAsync(response);
IHtmlFormElement form = (IHtmlFormElement)content.QuerySelector(selector.Form);
IHtmlButtonElement btnSubmit = (IHtmlButtonElement)content.QuerySelector(selector.SubmitButton);
//Act
HttpResponseMessage result = await Client.SendAsync(form, btnSubmit, postFormValue);
LastResponse = result;
//Assert
string requestUri = result.RequestMessage.RequestUri.ToString();
if (expectedRedirectedPage != null)
{
string expectedUri = (RootUri + '/' + expectedRedirectedPage).ToLower();
if (expectedUri != requestUri.ToLower())
{
throw new Exception($"Unexpected rediction of page: {requestUri}");
}
}
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
throw new HttpRequestException(await response.Content.ReadAsStringAsync());
}
/*Success might not be determined correctly
* due to Server still response Http status 200 OK
* but use JavaScript or Dom UI element to indicate error instead.
*/
return(result);
}
public async Task Warning_WhenNoText(string url)
{
//Arrange
HttpResponseMessage page = await _client.GetAsync(url);
IHtmlDocument document = await HtmlHelpers.GetDocumentAsync(page);
IHtmlFormElement form = (IHtmlFormElement)document.Body.SelectSingleNode(@".//form[@id=""messageForm""]");
IHtmlInputElement textField = (IHtmlInputElement)document.Body.SelectSingleNode(@".//input[@id=""textInput""]");
IHtmlInputElement submitButton = (IHtmlInputElement)document.Body.SelectSingleNode(@".//input[@id=""submitForNewMessage""]");
//Act
if (form != null)
{
textField.Value = "aaaaaaaaaaaaaaaaaaaaaaaaa";
await form.SubmitAsync(submitButton);
}
//Arrange
Assert.Equal(HttpStatusCode.OK, page.StatusCode);
}
private static List <KeyValuePair <string, string> > GetFormInputs(IHtmlFormElement form)
{
var pairs = new List <KeyValuePair <string, string> >();
var inputElements = form.QuerySelectorAll("input");
foreach (IHtmlInputElement element in inputElements)
{
if (element.Name != null && element.Name != string.Empty)
{
if (element.Type.Equals("checkbox", StringComparison.OrdinalIgnoreCase) &&
!element.IsChecked)
{
continue;
}
if (element.Type.Equals("submit", StringComparison.OrdinalIgnoreCase))
{
continue;
}
pairs.Add(new KeyValuePair <string, string>(element.Name, element.Value));
}
}
var selectElements = form.QuerySelectorAll("select");
foreach (IHtmlSelectElement element in selectElements)
{
if (element.SelectedIndex > -1)
{
var optionSelected = element[element.SelectedIndex];
pairs.Add(new KeyValuePair <string, string>(element.Name, optionSelected.Value));
}
}
return(pairs);
}
public ConsoleForm(IHtmlFormElement form)
{
_form = form;
}
public ResetPassword(HttpClient client, IHtmlDocument resetPassword, DefaultUIContext context) : base(client, resetPassword, context)
{
_resetPasswordForm = HtmlAssert.HasForm(resetPassword);
}
public LoginWithRecoveryCode(HttpClient client, IHtmlDocument loginWithRecoveryCode, DefaultUIContext context)
: base(client, loginWithRecoveryCode, context)
{
_loginWithRecoveryCodeForm = HtmlAssert.HasForm(loginWithRecoveryCode);
}
public ConsoleForm(IHtmlFormElement form)
{
_form = form;
}
