public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
var request = inp.CreateRequestFor(url);
var document = inp.Owner;
if (document != null)
{
var loader = document.Loader;
if (loader != null)
{
var download = loader.DownloadAsync(request);
var task = inp.ProcessResource <IImageInfo>(download, result => _img = result);
document.DelayLoad(task);
}
}
}
}
public async Task Post_EditWillUpdateEmployee()
{
// Arrange
Employee employee = (await GetAllEmloyees()).Last();
Department department = (await GetAllDepartments()).Last();
string url = $"employee/edit/{employee.Id}";
HttpResponseMessage editPageResponse = await _client.GetAsync(url);
IHtmlDocument editPage = await HtmlHelpers.GetDocumentAsync(editPageResponse);
string firstName = StringHelpers.EnsureMaxLength(
employee.FirstName + Guid.NewGuid().ToString(), 55);
string lastName = StringHelpers.EnsureMaxLength(
employee.LastName + Guid.NewGuid().ToString(), 55);
string isSupervisor = employee.IsSupervisor ? "false" : "true";
string departmentId = department.Id.ToString();
string departmentName = department.Name;
// Act
HttpResponseMessage response = await _client.SendAsync(
editPage,
new Dictionary <string, string>
{
{ "Employee_FirstName", firstName },
{ "Employee_LastName", lastName },
{ "Employee_IsSupervisor", isSupervisor },
{ "Employee_DepartmentId", departmentId }
});
// Assert
response.EnsureSuccessStatusCode();
IHtmlDocument indexPage = await HtmlHelpers.GetDocumentAsync(response);
var lastRow = indexPage.QuerySelector("tbody tr:last-child");
Assert.Contains(
lastRow.QuerySelectorAll("td"),
td => td.TextContent.Contains(firstName));
Assert.Contains(
lastRow.QuerySelectorAll("td"),
td => td.TextContent.Contains(lastName));
Assert.Contains(
lastRow.QuerySelectorAll("td"),
td => td.TextContent.Contains(departmentName));
IHtmlInputElement cb = (IHtmlInputElement)lastRow.QuerySelector("input[type='checkbox']");
if (isSupervisor == "true")
{
Assert.True(cb.IsChecked);
}
else
{
Assert.False(cb.IsChecked);
}
}
protected string ParseResponse2(string resp1)
{
Dictionary <string, object> dict = resp1.JsonDeserialize <Dictionary <string, object> >();
if (dict == null)
{
return(null);
}
object o2 = dict["content"];
var document = parser.Parse(o2 as string);
var all = document.All.Where(m => m.HasAttribute("value"));
var node = all.FirstOrDefault(x => x.Attributes["name"].Value == "t:formdata");
if (node == null)
{
return(null);
}
IHtmlInputElement e = node as IHtmlInputElement;
if (e == null)
{
return(null);
}
return(e.DefaultValue);
}
protected Tuple <string, string> ParseTokensFromLoginPage(string content)
{
var document = parser.Parse(content);
var all = document.All.Where(m => m.HasAttribute("value"));
var node = all.FirstOrDefault(x => x.Attributes["name"].Value == "t:formdata");
if (node == null)
{
return(null);
}
IHtmlInputElement e = node as IHtmlInputElement;
if (e == null)
{
return(null);
}
string t1 = e.DefaultValue;
var node2 = all.FirstOrDefault(x => x.Attributes["name"].Value == "loginTicket");
IHtmlInputElement e2 = node2 as IHtmlInputElement;
if (e2 == null)
{
return(null);
}
string t2 = e2.DefaultValue;
Tuple <string, string> res = new Tuple <string, string>(t1, t2);
return(res);
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
var request = inp.CreateRequestFor(url);
var document = inp.Owner;
if (document != null)
{
var loader = document.Loader;
if (loader != null)
{
var download = loader.DownloadAsync(request);
var task = inp.ProcessResource<IImageInfo>(download, result => _img = result);
document.DelayLoad(task);
}
}
}
}
/// <summary>
/// Creates an InputType provider for the provided element.
/// </summary>
/// <param name="input">The input element.</param>
/// <param name="type">The current value of the type attribute.</param>
/// <returns>The InputType provider instance.</returns>
public BaseInputType Create(IHtmlInputElement input, String type)
{
if (!String.IsNullOrEmpty(type) && _creators.TryGetValue(type, out var creator))
{
return(creator.Invoke(input));
}
return(CreateDefault(input, type));
}
public async Task Post_CreateAddsEmployee()
{
// Arrange
Department department = (await GetAllDepartments()).First();
string url = "/employee/create";
HttpResponseMessage createPageResponse = await _client.GetAsync(url);
IHtmlDocument createPage = await HtmlHelpers.GetDocumentAsync(createPageResponse);
string newFirstName = "FirstName-" + Guid.NewGuid().ToString();
string newLastName = "LastName-" + Guid.NewGuid().ToString();
string isSupervisor = "true";
string departmentId = department.Id.ToString();
string departmentName = department.Name;
// Act
HttpResponseMessage response = await _client.SendAsync(
createPage,
new Dictionary <string, string>
{
{ "Employee_FirstName", newFirstName },
{ "Employee_LastName", newLastName },
{ "Employee_IsSupervisor", isSupervisor },
{ "Employee_DepartmentId", departmentId }
});
// Assert
response.EnsureSuccessStatusCode();
IHtmlDocument indexPage = await HtmlHelpers.GetDocumentAsync(response);
var lastRow = indexPage.QuerySelector("tbody tr:last-child");
Assert.Contains(
lastRow.QuerySelectorAll("td"),
td => td.TextContent.Contains(newFirstName));
Assert.Contains(
lastRow.QuerySelectorAll("td"),
td => td.TextContent.Contains(newLastName));
Assert.Contains(
lastRow.QuerySelectorAll("td"),
td => td.TextContent.Contains(departmentName));
IHtmlInputElement cb = (IHtmlInputElement)lastRow.QuerySelector("input[type='checkbox']");
if (isSupervisor == "true")
{
Assert.True(cb.IsChecked);
}
else
{
Assert.False(cb.IsChecked);
}
}
/// <summary>
/// Creates an InputType provider for the provided element.
/// </summary>
/// <param name="input">The input element.</param>
/// <param name="type">The current value of the type attribute.</param>
/// <returns>The InputType provider or text, if the type is unknown.</returns>
public BaseInputType Create(IHtmlInputElement input, String type)
{
Func<IHtmlInputElement, BaseInputType> creator;
if (String.IsNullOrEmpty(type))
type = InputTypeNames.Text;
if (!creators.TryGetValue(type, out creator))
creator = creators[InputTypeNames.Text];
return creator(input);
}
public async Task Post_EditStudent()
{
// Arrange
string studentId = "1";
string url = $"/students/edit/{studentId}";
// fetch the edit page
HttpResponseMessage editPageResponse = await _client.GetAsync(url);
// convert the page into an HTML object so we can query it
IHtmlDocument editPage = await HtmlHelpers.GetDocumentAsync(editPageResponse);
// query the HTML object we converted
IHtmlInputElement firstNameInput = (IHtmlInputElement)editPage.QuerySelector("#student_FirstName");
IHtmlInputElement lastNameInput = (IHtmlInputElement)editPage.QuerySelector("#student_LastName");
IHtmlInputElement slackInput = (IHtmlInputElement)editPage.QuerySelector("#student_SlackHandle");
IHtmlSelectElement cohortSelect = (IHtmlSelectElement)editPage.QuerySelector("#student_CohortId");
// set firstName, lastName, slack, and cohortId to the values of the querySelectors
string firstName = firstNameInput.Value;
string lastName = lastNameInput.Value;
string slack = slackInput.Value;
string cohortId = cohortSelect.Value;
// Act
firstName = firstName + "!!!!";
HttpResponseMessage response = await _client.SendAsync(
editPage,
new Dictionary <string, string>
{
{ "student_FirstName", firstName },
{ "student_LastName", lastName },
{ "student_SlackHandle", slack },
{ "student_CohortId", cohortId }
});
// Assert
response.EnsureSuccessStatusCode();
IHtmlDocument indexPage = await HtmlHelpers.GetDocumentAsync(response);
Assert.Contains(
indexPage.QuerySelectorAll("td"),
td => td.TextContent.Contains(firstName));
//Assert.Contains(
// indexPage.QuerySelectorAll("td"),
// td => td.TextContent.Contains(lastName));
//Assert.Contains(
// indexPage.QuerySelectorAll("td"),
// td => td.TextContent.Contains(slack));
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
_cts = new CancellationTokenSource();
_imageTask = LoadAsync(inp, url, _cts.Token);
}
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
_request = new ImageRequestProcessor(inp.Context);
inp.Process(_request, url);
}
}
public async Task <MemeInfo> GenerateAsync(
string title,
string description,
byte[] image,
string imageFilename)
{
HttpClient hc;
string html;
try
{
hc = new HttpClient();
MultipartFormDataContent content = new MultipartFormDataContent();
content.Add(new StringContent(title), "tekst");
content.Add(new StringContent(description), "opis");
content.Add(new ByteArrayContent(image), "plik", imageFilename);
HttpResponseMessage response =
await hc.PostAsync(_uris[UriType.Page], content);
html = await response.Content.ReadAsStringAsync();
}
catch (WebException ex)
{
throw new ServiceOrConnectionException("Could not load page", ex);
}
IConfiguration config = Configuration.Default;
IBrowsingContext context = BrowsingContext.New(config);
IDocument document = await context.OpenAsync(req => req.Content(html));
IHtmlInputElement demotDiv = (IHtmlInputElement)document.DocumentElement
.QuerySelector("form > input[type=\"text\"][name=\"nazwa\"]");
if (demotDiv == null)
{
throw new NotFoundException("\"input\" tag could not be found");
}
MemeInfo meme = new MemeInfo
{
ViewURI = demotDiv.Value,
URI = demotDiv.Value,
Alt = title,
Name = title,
Type = MediaType.Image
};
return(meme);
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
var request = inp.CreateRequestFor(url);
_current = inp.Owner.LoadResource<IImageInfo>(request);
_current.ContinueWith(m => inp.FireLoadOrErrorEvent(m));
}
}
public void SetB(byte b, double selectorXPosition, double selectorYPosition)
{
var comp = ctx.RenderComponent <SimpleColorPickerTest>();
Console.WriteLine(comp.Markup);
IHtmlInputElement bInput = GetColorInput(comp, 2);
var expectedColor = comp.Instance.ColorValue.SetB(b);
bInput.Change(expectedColor.B.ToString());
CheckColorRelatedValues(comp, selectorXPosition, selectorYPosition, expectedColor, ColorPickerMode.RGB);
}
public void SetH(int h, double selectorXPosition, double selectorYPosition)
{
var comp = ctx.RenderComponent <SimpleColorPickerTest>(p => p.Add(x => x.ColorPickerMode, ColorPickerMode.HSL));
Console.WriteLine(comp.Markup);
IHtmlInputElement hInput = GetColorInput(comp, 0);
var expectedColor = comp.Instance.ColorValue.SetH(h);
hInput.Change(expectedColor.H.ToString());
CheckColorRelatedValues(comp, selectorXPosition, selectorYPosition, expectedColor, ColorPickerMode.HSL);
}
public void SetAlpha_AsHLS(double a, double selectorXPosition, double selectorYPosition)
{
var comp = ctx.RenderComponent <SimpleColorPickerTest>(p => p.Add(x => x.ColorPickerMode, ColorPickerMode.HSL));
Console.WriteLine(comp.Markup);
IHtmlInputElement lColor = GetColorInput(comp, 3);
var expectedColor = comp.Instance.ColorValue.SetAlpha(a);
lColor.Change(a.ToString(CultureInfo.InvariantCulture));
CheckColorRelatedValues(comp, selectorXPosition, selectorYPosition, expectedColor, ColorPickerMode.HSL);
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
var request = inp.CreateRequestFor(url);
inp.LoadResource <IImageInfo>(request).
ContinueWith(FinishLoading);
}
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
var request = inp.CreateRequestFor(url);
inp.LoadResource<IImageInfo>(request).
ContinueWith(FinishLoading);
}
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
_request = ImageRequestProcessor.Create(inp);
inp.Process(_request, url);
}
}
private async Task<string> GetCSRFToken(CancellationToken token)
{
RestRequest request = new RestRequest("tp/loot", Method.GET);
IRestResponse response = await restClient.ExecuteAsync(request, token);
if (token.IsCancellationRequested)
return default;
string content = response.Content;
IDocument document = await context.OpenAsync(x => x.Content(content), token);
if (token.IsCancellationRequested)
return default;
IHtmlInputElement inputElement = document.Body.QuerySelector<IHtmlInputElement>("input[name='csrf-key']");
return inputElement.Value;
}
public void SetColorInput_InvailidNoChange(string colorHexString)
{
var comp = ctx.RenderComponent <SimpleColorPickerTest>(p => p.Add(x => x.ColorPickerMode, ColorPickerMode.HEX));
Console.WriteLine(comp.Markup);
var inputs = comp.FindAll(".mud-picker-color-inputs input");
IHtmlInputElement hexInput = GetColorInput(comp, 0, 1);
var expectedColor = _defaultColor;
hexInput.Change(colorHexString);
CheckColorRelatedValues(comp, _defaultXForColorPanel, _defaultYForColorPanel, expectedColor, ColorPickerMode.HEX);
}
/// <summary>
/// Creates an InputType provider for the provided element.
/// </summary>
/// <param name="input">The input element.</param>
/// <param name="type">The current value of the type attribute.</param>
/// <returns>The InputType provider instance.</returns>
public BaseInputType Create(IHtmlInputElement input, String type)
{
var creator = default(Creator);
if (String.IsNullOrEmpty(type))
{
type = InputTypeNames.Text;
}
if (!creators.TryGetValue(type, out creator))
{
creator = creators[InputTypeNames.Text];
}
return(creator(input));
}
/// <summary>
/// Creates an InputType provider for the provided element.
/// </summary>
/// <param name="input">The input element.</param>
/// <param name="type">The current value of the type attribute.</param>
/// <returns>The InputType provider instance.</returns>
public BaseInputType Create(IHtmlInputElement input, String type)
{
var creator = default(Creator);
if (String.IsNullOrEmpty(type))
{
type = InputTypeNames.Text;
}
if (!creators.TryGetValue(type, out creator))
{
creator = creators[InputTypeNames.Text];
}
return creator(input);
}
public void SetColorInput(string colorHexString, double selectorXPosition, double selectorYPosition)
{
var comp = ctx.RenderComponent <SimpleColorPickerTest>(p => p.Add(x => x.ColorPickerMode, ColorPickerMode.HEX));
Console.WriteLine(comp.Markup);
var inputs = comp.FindAll(".mud-picker-color-inputs input");
IHtmlInputElement lColor = GetColorInput(comp, 0, 1);
var expectedColor = colorHexString;
lColor.Change(colorHexString);
CheckColorRelatedValues(comp, selectorXPosition, selectorYPosition, expectedColor, ColorPickerMode.HEX);
}
protected string ExtractCSRFToken(string result)
{
var doc = parser.Parse(result);
var node = doc.All.FirstOrDefault(x => x.Attributes != null && x.Attributes["name"] != null && x.Attributes["name"].Value == "csrf_token");
if (node == null)
{
return(null);
}
IHtmlInputElement e = node as IHtmlInputElement;
if (e == null)
{
return(null);
}
return(e.DefaultValue);
}
public ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
var request = inp.CreateRequestFor(url);
inp.LoadResource<IImageInfo>(request).ContinueWith(m =>
{
if (m.IsFaulted == false)
_img = m.Result;
inp.FireLoadOrErrorEvent(m);
});
}
}
public async Task Post_EditStudent()
{
// Arrange
string studentId = "1";
string url = $"/students/edit/{studentId}";
HttpResponseMessage editPageResponse = await _client.GetAsync(url);
IHtmlDocument editPage = await HtmlHelpers.GetDocumentAsync(editPageResponse);
IHtmlInputElement firstNameInput = (IHtmlInputElement)editPage.QuerySelector("#student_FirstName");
IHtmlInputElement lastNameInput = (IHtmlInputElement)editPage.QuerySelector("#student_LastName");
IHtmlInputElement slackInput = (IHtmlInputElement)editPage.QuerySelector("#student_SlackHandle");
IHtmlSelectElement cohortIdSelect = (IHtmlSelectElement)editPage.QuerySelector("#student_CohortId");
string firstName = firstNameInput.Value;
string lastName = lastNameInput.Value;
string slack = slackInput.Value;
string cohortId = cohortIdSelect.Value;
// Act
firstName = firstName + "!!!!";
HttpResponseMessage response = await _client.SendAsync(
editPage,
new Dictionary <string, string>
{
{ "student_FirstName", firstName },
{ "student_LastName", lastName },
{ "student_SlackHandle", slack },
{ "student_CohortId", cohortId }
});
// Assert
response.EnsureSuccessStatusCode();
IHtmlDocument indexPage = await HtmlHelpers.GetDocumentAsync(response);
Assert.Contains(
indexPage.QuerySelectorAll("td"),
td => td.TextContent.Contains(firstName));
}
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 ImageInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
var inp = input as HtmlInputElement;
var src = input.Source;
if (src != null && inp != null)
{
var url = inp.HyperReference(src);
var request = inp.CreateRequestFor(url);
inp.LoadResource <IImageInfo>(request).ContinueWith(m =>
{
if (m.IsFaulted == false)
{
_img = m.Result;
}
inp.FireLoadOrErrorEvent(m);
});
}
}
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);
}
public CheckedInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
}
public TextInputField(IHtmlInputElement element)
{
_getter = () => element.Value;
_setter = (value) => element.Value = value;
}
public BaseInputType(IHtmlInputElement input, String name, Boolean validate)
{
_input = input;
_validate = validate;
_name = name;
}
public FileInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
_files = new FileList();
}
public DatetimeLocalInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
}
public BinaryInputField(IHtmlInputElement element)
{
_element = element;
_isCheckbox = element.GetAttribute("type").ToLower() == "checkbox";
}
public ButtonInputType(IHtmlInputElement input, String name)
: base(input, name, validate: false)
{
}
public FileInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
_files = new FileList();
}
public override async Task <MemeInfo> RandomAsync()
{
WebClient wc;
string html;
try
{
wc = new WebClient();
html = await wc.DownloadStringTaskAsync(_uris[UriType.Random]);
}
catch (WebException ex)
{
throw new ServiceOrConnectionException("Could not load the page", ex);
}
IConfiguration config = Configuration.Default;
IBrowsingContext context = BrowsingContext.New(config);
IDocument document = await context.OpenAsync(req => req.Content(html).Address(_baseUrl));
IElement picDiv = document.DocumentElement
.QuerySelectorAll("#wrapper-wrap .left .ob-left-box-images")[RandomNthChild()];
IHtmlImageElement img = (IHtmlImageElement)picDiv
.QuerySelector(".left-wrap a img:last-child");
IHtmlAnchorElement a = (IHtmlAnchorElement)picDiv
.QuerySelector("h2 a");
IHtmlInputElement input = (IHtmlInputElement)picDiv
.QuerySelector(".left-wrap input[type=\"hidden\"]");
IHtmlSourceElement src = (IHtmlSourceElement)picDiv
.QuerySelector(".left-wrap video > source");
if ((src == null && img == null) || a == null)
{
throw new NotFoundException(
"Either \"img\", \"source\" or \"a\" tag could not be found");
}
MemeInfo meme;
if (src != null)
{
meme = new MemeInfo
{
ViewURI = a.Href,
URI = src.Source,
Alt = string.Empty,
Name = a.TextContent,
Type = MediaType.Video
};
}
else if (input != null)
{
meme = new MemeInfo
{
ViewURI = a.Href,
URI = input.Value,
Alt = img.AlternativeText,
Name = a.TextContent,
Type = MediaType.Gif
};
}
else
{
meme = new MemeInfo
{
ViewURI = a.Href,
URI = img.Source,
Alt = img.AlternativeText,
Name = a.TextContent,
Type = MediaType.Image
};
}
return(meme);
}
public BaseInputType(IHtmlInputElement input, String name, Boolean validate)
{
_input = input;
_validate = validate;
_name = name;
}
public PatternInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
}
public UrlInputType(IHtmlInputElement input, String name)
: base(input, name, validate: true)
{
}
public ButtonInputType(IHtmlInputElement input, String name)
: base(input, name, validate: false)
{
}
