public void WithSeleniumReporting_WithCanNotify_ShouldReturnCorrectValue(
[Modest] Actor actor,
IActor iactor,
string screenshotDirectory,
string screenshotName,
IObserver <string>[] observers,
ICanNotify canNotify)
{
#pragma warning disable CS0618 // Type or member is obsolete
var actual = ActorExtensions.WithSeleniumReporting(
actor,
screenshotDirectory,
screenshotName,
canNotify,
out var actualSeleniumReporter,
observers
);
#pragma warning restore CS0618 // Type or member is obsolete
TestWithSeleniumReporting(actualSeleniumReporter,
actual,
actor,
iactor,
screenshotDirectory,
screenshotName,
observers,
new CompositeCanNotify(canNotify, SeleniumReportingConfiguration.DefaultCanNotify),
_defaultTakeScreenshotStrategy);
}
public void WithSeleniumReporting_WithConfiguration_ShouldReturnCorrectValue(
[Modest] Actor actor,
IActor iactor,
SeleniumReportingConfiguration configuration,
IObserver <string>[] observers,
ICanNotify canNotify,
ITakeScreenshotStrategy takeScreenshotStrategy,
ScreenshotFormat format)
{
var actual = ActorExtensions.WithSeleniumReporting(
actor,
configuration,
out var actualSeleniumReporter
);
TestWithSeleniumReporting(actualSeleniumReporter,
actual,
actor,
iactor,
configuration.ScreenshotDirectory,
configuration.ScreenshotNameOrFormat,
observers,
canNotify,
takeScreenshotStrategy,
format);
}
private static void TestWithSeleniumReporting(
ISeleniumReporter actualSeleniumReporter,
Actor actual,
Actor actor,
IActor iactor,
string screenshotDirectory,
string screenshotName,
IObserver <string>[] observers,
ICanNotify canNotify,
ITakeScreenshotStrategy takeScreenshotStrategy)
{
// assert
var xmlDocumentObserver = new XmlDocumentObserver();
var takeScreenshot = actual.InnerActorBuilder(iactor).Should().BeOfType <TakeScreenshot>().Which;
var expectedTakeScreenshot = ActorExtensions.TakeScreenshots(
actor,
screenshotName,
new CompositeObserver <ScreenshotInfo>(
new ScreenshotInfoToActionAttachmentObserverAdapter(xmlDocumentObserver),
new RenderedScreenshotInfoObserver(new CompositeObserver <string>(observers)),
new SaveScreenshotsToFileOnComplete(screenshotDirectory)
),
takeScreenshotStrategy
)
.InnerActorBuilder(iactor) as TakeScreenshot;
takeScreenshot.Should().BeEquivalentTo(expectedTakeScreenshot, o => o.Excluding(a => a.Actor)
.Excluding(a => a.NextScreenshotName)
.RespectingRuntimeTypes());
var actualScreenshotNames = Enumerable.Range(0, 10).Select(_ => takeScreenshot.NextScreenshotName());
var expectedScreenshotNames = Enumerable.Range(0, 10).Select(_ => expectedTakeScreenshot.NextScreenshotName());
actualScreenshotNames.Should().BeEquivalentTo(expectedScreenshotNames);
var reportingActor = takeScreenshot.Actor.Should().BeOfType <ReportingActor>().Which;
var expectedReportingActor = actor.WithReporting(
new CompositeObserver <ActionNotification>(
xmlDocumentObserver,
new RenderedReportingObserver(
new CompositeObserver <string>(observers),
RenderedReportingObserver.DefaultRenderer
)
),
canNotify
)
.InnerActorBuilder(iactor) as ReportingActor;
reportingActor.Should().BeEquivalentTo(expectedReportingActor, o => o.Excluding(a => a.Actor)
.Excluding(a => a.MeasureTime.Now)
.Excluding((IMemberInfo m) => m.RuntimeType == typeof(DateTimeOffset))
.RespectingRuntimeTypes());
var expectedSeleniumReporter = new SeleniumReporter(xmlDocumentObserver, new SaveScreenshotsToFileOnComplete(screenshotDirectory));
actualSeleniumReporter.Should().BeEquivalentTo(expectedSeleniumReporter, o => o.Excluding((IMemberInfo m) => m.RuntimeType == typeof(DateTimeOffset)));
}
public void SlowSelenium_ShouldDecorateActor(
[Modest] Actor actor,
[Modest] SlowSelenium expected)
{
//arrange
//act
var actual = ActorExtensions.SlowSelenium(actor, expected.Delay).InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <SlowSelenium>().Which.Should().BeEquivalentTo(expected);
}
public void HighlighTargets_ShouldDecorateActor(
[Modest] Actor actor,
[Modest] HighlightTarget expected)
{
//arrange
//act
var actual = ActorExtensions.HighlightTargets(actor).InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <HighlightTarget>().Which.Should().BeEquivalentTo(expected);
}
public void WithReporting_ShouldDecorateActor(
[Modest] Actor actor,
ReportingActor expected)
{
//arrange
//act
var actual = ActorExtensions.WithReporting(actor, expected.Observer, expected.MeasureTime).InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <ReportingActor>().Which.Should().BeEquivalentTo(expected);
}
public void TakeScreenshots_NextScreenshotName_ShouldReturnCorrectValue(
[Modest] Actor actor,
TakeScreenshot expected,
string expectedName,
string directory)
{
//arrange
//act
var actual = ActorExtensions.TakeScreenshots(actor, directory, expectedName).InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <TakeScreenshot>().Which.NextScreenshotName().Should().Be(expectedName + "_01");
}
public void TakeScreenshots_NextScreenshotName_WithFormatWith2Placeholders_ShouldThrow(
[Modest] Actor actor,
string startName,
string endName,
string directory)
{
//arrange
//act
new System.Action(() => ActorExtensions.TakeScreenshots(actor, directory, $"{startName}{{0:0000}}{endName}{{1}}"))
.Should().ThrowExactly <FormatException>();
//assert
}
public void TakeScreenshots_ShouldDecorateActor(
ActorDecoratorExtensionAssertion assertion,
[Modest] Actor actor,
TakeScreenshot expected,
string name)
{
//arrange
//act
var actual = ActorExtensions.TakeScreenshots(actor, expected.Directory, name).InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <TakeScreenshot>().Which.ShouldBeEquivalentTo(expected, o => o.Excluding(t => t.NextScreenshotName));
}
public void TakeScreenshots_ShouldDecorateActor(
[Modest] Actor actor,
TakeScreenshot expected,
string name,
string directory)
{
//arrange
expected = new TakeScreenshot(expected.Actor, expected.NextScreenshotName, new SaveScreenshotsToFileOnNext(directory));
//act
var actual = ActorExtensions.TakeScreenshots(actor, directory, name).InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <TakeScreenshot>().Which.Should().BeEquivalentTo(expected, o => o.Excluding(t => t.NextScreenshotName));
}
public void WithReporting_WithIObserverOfString_ShouldDecorateActor(
[Modest] Actor actor,
ReportingActor expected,
IObserver <string> observer)
{
//arrange
//act
var actual = ActorExtensions.WithReporting(actor, observer).InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <ReportingActor>()
.Which.Observer.Should().BeOfType <RenderedReportingObserver>()
.Which.Observer.Should().Be(observer);
}
public void TakeScreenshots_NextScreenshotName_WithFormat_ShouldReturnCorrectValue(
[Modest] Actor actor,
TakeScreenshot expected,
string startName,
string endName,
string directory)
{
//arrange
var expectedName = $"{startName}0001{endName}";
//act
var actual = ActorExtensions.TakeScreenshots(actor, directory, $"{startName}{{0:0000}}{endName}").InnerActorBuilder(expected.Actor);
//assert
actual.Should().BeOfType <TakeScreenshot>().Which.NextScreenshotName().Should().Be(expectedName);
}
public void TakeScreenshots_NextScreenshotName_CalledMultipleTimes_ShouldReturnCorrectValue(
[Modest] Actor actor,
TakeScreenshot expected,
string expectedName,
string directory)
{
//arrange
//act
var actual = ActorExtensions.TakeScreenshots(actor, directory, expectedName).InnerActorBuilder(expected.Actor);
//assert
var func = actual.Should().BeOfType <TakeScreenshot>().Which.NextScreenshotName;
var expectedNames = Enumerable.Range(1, 99).Select(i => expectedName + "_" + i.ToString("00"));
var actualNames = Enumerable.Range(1, 99).Select(_ => func());
actualNames.Should().BeEquivalentTo(expectedNames);
}
public void TakeScreenshots_NextScreenshotName_WithFormatCalledMultipleTimes_ShouldReturnCorrectValue(
[Modest] Actor actor,
TakeScreenshot expected,
string startName,
string endName,
string directory)
{
//arrange
var expectedName = $"{startName}0001{endName}";
//act
var actual = ActorExtensions.TakeScreenshots(actor, directory, $"{startName}{{0:0000}}{endName}").InnerActorBuilder(expected.Actor);
//assert
var func = actual.Should().BeOfType <TakeScreenshot>().Which.NextScreenshotName;
var expectedNames = Enumerable.Range(1, 99).Select(i => $"{startName}{i.ToString("0000")}{endName}");
var actualNames = Enumerable.Range(1, 99).Select(_ => func());
actualNames.Should().BeEquivalentTo(expectedNames);
}
