public void It_checks_all_of_the_states_in_a_robust_query_expecting_true()
{
bool queriedState1 = false;
bool queriedState2 = false;
var state1 = new State(new LambdaQuery<bool>(() =>
{
queriedState1 = true;
return false;
}));
var state2 = new State(new LambdaQuery<bool>(() =>
{
queriedState2 = true;
return true;
}));
var state3 = new State(new LambdaQuery<bool>(() => true));
state3.CheckCondition();
var robustWrapper = new SpyTimingStrategy();
robustWrapper.StubQueryResult(true, true);
var session = BuildSession(robustWrapper);
Assert.That(session.FindState(new [] {state1, state2, state3}), Is.SameAs(state3));
Assert.IsFalse(queriedState1);
Assert.IsFalse(queriedState2);
var query = robustWrapper.QueriesRan<bool>().Single();
var queryResult = query.Run();
Assert.IsTrue(queryResult);
Assert.IsTrue(queriedState1);
Assert.IsTrue(queriedState2);
}
public void RetryUntilTimeout_is_exposed_on_the_session()
{
var calledOnWrapper = false;
browserSession.RetryUntilTimeout(() =>
{
calledOnWrapper = true;
});
SpyTimingStrategy.QueriesRan <object>().First().Run();
Assert.That(calledOnWrapper, Is.True);
}
protected void Queries_robustly_reversing_result <T>(bool stubResult, Func <T, Options, bool> subject, Action <T, bool, DriverScope> stub, T locator)
{
stub(locator, stubResult, browserSession);
SpyTimingStrategy.StubQueryResult(true, !stubResult);
var actualImmediateResult = subject(locator, sessionConfiguration);
Assert.That(actualImmediateResult, Is.EqualTo(!stubResult), "Result was not found robustly");
var queryResult = RunQueryAndCheckTiming <bool>();
Assert.That(queryResult, Is.EqualTo(!stubResult));
}
public void Query_is_exposed_on_the_session()
{
Func <string> query = () => "query result";
SpyTimingStrategy.StubQueryResult("expected query result", "immediate query result");
Assert.That(browserSession.Query(query, "expected query result"), Is.EqualTo("immediate query result"));
var robustQuery = SpyTimingStrategy.QueriesRan <string>().First();
var queryResult = robustQuery.Run();
Assert.That(queryResult, Is.EqualTo("query result"));
}
public void Return_from_RetryUntilTimeout_is_exposed_on_the_session()
{
Func <string> function = () => "The expected result";
SpyTimingStrategy.StubQueryResult(SpyTimingStrategy.NO_EXPECTED_RESULT, "immediate result");
Assert.That(browserSession.RetryUntilTimeout(function), Is.EqualTo("immediate result"));
var query = SpyTimingStrategy.QueriesRan <string>().First();
var queryResult = query.Run();
Assert.That(queryResult, Is.EqualTo("The expected result"));
}
public void SetUp()
{
driver = new FakeDriver();
SpyTimingStrategy = new SpyTimingStrategy();
fakeWaiter = new FakeWaiter();
stubUrlBuilder = new StubUrlBuilder();
sessionConfiguration = new SessionConfiguration();
browserSession = TestSessionBuilder.Build(sessionConfiguration, driver, SpyTimingStrategy, fakeWaiter, new SpyRestrictedResourceDownloader(),
stubUrlBuilder);
elementScope = browserSession.FindXPath(".");
popupScope = browserSession.FindWindow("popup");
}
public void It_makes_robust_call_to_find_then_hover_element_on_underlying_driver()
{
var element = new StubElement();
driver.StubId("something_to_hover", element, browserSession, sessionConfiguration);
SpyTimingStrategy.AlwaysReturnFromSynchronise(element);
browserSession.FindId("something_to_hover").Hover();
Assert.That(driver.HoveredElements, Has.No.Member(element));
RunQueryAndCheckTiming();
Assert.That(driver.HoveredElements, Has.Member(element));
}
public void It_makes_robust_call_to_find_then_clicks_element_on_underlying_driver()
{
var element = new StubElement();
driver.StubId("something_to_click", element, browserSession, sessionConfiguration);
SpyTimingStrategy.AlwaysReturnFromSynchronise(element);
var toCheck = browserSession.FindCss("something_to_click");
toCheck.Uncheck();
Assert.That(driver.UncheckedElements, Has.No.Member(toCheck), "Uncheck was not synchronised");
RunQueryAndCheckTiming();
Assert.That(driver.UncheckedElements, Has.Member(toCheck));
}
public void It_sends_keys_to_element_via_underlying_driver()
{
var element = new StubElement();
driver.StubId("something", element, browserSession, sessionConfiguration);
SpyTimingStrategy.AlwaysReturnFromRobustly(element);
browserSession.FindId("something")
.SendKeys("some keys to press");
Assert.That(driver.SentKeys.Count, Is.EqualTo(0));
RunQueryAndCheckTiming();
Assert.That(driver.SentKeys.Count, Is.EqualTo(1));
Assert.That(driver.SentKeys[element], Is.EqualTo("some keys to press"));
}
public void It_finds_then_synchronises_click_element_on_underlying_driver()
{
var element = new StubElement();
driver.StubId("something_to_click", element, browserSession, sessionConfiguration);
SpyTimingStrategy.AlwaysReturnFromSynchronise(element);
var elementScope = browserSession.FindId("something_to_click");
elementScope.Click();
Assert.That(driver.ClickedElements, Has.No.Member(elementScope), "Click was not synchronised");
RunQueryAndCheckTiming();
Assert.That(driver.ClickedElements, Has.Member(elementScope));
}
public void It_makes_robust_call_to_find_then_clicks_element_on_underlying_driver()
{
var element = new StubElement();
driver.StubId("something_to_fill_in", element, browserSession, sessionConfiguration);
SpyTimingStrategy.AlwaysReturnFromSynchronise(element);
var elementScope = browserSession.FindId("something_to_fill_in");
elementScope.FillInWith("some filled in stuff");
Assert.That(driver.SetFields.Keys, Has.No.Member(elementScope));
RunQueryAndCheckTiming();
Assert.That(driver.SetFields.Keys, Has.Member(elementScope));
Assert.That(driver.SetFields[elementScope].Value, Is.EqualTo("some filled in stuff"));
}
protected void Queries_robustly <T>(bool stubResult, Func <T, Options, bool> subject, Action <T, bool, DriverScope> stub, T locator)
{
stub(locator, stubResult, browserSession);
SpyTimingStrategy.StubQueryResult(true, !stubResult);
var individualTimeout = TimeSpan.FromMilliseconds(DateTime.UtcNow.Millisecond);
var options = new SessionConfiguration {
Timeout = individualTimeout
};
var actualImmediateResult = subject(locator, options);
Assert.That(actualImmediateResult, Is.EqualTo(!stubResult), "Result was not found robustly");
var queryResult = RunQueryAndCheckTiming <bool>(individualTimeout);
Assert.That(queryResult, Is.EqualTo(stubResult));
}
protected void Should_test_predicate_against_query_results_and_retry_on_failure(Func <string, Func <IEnumerable <SnapshotElementScope>, bool>, Options, IEnumerable <SnapshotElementScope> > subject, Action <string, IEnumerable <ElementFound>, Scope, Options> stub)
{
var locator = "Find me " + DateTime.Now.Ticks;
var individualTimeout = TimeSpan.FromMilliseconds(DateTime.UtcNow.Millisecond);
var expectedImmediateResult = new[] { new StubElement(), new StubElement() };
var expectedDeferredResult = new[] { new StubElement(), new StubElement() };
var options = new Options {
Timeout = individualTimeout
};
SpyTimingStrategy.AlwaysReturnFromRobustly(expectedImmediateResult.Select(e => new SnapshotElementScope(e, browserSession, options)));
stub(locator, expectedDeferredResult, browserSession, options);
VerifyFoundRobustly(subject, 0, locator, (elements) => true, expectedDeferredResult, expectedImmediateResult, options);
VerifyFoundRobustlyAndThrows <MissingHtmlException>(subject, 1, locator, (elements) => false, null, expectedImmediateResult, options);
VerifyFoundRobustlyAndThrows <TestException>(subject, 2, locator, (elements) => { throw new TestException("Thrown in FindAll predicate"); }, null, expectedImmediateResult, options);
}
public void When_query_returns_false_It_raises_an_exception()
{
var state1 = new State(new AlwaysSucceedsQuery <bool>(false, true, TimeSpan.Zero, SessionConfiguration.RetryInterval));
var state2 = new State(new AlwaysSucceedsQuery <bool>(false, true, TimeSpan.Zero, SessionConfiguration.RetryInterval));
var robustWrapper = new SpyTimingStrategy();
robustWrapper.StubQueryResult(true, false);
var session = BuildSession(robustWrapper);
try
{
session.FindState(state1, state2);
Assert.Fail("Expected MissingHTMLException");
}
catch (MissingHtmlException e)
{
Assert.That(e.Message, Is.EqualTo("None of the given states was reached within the configured timeout."));
}
}
public void It_checks_for_missing_elements_with_synchronise()
{
browserSession = TestSessionBuilder.Build(new SessionConfiguration(), driver, SpyTimingStrategy, null, null, null,
new ThrowsWhenMissingButNoDisambiguationStrategy());
SpyTimingStrategy.StubQueryResult(true, false);
driver.StubId("Signout", new StubElement(), browserSession, sessionConfiguration);
browserSession.FindId("Signin").Missing();
browserSession.FindId("Signout").Missing();
var firstQuery = SpyTimingStrategy.QueriesRan <bool>().ElementAt(0);
var secondQuery = SpyTimingStrategy.QueriesRan <bool>().ElementAt(1);
var firstQueryResult = RunQueryAndCheckTiming(firstQuery);
Assert.That(firstQueryResult, Is.True);
var secondQueryResult = RunQueryAndCheckTiming(secondQuery);
Assert.That(secondQueryResult, Is.False);
}
private void Check_robust_content_query <T>(bool stubResult, string actualContent, Func <T, Options, bool> subject, T toLookFor)
{
var window = new StubElement {
Text = actualContent
};
driver.StubCurrentWindow(window);
SpyTimingStrategy.StubQueryResult(true, !stubResult);
var individualTimeout = TimeSpan.FromMilliseconds(DateTime.UtcNow.Millisecond);
var options = new SessionConfiguration {
Timeout = individualTimeout
};
var actualImmediateResult = subject(toLookFor, options);
Assert.That(actualImmediateResult, Is.EqualTo(!stubResult), "Result was not found robustly");
var queryResult = RunQueryAndCheckTiming <bool>(individualTimeout);
Assert.That(queryResult, Is.EqualTo(stubResult));
}
public void It_checks_all_of_the_states_in_a_robust_query_expecting_true()
{
bool queriedState1 = false;
bool queriedState2 = false;
var state1 = new State(new LambdaQuery <bool>(() =>
{
queriedState1 = true;
return(false);
}));
var state2 = new State(new LambdaQuery <bool>(() =>
{
queriedState2 = true;
return(true);
}));
var state3 = new State(new LambdaQuery <bool>(() => true));
state3.CheckCondition();
var robustWrapper = new SpyTimingStrategy();
robustWrapper.StubQueryResult(true, true);
var session = BuildSession(robustWrapper);
Assert.That(session.FindState(new [] { state1, state2, state3 }), Is.SameAs(state3));
Assert.IsFalse(queriedState1);
Assert.IsFalse(queriedState2);
var query = robustWrapper.QueriesRan <bool>().Single();
var queryResult = query.Run();
Assert.IsTrue(queryResult);
Assert.IsTrue(queriedState1);
Assert.IsTrue(queriedState2);
}
private void Finds_element_robustly_and_returns_property_value <T>(T testValue, Action <StubElement, T> stubProperty, Func <ElementScope, T> getProperty, Func <object, Constraint> constraint = null)
{
constraint = constraint ?? Is.SameAs;
var stubElement = new StubElement();
stubProperty(stubElement, testValue);
driver.StubId("some-element", stubElement, browserSession, sessionConfiguration);
SpyTimingStrategy.AlwaysReturnFromRobustly(stubElement);
if (typeof(T) == typeof(bool))
{
Assert.That(getProperty(browserSession.FindId("some-element")), constraint(testValue));
}
else
{
Assert.That(getProperty(browserSession.FindId("some-element")), constraint(testValue));
}
var queryResult = RunQueryAndCheckTiming();
Assert.That(queryResult, Is.SameAs(stubElement));
}
public void It_waits_between_find_and_click_as_configured(int waitMs)
{
var stubButtonToBeClicked = StubButtonToBeClicked("Some button locator");
var expectedWait = TimeSpan.FromMilliseconds(waitMs);
sessionConfiguration.WaitBeforeClick = expectedWait;
var waiterCalled = false;
fakeWaiter.DoOnWait(milliseconds =>
{
Assert.That(milliseconds, Is.EqualTo(expectedWait));
AssertButtonFound();
AssertButtonNotClickedYet(stubButtonToBeClicked);
waiterCalled = true;
});
browserSession.ClickButton("Some button locator");
SpyTimingStrategy.QueriesRan <object>().Last().Run();
Assert.That(waiterCalled, "The waiter was not called");
AssertClicked(stubButtonToBeClicked);
}
public void When_query_returns_false_It_raises_an_exception()
{
var state1 = new State(new AlwaysSucceedsQuery<bool>(false, true, TimeSpan.Zero, SessionConfiguration.RetryInterval));
var state2 = new State(new AlwaysSucceedsQuery<bool>(false, true, TimeSpan.Zero, SessionConfiguration.RetryInterval));
var robustWrapper = new SpyTimingStrategy();
robustWrapper.StubQueryResult(true, false);
var session = BuildSession(robustWrapper);
try
{
session.FindState(state1, state2);
Assert.Fail("Expected MissingHTMLException");
}
catch (MissingHtmlException e)
{
Assert.That(e.Message, Is.EqualTo("None of the given states was reached within the configured timeout."));
}
}
private void ExecuteLastDeferedRobustAction()
{
SpyTimingStrategy.QueriesRan <object>().Last().Run();
}
