using System;
|
using System.Collections.Generic;
|
using System.ComponentModel;
|
using System.Linq;
|
using System.Threading;
|
using NUnit.Framework;
|
using OpenTap.Plugins.BasicSteps;
|
using Tap.Shared;
|
namespace OpenTap.UnitTests
|
{
|
[TestFixture]
|
public class MixinTests
|
{
|
[Test]
|
public void TestLoadingMixins()
|
{
|
var plan = new TestPlan();
|
var step = new LogStep();
|
plan.ChildTestSteps.Add(step);
|
|
MixinFactory.LoadMixin(step, new MixinTestBuilder
|
{
|
TestMember = "123"
|
});
|
|
plan.Execute();
|
|
var xml = plan.SerializeToString();
|
|
var plan2 = (TestPlan)new TapSerializer().DeserializeFromString(xml);
|
var step2 = plan2.ChildTestSteps[0];
|
var onPostRunCalled = TypeData.GetTypeData(step2).GetMember("TestMixin.OnPostRunCalled").GetValue(step2);
|
var onPreRunCalled = TypeData.GetTypeData(step2).GetMember("TestMixin.OnPreRunCalled").GetValue(step2);
|
|
Assert.AreEqual(true, onPostRunCalled);
|
Assert.AreEqual(true, onPreRunCalled);
|
}
|
|
[Test]
|
public void TestMixinWithValidationRule()
|
{
|
var step = new LogStep();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(step);
|
|
var builder = new MixinBuilderUi(new IMixinBuilder[]
|
{
|
new MixinTestBuilder
|
{
|
TestMember = null
|
}
|
});
|
|
var builderType = TypeData.GetTypeData(builder);
|
foreach (var rule in builder.Rules)
|
{
|
var member = builderType.GetMember(rule.PropertyName);
|
Assert.IsNotNull(member);
|
if (member.Name.Contains("TestMember"))
|
{
|
Assert.AreEqual("Test member must not be null.", (builder as IValidatingObject)[member.Name]);
|
}
|
}
|
|
Assert.AreEqual("Test member must not be null.", builder.Error);
|
|
builder = new MixinBuilderUi(new IMixinBuilder[]
|
{
|
new MixinTestBuilder
|
{
|
TestMember = "123"
|
}
|
});
|
Assert.IsTrue(string.IsNullOrWhiteSpace(builder.Error));
|
|
|
}
|
|
|
public class ProcessStepMixin : ITestStepPostRunMixin
|
{
|
|
public void OnPostRun(TestStepPostRunEventArgs eventArgs)
|
{
|
var step = (ResultsFromAttributesStep)eventArgs.TestStep;
|
step.X = step.RunIndex * 5 + 2;
|
step.Y = step.RunIndex * 10 + 513;
|
step.UpgradeVerdict(Verdict.Pass);
|
}
|
}
|
|
public class ResultsFromAttributesStep : TestStep
|
{
|
[Result]
|
public double RunIndex { get; set; }
|
|
[Result]
|
public double X { get; set; }
|
|
[Result]
|
public double Y { get; set; }
|
|
// add a mixin which generates new values for X and Y.
|
[EmbedProperties]
|
public ProcessStepMixin ResultsProcessorMixin { get; set; } = new ProcessStepMixin();
|
|
public override void Run()
|
{
|
RunIndex += 1;
|
}
|
}
|
|
//
|
[Test]
|
public void DynamicResultsFromMixinTest()
|
{
|
var results = new ResultsFromAttributesStep();
|
var loop = new RepeatStep();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(loop);
|
loop.ChildTestSteps.Add(results);
|
var rl = new RecordAllResultListener();
|
var run = plan.Execute(new[]
|
{
|
rl
|
});
|
|
Assert.AreEqual(Verdict.Pass, run.Verdict);
|
Assert.AreEqual(loop.Count * 1, rl.Results.Count);
|
for (int i = 0; i < loop.Count; i++)
|
{
|
var idx = (double)rl.Results[i].Columns.First(x => x.Name == "RunIndex").Data.GetValue(0);
|
var x = (double)rl.Results[i].Columns.First(x => x.Name == "X").Data.GetValue(0);
|
var y = (double)rl.Results[i].Columns.First(x => x.Name == "Y").Data.GetValue(0);
|
Assert.AreEqual(idx * 5 + 2, x);
|
Assert.AreEqual(idx * 10 + 513, y);
|
}
|
}
|
|
[Test]
|
public void TestAddMixinRestrictions([Values] bool isLocked)
|
{
|
var plan = new TestPlan();
|
var step = new DelayStep();
|
plan.ChildTestSteps.Add(step);
|
plan.Locked = isLocked;
|
var memberAnnotation = AnnotationCollection.Annotate(step).GetMember(nameof(step.DelaySecs));
|
var menu = memberAnnotation.Get<MenuAnnotation>().MenuItems.ToArray();
|
var mixinItem = menu.FirstOrDefault(x => x.Get<IIconAnnotation>()?.IconName == IconNames.AddMixin);
|
var access = mixinItem.GetAll<IAccessAnnotation>();
|
var hidden = access.Any(x => x.IsVisible == false);
|
if (isLocked)
|
Assert.IsTrue(hidden);
|
else
|
Assert.IsFalse(hidden);
|
}
|
|
[Test]
|
public void TestMixinFromReferencedTestPlan()
|
{
|
|
var planName = nameof(TestMixinFromReferencedTestPlan) + Guid.NewGuid() + ".TapPlan";
|
var plan2Name = nameof(TestMixinFromReferencedTestPlan) + Guid.NewGuid() + ".TapPlan";
|
|
{ // create plan with a mixin that has been parameterized.
|
var plan1 = new TestPlan();
|
var step1 = new DelayStep();
|
plan1.ChildTestSteps.Add(step1);
|
MixinFactory.LoadMixin(step1, new MixinTestBuilder()
|
{
|
TestMember = nameof(step1.DelaySecs)
|
});
|
|
var member = TypeData.GetTypeData(step1).GetMember("TestMixin.OutputStringValue");
|
member.Parameterize(plan1, step1, "A");
|
|
plan1.Save(planName);
|
}
|
{
|
var plan2 = new TestPlan();
|
var tpr = new TestPlanReference();
|
tpr.Filepath.Text = planName;
|
plan2.ChildTestSteps.Add(tpr);
|
tpr.LoadTestPlan();
|
var aMember = TypeData.GetTypeData(tpr).GetMember("A");
|
aMember.SetValue(tpr, "123");
|
Assert.IsNotNull(aMember);
|
plan2.Save(plan2Name);
|
}
|
{
|
var plan = TestPlan.Load(plan2Name);
|
var tpr2 = (TestPlanReference)plan.ChildTestSteps[0];
|
var aMember = TypeData.GetTypeData(tpr2).GetMember("A");
|
Assert.IsNotNull(aMember);
|
var aMemberValue = aMember.GetValue(tpr2) as string;
|
Assert.AreEqual("123", aMemberValue);
|
}
|
}
|
|
[Test]
|
public void TestMixinOnTestPlanDirect()
|
{
|
|
var planName = nameof(TestMixinOnTestPlanDirect) + Guid.NewGuid() + ".TapPlan";
|
|
{ // create plan with a mixin that has been parameterized.
|
var plan1 = new TestPlan();
|
var step1 = new DelayStep();
|
plan1.ChildTestSteps.Add(step1);
|
MixinFactory.LoadMixin(plan1, new MixinTestBuilder()
|
{
|
TestMember = nameof(plan1.Locked)
|
});
|
|
var member = TypeData.GetTypeData(plan1).GetMember("TestMixin.OutputStringValue");
|
member.SetValue(plan1, "123");
|
plan1.Save(planName);
|
}
|
|
{
|
var plan = TestPlan.Load(planName);
|
var member = TypeData.GetTypeData(plan).GetMember("TestMixin.OutputStringValue");
|
Assert.IsNotNull(member);
|
var aMemberValue = member.GetValue(plan) as string;
|
Assert.AreEqual("123", aMemberValue);
|
}
|
}
|
|
public class MixinOrder1 : ITestStepPreRunMixin,ITestStepPostRunMixin
|
{
|
public string Value = "";
|
|
public void OnPreRun(TestStepPreRunEventArgs eventArgs)
|
{
|
(eventArgs.TestStep as TestStepWithMixins).preOrders.Add(Value);
|
}
|
public void OnPostRun(TestStepPostRunEventArgs eventArgs)
|
{
|
(eventArgs.TestStep as TestStepWithMixins).postOrders.Add(Value);
|
}
|
}
|
|
public class MixinOrder2 : ITestStepPreRunMixinOrder, ITestStepPostRunMixinOrder
|
{
|
public string Value = "";
|
|
public double Order;
|
public void OnPreRun(TestStepPreRunEventArgs eventArgs)
|
{
|
(eventArgs.TestStep as TestStepWithMixins).preOrders.Add(Value);
|
}
|
public double GetPreRunOrder() => Order;
|
public double GetPostRunOrder() => -Order;
|
public void OnPostRun(TestStepPostRunEventArgs eventArgs)
|
{
|
(eventArgs.TestStep as TestStepWithMixins).postOrders.Add(Value);
|
}
|
}
|
|
|
public class TestStepWithMixins : TestStep
|
{
|
// the order of execution depends on the Order set
|
// but also the declaration order if Order is the same.
|
|
public List<string> preOrders = new List<string>();
|
public List<string> postOrders = new List<string>();
|
[EmbedProperties]
|
public MixinOrder2 A { get; set; } = new () { Value = nameof(A), Order=-1 };
|
[EmbedProperties]
|
public MixinOrder1 E { get; set; } = new () { Value = nameof(E) };
|
[EmbedProperties]
|
public MixinOrder2 B { get; set; } = new () { Value = nameof(B), Order=-1 };
|
[EmbedProperties]
|
public MixinOrder2 H { get; set; }= new () { Value = nameof(H), Order=1 };
|
[EmbedProperties]
|
public MixinOrder2 I { get; set; }= new () { Value = nameof(I), Order=1 };
|
[EmbedProperties]
|
public MixinOrder1 F { get; set; }= new () { Value = nameof(F) };
|
[EmbedProperties]
|
public MixinOrder2 C { get; set; }= new () { Value = nameof(C), Order=-1 };
|
[EmbedProperties]
|
public MixinOrder1 G { get; set; }= new () { Value = nameof(G) };
|
[EmbedProperties]
|
public MixinOrder2 D { get; set; }= new () { Value = nameof(D), Order=-1 };
|
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void TestMixinOrder()
|
{
|
var step = new TestStepWithMixins();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(step);
|
plan.Execute();
|
Assert.IsTrue(step.preOrders.SequenceEqual(["A", "B", "C", "D", "E", "F", "G", "H", "I"]));
|
Assert.IsTrue(step.postOrders.SequenceEqual(["H", "I", "E", "F", "G", "A", "B", "C", "D"]));
|
|
}
|
|
[Test]
|
public void TestParameterizeAndRemoveMixin()
|
{
|
// verify that a parameterized mixin member has the parameter removed when the mixin is removed.
|
var plan1 = new TestPlan();
|
var step1 = new DelayStep();
|
plan1.ChildTestSteps.Add(step1);
|
var numberMember = MixinFactory.LoadMixin(step1, new TestNumberMixinBuilder { Name = "A" });
|
|
numberMember.Parameterize(plan1, step1, "A");
|
|
var paramMember0 = TypeData.GetTypeData(plan1).GetMember("A");
|
// now this should _not_ be null.
|
Assert.IsNotNull(paramMember0);
|
|
MixinFactory.UnloadMixin(step1, numberMember);
|
var paramMember = TypeData.GetTypeData(plan1).GetMember("A");
|
// now this should be null (removed).
|
Assert.IsNull(paramMember);
|
|
// now try with an embedded member mixin.
|
var embeddedMixin = MixinFactory.LoadMixin(step1, new MixinTestBuilder()
|
{
|
TestMember = nameof(step1.DelaySecs)
|
});
|
var embeddedMember = TypeData.GetTypeData(step1).GetMember("TestMixin.OutputStringValue");
|
embeddedMember.Parameterize(plan1, step1, "B");
|
|
var paramMember2 = TypeData.GetTypeData(plan1).GetMember("B");
|
// now this should _not_ be null.
|
Assert.IsNotNull(paramMember2);
|
MixinFactory.UnloadMixin(step1, embeddedMixin);
|
|
var paramMember3 = TypeData.GetTypeData(plan1).GetMember("B");
|
// now this should be null.
|
Assert.IsNull(paramMember3);
|
}
|
|
public class ActionStep : TestStep
|
{
|
public Action action { get; set; }
|
|
public override void Run()
|
{
|
action();
|
}
|
public static ActionStep FromAction(Action action) => new ActionStep()
|
{
|
action = action
|
};
|
}
|
|
[Test]
|
public void CannotAddMixinWhilePlanRunning()
|
{
|
ManualResetEvent continueEvt = new ManualResetEvent(false);
|
ManualResetEvent started = new ManualResetEvent(false);
|
var step = ActionStep.FromAction(() =>
|
{
|
started.Set();
|
continueEvt.WaitOne();
|
});
|
var plan = new TestPlan();
|
plan.ChildTestSteps.Add(step);
|
var planRun = plan.ExecuteAsync();
|
started.WaitOne();
|
// ok, now the test plan is waiting until we set continueEvt.
|
|
var a = AnnotationCollection.Annotate(step);
|
var addMixin = a.GetIcon(IconNames.AddMixin);
|
Assert.IsNotNull(addMixin);
|
var enabled = addMixin.GetAll<IEnabledAnnotation>();
|
Assert.IsTrue(enabled.Any());
|
var isDisabled = enabled.Any(x => x.IsEnabled == false);
|
Assert.IsTrue(isDisabled);
|
continueEvt.Set();
|
planRun.Wait();
|
a.Read();
|
var isDisabled2 = enabled.Any(x => x.IsEnabled == false);
|
Assert.IsFalse(isDisabled2);
|
|
}
|
public class PrerunMixinModifyingParametersBuilder : IMixinBuilder
|
{
|
public void Initialize(ITypeData targetType)
|
{
|
}
|
|
IEnumerable<Attribute> GetAttributes()
|
{
|
yield return new EmbedPropertiesAttribute();
|
}
|
|
public MixinMemberData ToDynamicMember(ITypeData targetType)
|
{
|
return new MixinMemberData(this, () => new PrerunMixinModifyingParameters())
|
{
|
TypeDescriptor = TypeData.FromType(typeof(PrerunMixinModifyingParameters)),
|
Writable = true,
|
Readable = true,
|
DeclaringType = targetType,
|
Attributes = GetAttributes(),
|
Name = nameof(PrerunMixinModifyingParameters)
|
};
|
}
|
}
|
|
public class PrerunMixinModifyingParameters : IMixin, ITestStepPreRunMixin
|
{
|
public PrerunMixinModifyingParameters()
|
{
|
|
}
|
public void OnPreRun(TestStepPreRunEventArgs eventArgs)
|
{
|
var step = eventArgs.TestStep as LogStep;
|
step.LogMessage = "Hello Prerun";
|
step.StepRun.Parameters["Additional Parameter"] = "More Info";
|
}
|
}
|
|
[Test]
|
public void PrerunMixinModifyParametersTest()
|
{
|
var plan = new TestPlan();
|
var step = new LogStep() { LogMessage = "No Prerun" };
|
plan.ChildTestSteps.Add(step);
|
|
{ /* no mixin */
|
var rl = new RecordAllResultListener();
|
plan.Execute(new[] { rl });
|
var run = rl.RunStart.First(r => (r.Value as TestStepRun)?.TestStepId == step.Id).Value;
|
Assert.AreEqual("No Prerun", run.Parameters["Log Message"]);
|
}
|
|
{ /* prerun mixin */
|
MixinFactory.LoadMixin(step, new PrerunMixinModifyingParametersBuilder());
|
var rl = new RecordAllResultListener();
|
plan.Execute(new[] { rl });
|
var run = rl.RunStart.First(r => (r.Value as TestStepRun)?.TestStepId == step.Id).Value;
|
Assert.AreEqual("Hello Prerun", run.Parameters["Log Message"]);
|
Assert.AreEqual("More Info", run.Parameters["Additional Parameter"]);
|
}
|
}
|
|
[Test]
|
public void CanAddMixinToTestPlanReference()
|
{
|
var plan1 = new TestPlan();
|
plan1.ChildTestSteps.Add(new DelayStep());
|
var plan1File = PathUtils.GetTempFileName("TapPlan");
|
plan1.Save(plan1File);
|
|
var plan2 = new TestPlan();
|
var tpr = new TestPlanReference();
|
tpr.Filepath.Text = plan1File;
|
|
plan2.ChildTestSteps.Add(tpr);
|
tpr.LoadTestPlan();
|
{
|
var a = AnnotationCollection.Annotate(tpr);
|
var addMixin = a.GetIcon(IconNames.AddMixin);
|
var enabled = addMixin.Get<IAccessAnnotation>();
|
// it _is_ allowed to add mixins to test plan reference.
|
Assert.IsTrue(enabled.IsVisible);
|
}
|
{
|
var a = AnnotationCollection.Annotate(tpr.ChildTestSteps[0]);
|
var addMixin = a.GetIcon(IconNames.AddMixin);
|
var enabled = addMixin.Get<IAccessAnnotation>();
|
// it is not allowed to add mixins to the child steps of test plan reference.
|
Assert.IsFalse(enabled.IsVisible);
|
}
|
|
}
|
|
|
|
[Test]
|
public void CannotModifyMixinTest()
|
{
|
|
var plan1 = new TestPlan();
|
var step1 = new DelayStep();
|
plan1.ChildTestSteps.Add(step1);
|
MixinFactory.LoadMixin(step1, new MixinTestBuilder()
|
{
|
TestMember = nameof(step1.DelaySecs)
|
});
|
|
var memberAnnotation = AnnotationCollection.Annotate(step1).GetMember("TestMixin.MixinLoadValue");
|
var menuItems = memberAnnotation.Get<MenuAnnotation>().MenuItems.ToArray();
|
var menuModel = menuItems.Select(x => x.Source).OfType<MixinMemberMenuModel>().First() as IMemberMenuModel;
|
Assert.IsNotNull(menuModel.Member);
|
}
|
|
public class UserInputOverride : IUserInputInterface
|
{
|
public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
|
{
|
|
}
|
}
|
|
[Test]
|
public void ModifyMixinTest()
|
{
|
var plan1 = new TestPlan();
|
var step1 = new DelayStep();
|
plan1.ChildTestSteps.Add(step1);
|
var mixinMember = MixinFactory.LoadMixin(step1, new MixinTestBuilder()
|
{
|
TestMember = nameof(step1.DelaySecs)
|
});
|
var memberMenuModel = new MixinMemberMenuModel(mixinMember)
|
{
|
Source = new object[]{step1}
|
};
|
using (Session.Create(SessionOptions.None))
|
{
|
UserInput.SetInterface(new UserInputOverride());
|
|
// previously this would have thrown an exception
|
// because the mixin does not allow itself to be defined twice.
|
// this was really only because we added the new one before removing the old.
|
memberMenuModel.ModifyMixin();
|
}
|
}
|
|
public class SimpleOutputStep : TestStep
|
{
|
[Output]
|
public double Output { get; set; }
|
public override void Run()
|
{
|
|
}
|
}
|
|
[Test]
|
public void MixinAsInput()
|
{
|
var plan = new TestPlan();
|
var step1 = new SimpleOutputStep();
|
var step2 = new SequenceStep();
|
plan.ChildTestSteps.Add(step1);
|
plan.ChildTestSteps.Add(step2);
|
|
var mixinMember = MixinFactory.LoadMixin(step2, new TestNumberMixinBuilder()
|
{
|
Name = "Number"
|
});
|
|
InputOutputRelation.Assign(step2, mixinMember, step1, TypeData.GetTypeData(step1).GetMember(nameof(step1.Output)));
|
var s = new TapSerializer().SerializeToString(plan);
|
var i1 = s.IndexOf("OpenTap.UnitTests.TestNumberMixinBuilder", StringComparison.Ordinal);
|
var i2 = s.IndexOf("OpenTap.UnitTests.TestNumberMixinBuilder", i1 + 1, StringComparison.Ordinal);
|
// the xml should only contain the once.
|
// this means it is included at least two times.
|
Assert.IsTrue(i1 != -1);
|
Assert.IsTrue(i2 == -1);
|
}
|
|
[Test]
|
[TestCase(HandleExceptionDialog.Options.Abort, Verdict.Aborted)]
|
[TestCase(HandleExceptionDialog.Options.Retry, Verdict.Pass)]
|
[TestCase(HandleExceptionDialog.Options.Continue, Verdict.Error)]
|
public void TestUnhandledExceptionMixin(HandleExceptionDialog.Options behavior, Verdict expectedVerdict)
|
{
|
using var session = Session.Create(SessionOptions.OverlayComponentSettings);
|
var userInput = new UnhandledMixinUserInputHandler(behavior);
|
UserInput.SetInterface(userInput);
|
var plan = new TestPlan();
|
var step = new ThrowingStep() { Throws = true };
|
plan.ChildTestSteps.Add(step);
|
var mixin = MixinFactory.LoadMixin(step, new TestUnhandledExceptionMixinBuilder());
|
var run = plan.Execute();
|
Assert.That(run.Verdict, Is.EqualTo(expectedVerdict));
|
}
|
|
|
|
class ExecutedStep : TestStep
|
{
|
|
public bool Executed;
|
public override void Run()
|
{
|
Executed = true;
|
}
|
}
|
class PreJumpSkipStep : ExecutedStep
|
{
|
public class JumpMixin : ITestStepPreRunMixin
|
{
|
|
public ITestStep NextStep;
|
public void OnPreRun(TestStepPreRunEventArgs eventArgs)
|
{
|
eventArgs.TestStep.StepRun.SuggestedNextStep = NextStep.Id;
|
}
|
}
|
[EmbedProperties]
|
public JumpMixin Jump { get; } = new JumpMixin();
|
}
|
|
class ExceptionPreMixinStep : ExecutedStep
|
{
|
public class ExceptionMixin : ITestStepPreRunMixin
|
{
|
public void OnPreRun(TestStepPreRunEventArgs eventArgs)
|
{
|
eventArgs.TestStep.StepRun.Exception = new Exception("!!");
|
}
|
}
|
[EmbedProperties]
|
public ExceptionMixin Exception { get; } = new ExceptionMixin();
|
}
|
|
[Test]
|
public void TestMixinPreJumpToStep()
|
{
|
var step1 = new PreJumpSkipStep();
|
var step2 = new ExecutedStep();
|
var step3 = new ExecutedStep();
|
var step4 = new ExecutedStep();
|
step1.Jump.NextStep = step3;
|
var plan = new TestPlan();
|
plan.ChildTestSteps.AddRange([step1, step2, step3, step4]);
|
plan.Execute();
|
Assert.IsFalse(step1.Executed);
|
Assert.IsFalse(step2.Executed);
|
Assert.IsTrue(step3.Executed);
|
Assert.IsTrue(step4.Executed);
|
}
|
|
[Test]
|
public void TestMixinExceptionPreStep()
|
{
|
var step1 = new ExceptionPreMixinStep();
|
var step2 = new ExecutedStep();
|
var step3 = new ExecutedStep();
|
var plan = new TestPlan();
|
plan.ChildTestSteps.AddRange([step1, step2, step3]);
|
var run = plan.Execute();
|
Assert.IsFalse(step1.Executed);
|
Assert.IsFalse(step2.Executed);
|
Assert.IsFalse(step3.Executed);
|
Assert.AreEqual(Verdict.Error, run.Verdict);
|
}
|
|
|
}
|
|
public class MixinTest : IMixin, ITestStepPostRunMixin, ITestStepPreRunMixin, IAssignOutputMixin
|
{
|
public bool OnPostRunCalled { get; set; }
|
public bool OnPreRunCalled { get; set; }
|
public bool OnAssignOutputCalled { get; set; }
|
public string OutputStringValue { get; set; }
|
|
[Browsable(true)]
|
public string MixinLoadValue { get; }
|
|
public MixinTest(string loadValue) => MixinLoadValue = loadValue;
|
|
public void OnPostRun(TestStepPostRunEventArgs eventArgs)
|
{
|
OnPostRunCalled = true;
|
}
|
public void OnPreRun(TestStepPreRunEventArgs eventArgs)
|
{
|
OnPreRunCalled = true;
|
}
|
public void OnAssigningOutput(AssignOutputEventArgs args)
|
{
|
OnAssignOutputCalled = true;
|
OutputStringValue = args.Value.ToString();
|
}
|
}
|
|
[MixinBuilder(typeof(ITestStepParent))]
|
public class MixinTestBuilder : ValidatingObject, IMixinBuilder
|
{
|
public MixinTestBuilder()
|
{
|
Rules.Add(() => TestMember != null, "Test member must not be null.", nameof(TestMember));
|
}
|
|
public string TestMember { get; set; }
|
public void Initialize(ITypeData targetType)
|
{
|
|
}
|
public MixinMemberData ToDynamicMember(ITypeData targetType)
|
{
|
if (!string.IsNullOrWhiteSpace(Error))
|
throw new Exception($"{Error}");
|
// targetType is wrapped in an EmbeddedMember data object that hides TestMixin on the outside.
|
if (targetType.BaseType.GetMember("TestMixin") != null)
|
{
|
throw new Exception("Target type already has a TestMixin member.");
|
}
|
return new MixinMemberData(this, () => new MixinTest(TestMember))
|
{
|
TypeDescriptor = TypeData.FromType(typeof(MixinTest)),
|
Attributes = GetAttributes().ToArray(),
|
Writable = true,
|
Readable = true,
|
DeclaringType = targetType,
|
Name = "TestMixin"
|
};
|
}
|
|
IEnumerable<Attribute> GetAttributes()
|
{
|
yield return new EmbedPropertiesAttribute();
|
yield return new DisplayAttribute("Test Mixin", Order: 19999);
|
}
|
}
|
|
[MixinBuilder(typeof(ITestStepParent))]
|
public class TestNumberMixinBuilder : ValidatingObject, IMixinBuilder
|
{
|
public string Name { get; set; }
|
public bool IsOutput { get; set; }
|
public TestNumberMixinBuilder()
|
{
|
|
}
|
|
public void Initialize(ITypeData targetType)
|
{
|
|
}
|
public MixinMemberData ToDynamicMember(ITypeData targetType)
|
{
|
return new MixinMemberData(this, () => 0.0)
|
{
|
TypeDescriptor = TypeData.FromType(typeof(double)),
|
Attributes = GetAttributes().ToArray(),
|
Writable = true,
|
Readable = true,
|
DeclaringType = targetType,
|
Name = "Number." + Name
|
};
|
}
|
|
IEnumerable<Attribute> GetAttributes()
|
{
|
yield return new DisplayAttribute(Name, Order: 19999);
|
|
if (IsOutput)
|
yield return new OutputAttribute();
|
}
|
}
|
|
[Display("Unhandled Exception")]
|
public class HandleExceptionDialog
|
{
|
public enum Options
|
{
|
[Display("Continue")]
|
Continue,
|
[Display("Retry Failed Step")]
|
Retry,
|
[Display("Abort Sequence")]
|
Abort,
|
}
|
|
private readonly Exception ex;
|
private readonly string stepName;
|
public HandleExceptionDialog(string stepName, Exception ex)
|
{
|
this.ex = ex;
|
this.stepName = stepName;
|
}
|
|
[Browsable(true)]
|
[Layout(LayoutMode.FullRow)]
|
public string Message => $"Error in step {stepName}: {ex.Message}";
|
|
[Submit]
|
[Layout(LayoutMode.FullRow | LayoutMode.FloatBottom)]
|
[Display("Continue Behavior")]
|
public Options HandlingOption { get; set; }
|
}
|
|
|
public class ThrowingStep : TestStep
|
{
|
public bool Throws { get; set; } = true;
|
public override void Run()
|
{
|
if (Throws)
|
{
|
throw new Exception("Something went wrong");
|
}
|
UpgradeVerdict(Verdict.Pass);
|
}
|
}
|
|
[MixinBuilder(typeof(ITestStepParent))]
|
[Display("Handle Exceptions")]
|
public class TestUnhandledExceptionMixinBuilder : IMixinBuilder
|
{
|
public void Initialize(ITypeData targetType)
|
{
|
|
}
|
|
public MixinMemberData ToDynamicMember(ITypeData targetType)
|
{
|
return new MixinMemberData(this, () => new ExceptionMixin())
|
{
|
TypeDescriptor = TypeData.FromType(typeof(ExceptionMixin)),
|
Writable = true,
|
Readable = true,
|
DeclaringType = targetType,
|
Attributes = [new EmbedPropertiesAttribute()],
|
Name = "On Exception",
|
};
|
}
|
}
|
|
public class UnhandledMixinUserInputHandler(HandleExceptionDialog.Options behavior) : IUserInputInterface
|
{
|
public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
|
{
|
if (dataObject is HandleExceptionDialog h)
|
{
|
h.HandlingOption = behavior;
|
}
|
}
|
}
|
|
[Display("On Exception")]
|
public class ExceptionMixin : IMixin, ITestStepPostRunMixin
|
{
|
[Display("Handle Exception")] public bool HandleException { get; set; } = true;
|
|
public void OnPostRun(TestStepPostRunEventArgs eventArgs)
|
{
|
if (!HandleException) return;
|
if (TapThread.Current.AbortToken.IsCancellationRequested)
|
return;
|
var step = eventArgs.TestStep;
|
var run = step.StepRun;
|
var exception = run.Exception;
|
if (exception == null) return;
|
|
|
var handling = new HandleExceptionDialog(step.GetFormattedName(),exception);
|
UserInput.Request(handling, true);
|
switch (handling.HandlingOption)
|
{
|
case HandleExceptionDialog.Options.Abort:
|
step.PlanRun.MainThread.Abort();
|
break;
|
case HandleExceptionDialog.Options.Continue:
|
// do nothing
|
break;
|
case HandleExceptionDialog.Options.Retry:
|
// Ensure that the step will not throw after retry
|
(step as ThrowingStep).Throws = false;
|
run.Exception = null;
|
run.SuggestedNextStep = run.TestStepId;
|
break;
|
}
|
}
|
}
|
}
|
