public void Count(ElementProxy element, int count)
{
Parallel.ForEach(element.Elements, e =>
{
this.BuildAssertProvider(e.Item1).Count(new ElementProxy(e.Item1, e.Item2), count);
});
}
public void AppendText(ElementProxy element, string text)
{
this.RepackExceptions(() => Parallel.ForEach(element.Elements, e =>
{
e.Item1.AppendText(new ElementProxy(e.Item1, e.Item2), text);
}));
}
public void Visible(ElementProxy element, Action <bool> action)
{
this.Act(CommandType.Action, () =>
{
var el = (element.Element as Element).AutomationElement;
var isVisible = false;
try
{
isVisible = bool.Parse(this.ActiveDomContainer.Eval(string.Format("jQuery({0}).is(':visible');", el.GetJavascriptElementReference())));
}
catch (JavaScriptException) { }
action(isVisible);
});
}
public ElementProxy FindMultiple(string selector)
{
var result = new ElementProxy();
this.RepackExceptions(() => Parallel.ForEach(this.commandProviders, x =>
{
foreach (var element in x.FindMultiple(selector).Elements)
{
result.Elements.Add(new Tuple <ICommandProvider, Func <IElement> >(x, element.Item2));
}
}));
return(result);
}
public void DragAndDrop(ElementProxy source, int sourceOffsetX, int sourceOffsetY, ElementProxy target, int targetOffsetX, int targetOffsetY)
{
this.Act(CommandType.Action, () =>
{
var element = source.Element as Element;
var targetElement = target.Element as Element;
new Actions(this._webDriver)
.MoveToElement(element.WebElement, sourceOffsetX, sourceOffsetY)
.ClickAndHold()
.MoveToElement(targetElement.WebElement, targetOffsetX, targetOffsetY)
.Release()
.Perform();
});
}
public void SelectIndex(ElementProxy element, int optionIndex)
{
this.Act(CommandType.Action, () =>
{
var unwrappedElement = element.Element as Element;
SelectElement selectElement = new SelectElement(unwrappedElement.WebElement);
if (selectElement.IsMultiple)
{
selectElement.DeselectAll();
}
selectElement.SelectByIndex(optionIndex);
});
}
public IActionSyntaxProvider To(ElementProxy targetElement, int targetOffsetX, int targetOffsetY)
{
// Before
_logger.LogPartialMessage(" to: " + targetElement.Element.Selector + " with offset x: " + targetOffsetX + " y: " + targetOffsetY, true);
// Execute
if (!IsInDryRunMode)
{
_dragDropSyntaxProvider.To(targetElement, targetOffsetX, targetOffsetY);
}
// After
return(_actionSyntaxProvider);
}
public IAssertSyntaxProvider In(ElementProxy element)
{
// Before
_logger.LogPartialMessage("in element with selector: " + element.Element.Selector, true);
// Execute
if (!IsInDryRunMode)
{
_assertValueSyntaxProvider.In(element);
}
// After
return(_assertSyntaxProvider);
}
public IActionSyntaxProvider Upload(ElementProxy element, int x, int y, string fileName)
{
// Before
_logger.LogMessage("Upload file :" + fileName + " into element with selector: " + element.Element.Selector + " position x: " + x + "y: " + y);
// Execute
if (!IsInDryRunMode)
{
_actionSyntaxProvider.Upload(element, x, y, fileName);
}
// After
return(this);
}
public IActionSyntaxProvider To(ElementProxy targetElement)
{
// Before
_logger.LogPartialMessage(" to: " + targetElement.Element.Selector, true);
// Execute
if (!IsInDryRunMode)
{
_dragDropSyntaxProvider.To(targetElement);
}
// After
return(_actionSyntaxProvider);
}
public IActionSyntaxProvider Scroll(ElementProxy element)
{
// Before
_logger.LogMessage("Scroll to element with selector: " + element.Element.Selector);
// Execute
if (!IsInDryRunMode)
{
_actionSyntaxProvider.Scroll(element);
}
// After
return(this);
}
public IActionSyntaxProvider RightClick(ElementProxy element)
{
// Before
_logger.LogMessage("Rightclick element with selector: " + element.Element.Selector);
// Execute
if (!IsInDryRunMode)
{
_actionSyntaxProvider.RightClick(element);
}
// After
return(this);
}
public IActionSyntaxProvider Hover(ElementProxy element, int x, int y)
{
// Before
_logger.LogMessage("Hover over element with selector: " + element.Element.Selector + " position x: " + x + "y: " + y);
// Execute
if (!IsInDryRunMode)
{
_actionSyntaxProvider.Hover(element, x, y);
}
// After
return(this);
}
public IAssertSyntaxProvider On(ElementProxy elements)
{
// Before
_logger.LogPartialMessage(" on element with selector: " + elements.Element.Selector, true);
// Execute
if (!IsInDryRunMode)
{
_assertCssPropertySyntaxProvider.On(elements);
}
// After
return(_assertSyntaxProvider);
}
public IAssertSyntaxProvider Visible(ElementProxy element)
{
// Before
_logger.LogPartialMessage("element with selector: " + element.Element.Selector + " to be visible", true);
// Execute
if (!IsInDryRunMode)
{
_assertSyntaxProvider.Visible(element);
}
// After
return(this);
}
public void SelectValue(ElementProxy element, string optionValue)
{
this.Act(CommandType.Action, () =>
{
var unwrappedElement = element.Element as Element;
SelectElement selectElement = new SelectElement(unwrappedElement.WebElement);
if (selectElement.IsMultiple)
{
selectElement.DeselectAll();
}
selectElement.SelectByValue(optionValue);
});
}
private ElementHasTextResult elementHasText(ElementProxy element, Func <string, bool> textMatcher)
{
var hasText = false;
var unwrappedElement = element.Element;
var actualText = unwrappedElement.Text;
if (unwrappedElement.IsSelect)
{
foreach (var optionText in unwrappedElement.SelectedOptionTextCollection)
{
if (textMatcher(optionText))
{
hasText = true;
break;
}
}
actualText = string.Join(", ", unwrappedElement.SelectedOptionTextCollection.Select(x => x).ToArray());
}
else
{
if (textMatcher(unwrappedElement.Text))
{
hasText = true;
}
}
var elementType = "DOM Element";
if (unwrappedElement.IsText)
{
elementType = "TextElement";
}
else if (unwrappedElement.IsMultipleSelect)
{
elementType = "MultipleSelectElement";
}
else if (unwrappedElement.IsSelect)
{
elementType = "SelectElement";
}
return(new ElementHasTextResult
{
HasText = hasText,
ActualText = actualText,
ElementType = elementType,
Selector = element.Element.Selector
});
}
public void CssPropertyValue(ElementProxy element, string propertyName, Action <bool, string> action)
{
this.Act(CommandType.Action, () =>
{
var propertyValue = ((IJavaScriptExecutor)this._webDriver).ExecuteScript(string.Format("return fluentjQuery(\"{0}\").css(\"{1}\")", element.Element.Selector, propertyName));
if (propertyValue == null)
{
action(false, string.Empty);
}
else
{
action(true, propertyValue.ToString());
}
});
}
public void CssPropertyValue(ElementProxy element, string propertyName, Action <bool, string> action)
{
this.Act(CommandType.Action, () =>
{
var el = (element.Element as Element).AutomationElement;
object cssPropertyValue = null;
try
{
cssPropertyValue = bool.Parse(this.ActiveDomContainer.Eval(string.Format("jQuery({0}).css('{1}');", el.GetJavascriptElementReference(), propertyName)));
}
catch (JavaScriptException) { }
action(cssPropertyValue != null, cssPropertyValue.ToString());
});
}
public void NotAttribute(ElementProxy element, string attributeName, string attributeValue)
{
this.commandProvider.Act(commandType, () =>
{
var result = element.Element.Attributes.Get(attributeName);
if (attributeValue == null && result != null)
{
this.ReportError("Expected element [{0}] not to have attribute [{1}] but it did.", element.Element.Selector, attributeName);
}
else if (result != null && IsTextMatch(result, attributeValue))
{
this.ReportError("Expected element [{0}]'s attribute [{1}] not to have a value of [{2}] but it did.", element.Element.Selector, attributeName, attributeValue);
}
});
}
public void NotCssProperty(ElementProxy element, string propertyName, string propertyValue)
{
this.commandProvider.Act(commandType, () =>
{
var result = this.elementHasCssProperty(element, propertyName, propertyValue);
if (propertyValue == null && result.HasProperty)
{
this.ReportError("Expected element [{0}] not to have CSS property [{1}] but it did.", element.Element.Selector, propertyName);
}
else if (result.PropertyMatches)
{
this.ReportError("Expected element [{0}]'s CSS property [{1}] not to have a value of [{2}] but it did.", element.Element.Selector, propertyName, propertyValue);
}
});
}
public void DragAndDrop(ElementProxy source, int sourceOffsetX, int sourceOffsetY, ElementProxy target, int targetOffsetX, int targetOffsetY)
{
var sourceEl = source.Element as Element;
var targetEl = target.Element as Element;
var sourceX = sourceEl.PosX + sourceOffsetX;
var sourceY = sourceEl.PosY + sourceOffsetY;
var targetX = targetEl.PosX + targetOffsetX;
var targetY = targetEl.PosY + targetOffsetY;
MouseControl.SetPosition(sourceX, sourceY);
MouseControl.MouseEvent(MouseControl.MouseEvent_LeftButtonDown, sourceX, sourceY, 0, 0);
MouseControl.SetPosition(targetX, targetY);
MouseControl.MouseEvent(MouseControl.MouseEvent_LeftButtonUp, targetX, targetY, 0, 0);
}
public void MultiSelectIndex(ElementProxy element, int[] optionIndices)
{
this.Act(CommandType.Action, () =>
{
var el = element.Element as Element;
if (el.IsSelect && el.IsMultipleSelect)
{
var sl = new WatiNCore.SelectList(this.ActiveDomContainer, el.AutomationElement.NativeElement);
foreach (var i in optionIndices)
{
sl.Options[i].Select();
fireOnChange(el.AutomationElement);
}
}
});
}
public IActionSyntaxProvider From(ElementProxy element)
{
// Before
string selector = (element != null && element.Element != null) ? element.Element.Selector ?? "?" : "?";
_logger.LogMessage("Perform selection in element with selector: {0}", selector);
// Execute
if (!IsInDryRunMode)
{
_selectSyntaxProvider.From(element);
}
// After
return(_actionSyntaxProvider);
}
private int CountElementsInProxy(ElementProxy elements)
{
int count = 0;
foreach (var element in elements.Elements)
{
try
{
element.Item2();
count++;
}
catch (Exception) { }
}
return(count);
}
public IActionSyntaxProvider To(ElementProxy element)
{
// Before
string selector = (element != null && element.Element != null) ? element.Element.Selector ?? "?" : "?";
_logger.LogMessage("Append text to text in element with selector: {0}", selector);
// Execute
if (!IsInDryRunMode)
{
_textAppendSyntaxProvider.To(element);
}
// After
return(_actionSyntaxProvider);
}
public void MultiSelectText(ElementProxy element, string[] optionTextCollection)
{
this.Act(CommandType.Action, () =>
{
var el = element.Element as Element;
if (el.IsSelect && el.IsMultipleSelect)
{
var sl = new WatiNCore.SelectList(this.ActiveDomContainer, el.AutomationElement.NativeElement);
foreach (var text in optionTextCollection)
{
sl.Select(text);
fireOnChange(el.AutomationElement);
}
}
});
}
private ElementHasValueResult elementHasValue(ElementProxy element, Func <string, bool> valueMatcher)
{
var hasValue = false;
var unwrappedElement = element.Element;
if (unwrappedElement.IsMultipleSelect)
{
foreach (var optionValue in unwrappedElement.SelectedOptionValues)
{
if (valueMatcher(optionValue))
{
hasValue = true;
break;
}
}
}
else
{
if (valueMatcher(unwrappedElement.Value))
{
hasValue = true;
}
}
var elementType = "DOM Element";
if (unwrappedElement.IsText)
{
elementType = "TextElement";
}
else if (unwrappedElement.IsMultipleSelect)
{
elementType = "MultipleSelectElement";
}
else if (unwrappedElement.IsSelect)
{
elementType = "SelectElement";
}
return(new ElementHasValueResult
{
HasValue = hasValue,
ElementType = elementType,
ActualValue = unwrappedElement.Value,
Selector = element.Element.Selector
});
}
public void MultiSelectValue(ElementProxy element, string[] optionValues)
{
this.Act(CommandType.Action, () =>
{
var el = element.Element as Element;
if (el.IsSelect && el.IsMultipleSelect)
{
new WatiNCore.SelectList(this.browser.Frame("").DomContainer, el.AutomationElement.NativeElement);
var sl = new WatiNCore.SelectList(this.ActiveDomContainer, el.AutomationElement.NativeElement);
foreach (var val in optionValues)
{
sl.SelectByValue(val);
fireOnChange(el.AutomationElement);
}
}
});
}
public void MultiSelectIndex(ElementProxy element, int[] optionIndices)
{
this.Act(CommandType.Action, () =>
{
var unwrappedElement = element.Element as Element;
SelectElement selectElement = new SelectElement(unwrappedElement.WebElement);
if (selectElement.IsMultiple)
{
selectElement.DeselectAll();
}
foreach (var optionIndex in optionIndices)
{
selectElement.SelectByIndex(optionIndex);
}
});
}
/// <summary>
/// Enter text into specified <paramref name="element"/>.
/// </summary>
/// <param name="element">IElement factory function.</param>
public IActionSyntaxProvider To(ElementProxy element)
{
if (!element.Element.IsText)
{
throw new FluentException("Append().To() is only supported on text elements (input, textarea, etc).");
}
if (this.eventsEnabled)
{
this.syntaxProvider.commandProvider.AppendText(element, text);
}
else
{
this.syntaxProvider.commandProvider.AppendTextWithoutEvents(element, text);
}
return(this.syntaxProvider);
}
public void MultiSelectText(ElementProxy element, string[] optionTextCollection)
{
this.Act(CommandType.Action, () =>
{
var unwrappedElement = element.Element as Element;
SelectElement selectElement = new SelectElement(unwrappedElement.WebElement);
if (selectElement.IsMultiple)
{
selectElement.DeselectAll();
}
foreach (var optionText in optionTextCollection)
{
selectElement.SelectByText(optionText);
}
});
}
/// <summary>
/// Specified <paramref name="element"/> that should have matching CSS class.
/// </summary>
/// <param name="element">IElement factory function.</param>
public AssertSyntaxProvider On(ElementProxy element)
{
if (this.notMode)
this.assertProvider.NotAttribute(element, this.attributeName, this.attributeValue);
else
this.assertProvider.Attribute(element, this.attributeName, this.attributeValue);
return this.assertSyntaxProvider;
}
public void CssClass(ElementProxy element, string className)
{
Parallel.ForEach(element.Elements, e =>
{
this.BuildAssertProvider(e.Item1).CssClass(new ElementProxy(e.Item1, e.Item2), className);
});
}
/// <summary>
/// End Drag/Drop operation at specified <paramref name="targetElement"/>.
/// </summary>
/// <param name="targetElement">IElement factory function.</param>
/// <param name="targetOffsetX">X-offset for drop.</param>
/// <param name="targetOffsetY">Y-offset for drop.</param>
public IActionSyntaxProvider To(ElementProxy targetElement, int targetOffsetX, int targetOffsetY)
{
this.syntaxProvider.commandProvider.DragAndDrop(this.sourceElement, offsetX, offsetY, targetElement, targetOffsetX, targetOffsetY);
return this.syntaxProvider;
}
public IActionSyntaxProvider RightClick(ElementProxy element)
{
this.commandProvider.RightClick(element);
return this;
}
public IActionSyntaxProvider Upload(ElementProxy element, string fileName)
{
return this.Upload(element, 0, 0, fileName);
}
/// <summary>
/// Assert the element specified does not exist.
/// </summary>
/// <param name="selector">Element reference.</param>
public AssertSyntaxProvider Exists(ElementProxy element)
{
this.assertProvider.NotExists(element);
return this.assertSyntaxProvider;
}
/// <summary>
/// Specified <paramref name="element"/> that should have matching CSS class.
/// </summary>
/// <param name="element">IElement factory function.</param>
public AssertSyntaxProvider On(ElementProxy element)
{
if (this.notMode)
this.assertProvider.NotCssProperty(element, this.propertyName, this.propertyValue);
else
this.assertProvider.CssProperty(element, this.propertyName, this.propertyValue);
return this.assertSyntaxProvider;
}
public void Text(ElementProxy element, string text)
{
Parallel.ForEach(element.Elements, e =>
{
this.BuildAssertProvider(e.Item1).Text(new ElementProxy(e.Item1, e.Item2), text);
});
}
public void NotExists(ElementProxy element)
{
Parallel.ForEach(this.providers, x => this.BuildAssertProvider(x.Key).NotExists(element));
}
public void NotCssProperty(ElementProxy element, string propertyName, string propertyValue)
{
Parallel.ForEach(this.providers, x => this.BuildAssertProvider(x.Key).NotCssProperty(element, propertyName, propertyValue));
}
/// <summary>
/// Enter text into specified <paramref name="element"/>.
/// </summary>
/// <param name="element">IElement factory function.</param>
public IActionSyntaxProvider In(ElementProxy element)
{
if (!element.Element.IsText)
throw new FluentException("Enter().In() is only supported on text elements (input, textarea, etc).");
if (this.eventsEnabled)
{
this.syntaxProvider.commandProvider.EnterText(element, text);
}
else
{
this.syntaxProvider.commandProvider.EnterTextWithoutEvents(element, text);
}
return this.syntaxProvider;
}
/// <summary>
/// Switch focus to a previously selected frame/iframe
/// </summary>
/// <param name="frameElement"></param>
/// <returns></returns>
public IActionSyntaxProvider Frame(ElementProxy frameElement)
{
this.syntaxProvider.commandProvider.SwitchToFrame(frameElement);
return this.syntaxProvider;
}
/// <summary>
/// Select from specified <paramref name="element"/>.
/// </summary>
/// <param name="element">IElement factory function.</param>
public IActionSyntaxProvider From(ElementProxy element)
{
if (this.mode == SelectionOption.Value)
{
if (this.value is string)
{
this.syntaxProvider.commandProvider.SelectValue(element, this.value);
}
else if (this.value is string[])
{
this.syntaxProvider.commandProvider.MultiSelectValue(element, this.value);
}
}
else if (this.mode == SelectionOption.Text)
{
if (this.value is string)
{
this.syntaxProvider.commandProvider.SelectText(element, this.value);
}
else if (this.value is string[])
{
this.syntaxProvider.commandProvider.MultiSelectText(element, this.value);
}
}
else if (this.value is int)
{
this.syntaxProvider.commandProvider.SelectIndex(element, this.value);
}
else if (this.value is int[])
{
this.syntaxProvider.commandProvider.MultiSelectIndex(element, this.value);
}
return this.syntaxProvider;
}
/// <summary>
/// Specified <paramref name="element"/> that should have matching CSS class.
/// </summary>
/// <param name="element">IElement factory function.</param>
public AssertSyntaxProvider On(ElementProxy element)
{
if (this.notMode)
this.assertProvider.NotCssClass(element, this.className);
else
this.assertProvider.CssClass(element, this.className);
return this.assertSyntaxProvider;
}
/// <summary>
/// Specified <paramref name="elements"/> to be counted.
/// </summary>
/// <param name="elements">IElement collection factory function.</param>
public AssertSyntaxProvider Of(ElementProxy elements)
{
if (this.notMode)
this.assertProvider.NotCount(elements, count);
else
this.assertProvider.Count(elements, this.count);
return this.assertSyntaxProvider;
}
public void Value(ElementProxy element, string value)
{
Parallel.ForEach(element.Elements, e =>
{
this.BuildAssertProvider(e.Item1).Value(new ElementProxy(e.Item1, e.Item2), value);
});
}
/// <summary>
/// Specified <paramref name="element"/> that should have a matching Value.
/// </summary>
/// <param name="element"></param>
public AssertSyntaxProvider In(ElementProxy element)
{
if (!string.IsNullOrEmpty(this.value))
{
if (this.notMode)
this.assertProvider.NotValue(element, this.value);
else
this.assertProvider.Value(element, this.value);
}
else if (this.matchFunc != null)
{
if (this.notMode)
this.assertProvider.NotValue(element, this.matchFunc);
else
this.assertProvider.Value(element, this.matchFunc);
}
return this.assertSyntaxProvider;
}
public void Value(ElementProxy element, System.Linq.Expressions.Expression<Func<string, bool>> matchFunc)
{
Parallel.ForEach(element.Elements, e =>
{
this.BuildAssertProvider(e.Item1).Value(new ElementProxy(e.Item1, e.Item2), matchFunc);
});
}
/// <summary>
/// Assert that the element is not visible and cannot be interacted with.
/// </summary>
/// <param name="selector"></param>
public AssertSyntaxProvider Visible(ElementProxy element)
{
this.assertProvider.NotVisible(element);
return this.assertSyntaxProvider;
}
internal DragDropSyntaxProvider(ActionSyntaxProvider syntaxProvider, ElementProxy element)
{
this.syntaxProvider = syntaxProvider;
this.sourceElement = element;
}
public IActionSyntaxProvider Scroll(ElementProxy element)
{
this.commandProvider.Hover(element);
return this;
}
/// <summary>
/// End Drag/Drop operation at specified <paramref name="targetElement"/>.
/// </summary>
/// <param name="targetElement">IElement factory function.</param>
/// <param name="targetOffsetX">X-offset for drop.</param>
/// <param name="targetOffsetY">Y-offset for drop.</param>
public void To(ElementProxy targetElement, int targetOffsetX, int targetOffsetY)
{
this.syntaxProvider.commandProvider.DragAndDrop(this.syntaxProvider.commandProvider.Find("html"), this.sourceX, this.sourceY, targetElement, targetOffsetX, targetOffsetY);
}
public void Visible(ElementProxy element)
{
Parallel.ForEach(this.providers, x => this.BuildAssertProvider(x.Key).Visible(element));
}
internal DragDropSyntaxProvider(ActionSyntaxProvider syntaxProvider, ElementProxy element, int offsetX, int offsetY)
{
this.syntaxProvider = syntaxProvider;
this.sourceElement = element;
this.offsetX = offsetX;
this.offsetY = offsetY;
}
public void Attribute(ElementProxy element, string attributeName, string attributeValue)
{
Parallel.ForEach(this.providers, x => this.BuildAssertProvider(x.Key).Attribute(element, attributeName, attributeValue));
}
public IActionSyntaxProvider Upload(ElementProxy element, int x, int y, string fileName)
{
this.commandProvider.UploadFile(element, x, y, fileName);
return this;
}
/// <summary>
/// End Drag/Drop operation at specified <paramref name="targetElement"/>.
/// </summary>
/// <param name="targetElement">IElement factory function.</param>
public IActionSyntaxProvider To(ElementProxy targetElement)
{
if (this.offsetX != 0 || this.offsetY != 0)
{
this.syntaxProvider.commandProvider.DragAndDrop(this.sourceElement, offsetX, offsetY, targetElement, 0, 0);
}
else
{
this.syntaxProvider.commandProvider.DragAndDrop(this.sourceElement, targetElement);
}
return this.syntaxProvider;
}
/// <summary>
/// End Drag/Drop operation at specified <paramref name="targetElement"/>.
/// </summary>
/// <param name="targetElement">IElement factory function.</param>
public void To(ElementProxy targetElement)
{
this.syntaxProvider.commandProvider.DragAndDrop(this.syntaxProvider.commandProvider.Find("html"), this.sourceX, this.sourceY, targetElement, 0, 0);
}
