protected override void InitActor()
{
Actor = SystemActor.AttemptsTo(Create.Actor(UserType.RegularUser));
var userCarpenter = TestData.Get <UserInfo>("FirstUserInfo");
var userWoods = TestData.Get <UserInfo>("SecondUserInfo");
Actor.ActorInfo.FirstName = userCarpenter.FirstName;
Actor.ActorInfo.LastName = userCarpenter.LastName;
Actor.ActorInfo.LoginName = userCarpenter.LoginName;
Actor.AttemptsTo(Update.UserAndIdentityInfo.To(Actor.ActorInfo));
replacementMap.Add("{userAliasId1}", Actor.ActorInfo.AliasId);
Actor2 = SystemActor.AttemptsTo(Create.Actor(UserType.RegularUser));
replacementMap.Add("{userAliasId2}", Actor2.ActorInfo.AliasId);
Actor2.ActorInfo.ManagerId = Actor.ActorInfo.Id;
Actor2.ActorInfo.FirstName = userWoods.FirstName;
Actor2.ActorInfo.LastName = userWoods.LastName;
Actor2.ActorInfo.LoginName = userWoods.LoginName;
Actor.AttemptsTo(Update.UserAndIdentityInfo.To(Actor2.ActorInfo));
}
public void CanUseIf_WhenPredicateIsFalse_ShouldNotAddCapability(IActorFacade actor, object capability)
{
// act
var actual = actor.CanUseIf(() => capability, false);
// assert
Assert.Equal(actor, actual);
}
public void CanUseIf_WhenPredicateIsTrue_ShouldAddCapability(IActorFacade actor, IActorFacade expected, object capability)
{
// arrange
Mock.Get(actor).Setup(a => a.CanUse(capability)).Returns(expected);
// act
var actual = actor.CanUseIf(() => capability, true);
// assert
Assert.Equal(expected, actual);
}
private void CheckErrorMessage(IActorFacade <IUserInfo> actor, string errorMessage)
{
var errorMessageElement = LoginPageElements.ErrorMessage;
actor.AttemptsTo(Wait.UntilQuestionIsAnswered(Presence.Of(errorMessageElement), x => x)
.WithTimeout(TimeSpan.FromSeconds(5)));
actor.AttemptsTo(Wait.UntilQuestionIsAnswered(Visibility.Of(errorMessageElement), a => a));
actor.ChecksThat(Visibility.Of(errorMessageElement), Is.True);
actor.ChecksThat(TextContent.Of(errorMessageElement),
Is.EqualTo(errorMessage));
}
/// <summary>
/// Execute all the given <see cref = "IWhenCommand{TResult}"/> when the actor uses the system
/// </summary>
/// <param name = "commands">A list of <see cref = "IWhenCommand{TResult}"/> representing the actions performed by the actor</param>
/// <typeparam name="TResult">The type returned by the action. Use the <see cref="Unit"/> to represent void actions</typeparam>
/// <param name="actor">The actor used to perform the actions</param>
/// <returns>An array of all the command results</returns>
public static ImmutableArray <TResult> When <TResult>(this IActorFacade actor, params IWhenCommand <TResult>[] commands)
{
if (actor == null)
{
throw new ArgumentNullException(nameof(actor));
}
if (commands == null)
{
throw new ArgumentNullException(nameof(commands));
}
return(commands.Select(c => actor.When(c)).ToImmutableArray());
}
public void Before()
{
var screenshotName = Context.ScenarioInfo.Title;
#if DEBUG
var delay = IsLiveUnitTesting ? TimeSpan.Zero : TimeSpan.FromSeconds(1);
#else
var delay = TimeSpan.Zero;
#endif
if (IsLiveUnitTesting)
{
delay = TimeSpan.Zero;
}
var actorSource = new Actor("John");
IActorFacade actor = actorSource;
if (TestLevel == TestLevel.UI)
{
var driver = CreateWebDriver();
actor = actorSource.WithSeleniumReporting(
new SeleniumReportingConfiguration(
GetScreenshotsPath(),
screenshotName)
.AddTextObservers(new DebugObserver())
.WithCanNotify(new CanNotify())
.WithScreenshotPng()
.WithTakeScreenshotStrategy(new TakeScreenshotOnErrorStrategy()),
out var seleniumReporter)
.HighlightTargets()
.SlowSelenium(delay)
.CanUse(seleniumReporter)
.CanUse(WebBrowser.With(driver));
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(5);
Context.Set(driver);
}
// Indicates what level of automation is supported by the current scenario
var levels = new[] { TestLevel.UI, TestLevel.Api }.Where(l => l >= TestLevel).ToArray();
actor = actor.CanUse <IActionTags <TestLevel> >(ActionTags.Create(levels))
.CanUse(ClientFactory());
Context.Set(actor);
if (TestLevel == TestLevel.UI)
{
actor.Given(Open.TheApplication());
}
}
public void When_ShouldCallWhen(int count, IActorFacade actor, IFixture fixture)
{
// arrange
var mockActor = Mock.Get(actor);
var expected = fixture.CreateMany <object>(count);
var commands = fixture.CreateMany <IWhenCommand <object> >(count)
.Zip(expected, (command, exp) =>
{
mockActor.Setup(a => a.When(command)).Returns(exp);
return(command);
})
.ToArray();
// act
var actual = ActorFacadeExtensions.When(actor, commands);
// assert
actual.Should().BeEquivalentTo(expected);
}
/// <summary>
/// Give an ability to the actor if the predicate is true
/// </summary>
/// <typeparam name="T">The type of the ability</typeparam>
/// <param name="actor"></param>
/// <param name="doSomething">Ability</param>
/// <param name="predicate">A value indicating if the ability should be added</param>
/// <returns>A new actor with the given ability</returns>
public static IActorFacade CanUseIf <T>(this IActorFacade actor, Func <T> doSomething, bool predicate)
where T : class
{
if (actor is null)
{
throw new ArgumentNullException(nameof(actor));
}
if (doSomething is null)
{
throw new ArgumentNullException(nameof(doSomething));
}
if (predicate)
{
return(actor.CanUse(doSomething()));
}
return(actor);
}
protected override void CheckLoginFailed(IActorFacade <IUserInfo> actor)
{
actor.ChecksThat(Classes.Of(LoginPageElements.PasswordInputField), x => Assert.Contains("wrong", x));
actor.ChecksThat(HtmlAttribute.Of(LoginPageElements.PasswordInputField).Named(("required")), Is.EqualTo("true"));
}
protected override void CheckServicePackVersion(IActorFacade <IUserInfo> actor, IInnovatorTestRunSettings settings)
{
var innovatorVersion = settings.InnovatorVersion.GetDescription();
CheckVariableValue(actor, "VersionServicePack", innovatorVersion.Split(' ').Last());
}
protected virtual void CheckLoginFailed(IActorFacade <IUserInfo> actor)
{
CheckErrorMessage(actor, missingPassMessage);
}
protected virtual void CheckServicePackVersion(IActorFacade <IUserInfo> actor, IInnovatorTestRunSettings settings)
{
CheckVariableValue(actor, "VersionServicePack", "None");
}
protected void CheckVariableValue(IActorFacade <IUserInfo> actor, string varName, string varValue)
{
var rowNumber = actor.AsksFor(MainGridState.Unfrozen.IndexOfRowByValueInColumn(varName, columnLabel));
actor.ChecksThat(MainGridState.Unfrozen.CellValue(rowNumber, 2), Is.EqualTo(varValue));
}
private void CheckLoginIsSuccessful(IActorFacade <IUserInfo> actor)
{
actor.ChecksThat(Visibility.Of(PageElements.MainContainer), Is.True);
actor.ChecksThat(Visibility.Of(PageElements.Header), Is.True);
}
internal void Invoke(IActorFacade <IUserInfo> actor, IInnovatorTestRunSettings settings)
{
//a
actor.ChecksThat(ServerLogState.ServerFileInfo("VersionServer.xml"), Is.Empty);
//c
actor.AttemptsTo(Open.Application.By(settings.ClientUrl), Actions.Chains.WaitChains.Wait.ForLoginPageLoading);
//c.i
actor.ChecksThat(TextContent.Of(LoginPageElements.InnovatorVersion), Is.EqualTo(logonFormLabel));
//c.ii
actor.ChecksThat(HtmlAttribute.Of(LoginPageElements.UserNameInputField).Named("placeholder"),
Is.EqualTo(usernameTip));
actor.ChecksThat(HtmlAttribute.Of(LoginPageElements.PasswordInputField).Named("placeholder"),
Is.EqualTo(passwordTip));
//d, e
actor.AttemptsTo(LogIn.ToInnovator.As(actor.ActorInfo));
CheckLoginIsSuccessful(actor);
actor.ChecksThat(Page.Url, Is.EqualTo(string.Concat(settings.ClientUrl, "/")));
//f
actor.AttemptsTo(Select.UserMenuItem.ByPath(UserMenuItems.AboutId));
//f.i
var dialogContainer = PageElements.DialogsContainer;
actor.ChecksThat(Visibility.Of(ArasDialogElements.Dialog(dialogContainer)), Is.True);
//f.ii
actor.ChecksThat(
TextContent.Of(AboutDialogElements.VersionAndBuildNumber(dialogContainer)),
x => Assert.AreEqual(
FormattableString.Invariant(
$"Aras Innovator Version {settings.InnovatorVersion.GetDescription()} Build: {settings.BuildNumber}"),
x.Replace(" ", " "))
);
//g
actor.AttemptsTo(Click.On(AboutDialogElements.OkButton(dialogContainer)));
//h
actor.AttemptsTo(
Open.NavigationPanel,
Pin.NavigationPanel
);
//i
actor.AttemptsTo(
Open.SearchPanel.OfTocItemWithPath("Administration/Variable").ByLoupeIcon,
Search.Simple.InMainGrid.With(searchData)
);
//i.i
CheckVariableValue(actor, "VersionBuild", settings.BuildNumber);
CheckServicePackVersion(actor, settings);
CheckVariableValue(actor, "VersionMinor", "0");
CheckVariableValue(actor, "VersionServiceUpdate", "0");
//j
actor.AttemptsTo(LogOut.FromInnovator);
//j.i
actor.ChecksThat(Displayed.Of(LoginPageElements.InfoContentDescription), Is.True);
actor.ChecksThat(TextContent.Of(LoginPageElements.InfoContentDescription),
Is.EqualTo(loggedOutLabel));
//k
actor.AttemptsTo(Click.On(LoginPageElements.LoginAgainButton));
//k.i
var link = LoginPageElements.ArasLink;
actor.AttemptsTo(
Wait.UntilTargetIsPresent(LoginPageElements.LoginButton),
Wait.UntilTargetIsClickable(link));
//l.i
actor.ChecksThat(ServerLogState.ServerFileInfo("VersionServer.xml"), Is.Not.Empty);
//m
var initialTabHandle = actor.AsksFor(Page.WindowHandle);
var newTabHandle = actor.AttemptsTo(Open.NewBrowserTab.ByClickOnLink(link));
actor.AttemptsTo(Switch.ToBrowserTab.WithHandle(newTabHandle));
actor.AttemptsTo(Wait.UntilQuestionIsAnswered(Page.Url, url => url != "about:blank"));
//m.i
actor.ChecksThat(Page.Url, x => StringAssert.StartsWith(ArasUrl, x));
//n
actor.AttemptsTo(Close.BrowserTab.Current.ByButton,
Switch.ToBrowserTab.WithHandle(initialTabHandle));
//o
actor.AttemptsTo(
Enter.TheNewValue(actor.ActorInfo.LoginName).Into(LoginPageElements.UserNameInputField),
Enter.TheNewValue(string.Empty).Into(LoginPageElements.PasswordInputField));
actor.ChecksThat(JsScriptResult.For(opacityQuerySelectorScript), Is.EqualTo("0"));
actor.AttemptsTo(CoreSelect.TheText(actor.ActorInfo.DatabaseName)
.Into(LoginPageElements.DatabaseSelectField));
//p
actor.AttemptsTo(Click.On(LoginPageElements.LoginButton));
//p.i
CheckLoginFailed(actor);
//q
actor.AttemptsTo(
Enter.TheNewValue(userName).Into(LoginPageElements.UserNameInputField),
Enter.TheNewValue(actor.ActorInfo.Password).Into(LoginPageElements.PasswordInputField),
CoreSelect.TheText(actor.ActorInfo.DatabaseName).Into(LoginPageElements.DatabaseSelectField)
);
//r
actor.AttemptsTo(Click.On(LoginPageElements.LoginButton));
//r.i
CheckErrorMessage(actor, authFailedMessage);
//s
actor.AttemptsTo(Enter.TheNewValue("Admin").Into(LoginPageElements.UserNameInputField));
//t
actor.AttemptsTo(Clear.TheValueOf(LoginPageElements.PasswordInputField));
//u
actor.AttemptsTo(Set.NewValue("true").ForHtmlAttribute("data-tooltip-show")
.OfTarget(LoginPageElements.PasswordFieldTooltip));
actor.AttemptsTo(Wait.UntilQuestionIsAnswered(JsScriptResult.For(opacityQuerySelectorScript),
a => a.ToString() == "1"));
actor.ChecksThat(HtmlAttribute.Of(LoginPageElements.PasswordFieldTooltip).Named("data-tooltip-show"),
Is.EqualTo("true"));
actor.ChecksThat(HtmlAttribute.Of(LoginPageElements.PasswordFieldTooltip).Named("data-tooltip"),
x => Assert.IsTrue(x.StartsWith(capsIsOnMessage, false,
CultureInfo.CurrentCulture)));
actor.ChecksThat(JsScriptResult.For(opacityQuerySelectorScript), Is.EqualTo("1"));
//v
actor.AttemptsTo(Set.NewValue("false").ForHtmlAttribute("data-tooltip-show")
.OfTarget(LoginPageElements.PasswordFieldTooltip));
actor.ChecksThat(HtmlAttribute.Of(LoginPageElements.PasswordFieldTooltip).Named("data-tooltip-show"),
Is.EqualTo("false"));
actor.ChecksThat(Visibility.Of(LoginPageElements.DatabaseSelectField), Is.True);
actor.ChecksThat(Visibility.Of(LoginPageElements.LoginButton), Is.True);
actor.AttemptsTo(Wait.UntilQuestionIsAnswered(JsScriptResult.For(opacityQuerySelectorScript),
a => a.ToString() == "0"));
//w
actor.AttemptsTo(LogIn.ToInnovator.As(actor.ActorInfo));
CheckLoginIsSuccessful(actor);
}
