/**********************************************************************/
#region Constructors
internal ReadOnlyTestResult(ITestObjectFactory testObjectFactory, TestResult testResult)
{
if (testObjectFactory == null)
{
throw new ArgumentNullException(nameof(testObjectFactory));
}
if (testResult == null)
{
throw new ArgumentNullException(nameof(testResult));
}
if (testResult.TestCase == null)
{
throw new ArgumentException($"{nameof(testResult.TestCase)} cannot be null", nameof(testResult));
}
TestCase = testObjectFactory.TranslateTestCase(testResult.TestCase);
DisplayName = testResult.DisplayName;
ComputerName = testResult.ComputerName;
Outcome = testResult.Outcome;
StartTime = testResult.StartTime;
EndTime = testResult.EndTime;
Duration = testResult.Duration;
Messages = new ReadOnlyCollection <TestResultMessage>(testResult.Messages);
ErrorMessage = testResult.ErrorMessage;
ErrorStackTrace = testResult.ErrorStackTrace;
Attachments = new ReadOnlyCollection <AttachmentSet>(testResult.Attachments);
Traits = new ReadOnlyCollection <Trait>(testResult.Traits.ToArray());
}
public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
: base(factory) {
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.transactionManager = transactionManager;
NakedObject = nakedObjectAdapter;
}
public TestProperty(IObjectPersistor persistor, IAssociationSpec field, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager) {
this.persistor = persistor;
this.field = field;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
}
public TestProperty(IObjectPersistor persistor, IAssociationSpec field, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager)
{
this.persistor = persistor;
this.field = field;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
}
public ParentPage(IBasePage basePage)
{
BasePage = basePage;
ToolDependencyResolver = basePage.GetToolDependencyResolver();
Resolver = basePage.GetResolver();
TestObjectFactory = ToolDependencyResolver.Resolve <ITestObjectFactory>(basePage.GetBrowser());
}
public TestAction(INakedObjectsFramework framework, string contributor, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory)
{
SubMenu = contributor;
this.framework = framework;
this.owningObject = owningObject;
this.factory = factory;
this.actionSpec = actionSpec;
}
public ITestObject GetParentItem()
{
ITestObjectLocator parentObjectLocator = Resolver.Resolve <ITestObjectLocator>(Locator.XPath,
GetParentElementXPath(GetAutomationElement()));
ITestObjectFactory toFactory = Resolver.Resolve <ITestObjectFactory>(browser);
return(toFactory.Get(parentObjectLocator));
}
public ITestObject GetInputChildObject()
{
ITestObjectLocator inputObjectLocator = Resolver.Resolve <ITestObjectLocator>(Locator.TagName, "input");
ITestObjectLocator inputChildTestObjectLocator = Resolver.Resolve <ITestObjectLocator>(Locator.XPath,
GetXPathTo(GetChildAutomationElementMatchingWith(inputObjectLocator)));
ITestObjectFactory toFactory = Resolver.Resolve <ITestObjectFactory>(browser);
return(toFactory.Get(inputChildTestObjectLocator));
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, string contributor, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager)
{
SubMenu = contributor;
this.metamodelManager = metamodelManager;
this.session = session;
this.lifecycleManager = lifecycleManager;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
this.actionSpec = actionSpec;
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, ITransactionManager transactionManager, string contributor, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager, IMessageBroker messageBroker) {
SubMenu = contributor;
this.metamodelManager = metamodelManager;
this.session = session;
this.lifecycleManager = lifecycleManager;
this.transactionManager = transactionManager;
this.messageBroker = messageBroker;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
this.actionSpec = actionSpec;
}
public ITestObject GetChildTestObject(ITestObject to)
{
if (GetChildAutomationElementMatchingWith(to.TestObjectLocator) != null)
{
ITestObjectLocator childObjectLocator = Resolver.Resolve <ITestObjectLocator>(Locator.XPath,
GetXPathTo(GetChildAutomationElementMatchingWith(to.TestObjectLocator)));
ITestObjectFactory toFactory = Resolver.Resolve <ITestObjectFactory>(browser);
return(toFactory.Get(childObjectLocator));
}
return(null);
}
public ITestObject GetChildItem(int itemNumber, string tagName)
{
ITestObjectLocator objectLocator = Resolver.Resolve <ITestObjectLocator>(Locator.TagName,
tagName);
ITestObjectLocator childObjectLocator = Resolver.Resolve <ITestObjectLocator>(Locator.XPath,
GetXPathTo(GetChildAutomationElementsMatchingWith(objectLocator)[itemNumber - 1]));
ITestObjectFactory toFactory = Resolver.Resolve <ITestObjectFactory>(browser);
return(toFactory.Get(childObjectLocator));
}
public List <ITestObject> GetAllMatchingTestObjects()
{
List <ITestObject> testObjectList = new List <ITestObject>();
ITestObjectFactory factory = Resolver.Resolve <ITestObjectFactory>(browser);
foreach (var element in GetAutomationElements())
{
string locatorValue = GetXPathTo(element);
testObjectList.Add(factory.Get(Locator.XPath, locatorValue));
}
return(testObjectList);
}
public void LookupMethodMultiple()
{
RootObjectDefinition feedDef = new RootObjectDefinition(typeof(NewsFeed));
feedDef.IsSingleton = false;
feedDef.PropertyValues.Add("name", "Bingo");
RootObjectDefinition testObjectDef = new RootObjectDefinition(typeof(TestObject));
testObjectDef.IsSingleton = false;
testObjectDef.PropertyValues.Add("name", "Miki Nakatani");
RootObjectDefinition managerDef = new RootObjectDefinition(typeof(TestObjectAndNewsFeedFactory));
managerDef.MethodOverrides.Add(new LookupMethodOverride("CreateNewsFeed", "feed"));
managerDef.MethodOverrides.Add(new LookupMethodOverride("CreateTestObject", "test"));
DefaultListableObjectFactory factory = new DefaultListableObjectFactory();
factory.RegisterObjectDefinition("manager", managerDef);
factory.RegisterObjectDefinition("feed", feedDef);
factory.RegisterObjectDefinition("test", testObjectDef);
TestObjectAndNewsFeedFactory manager = (TestObjectAndNewsFeedFactory)factory["manager"];
INewsFeedManager newsFeedManager = manager;
NewsFeed feed1 = newsFeedManager.CreateNewsFeed();
Assert.IsNotNull(feed1, "The CreateNewsFeed() method is not being replaced.");
NewsFeed feed2 = newsFeedManager.CreateNewsFeed();
// assert that the object (prototype) is definitely being looked up each time...
Assert.IsFalse(ReferenceEquals(feed1, feed2));
ITestObjectFactory toFactory = manager;
ITestObject to1 = toFactory.CreateTestObject();
Assert.IsNotNull(to1, "The CreateTestObject() method is not being replaced.");
ITestObject to2 = toFactory.CreateTestObject();
// assert that the object (prototype) is definitely being looked up each time...
Assert.IsFalse(ReferenceEquals(to1, to2));
}
/// <summary>
/// Creates Dummy parameter array for class instantiation through reflection.
/// </summary>
/// <param name="classType">Type of IQuery/ICommand (Validatable) class to be instantiated.</param>
/// <param name="domainObjectFactory">The domain object factory.</param>
/// <returns>
/// Dummy general parameter array for First() class constructor
/// </returns>
public static object[] CreateDummyParametersForType(Type classType, ITestObjectFactory domainObjectFactory = null)
{
// To supply specific parameters - add this method to your query class:
// private static object[] SupplyTestParameters()
// and return object array with all parameters with necessary values to be able to successfully test your query class.
MethodInfo parameterSettingMethod = classType.GetMethod(
"SupplyTestParameters",
BindingFlags.NonPublic | BindingFlags.Static);
if (parameterSettingMethod != null)
{
return(parameterSettingMethod.Invoke(null, null) as object[]);
}
// For majority of Query/Command classes...
// no specific parameters needed - compose necessary dummy parameters for Class instantiation (parameter values does not matter)
ParameterInfo[] parameterInfo = classType.GetConstructors()[0].GetParameters();
object[] parameters = new object[parameterInfo.Length];
for (int index = 0; index < parameterInfo.Length; index++)
{
if (parameterInfo[index].ParameterType.Name == "String")
{
// Handling cases when SQL Select may come in as parameter
parameters[index] =
parameterInfo[index].Name.IndexOf("QUERY", StringComparison.InvariantCultureIgnoreCase) > 0
? "SELECT Id FROM FormData"
: "123-ABC-456";
continue;
}
if (domainObjectFactory != null && domainObjectFactory.HasFakeFor(parameterInfo[index].ParameterType.FullName))
{
parameters[index] = domainObjectFactory.GetTestObject(parameterInfo[index].ParameterType);
continue;
}
// Checking whether it is collection
bool collectionTypeFound = false;
foreach (Type interfaceType in parameterInfo[index].ParameterType.GetInterfaces())
{
if (interfaceType.IsGenericType &&
interfaceType.GetGenericTypeDefinition() == typeof(IList <>))
{
Type itemType = parameterInfo[index].ParameterType.GetGenericArguments()[0];
Type listType = typeof(List <>).MakeGenericType(itemType);
parameters[index] = Activator.CreateInstance(listType);
collectionTypeFound = true;
break;
}
}
if (collectionTypeFound)
{
continue;
}
// Nullable class can easily be null
if (Nullable.GetUnderlyingType(parameterInfo[index].ParameterType) != null ||
parameterInfo[index].ParameterType.IsClass)
{
parameters[index] = null;
continue;
}
// Normal class - just create default instance of it.
if (parameterInfo[index].ParameterType.IsClass)
{
parameters[index] = Activator.CreateInstance(parameterInfo[index].ParameterType);
continue;
}
parameters[index] = parameterInfo[index].ParameterType.Name switch
{
"DateTime" => DateTime.Now,
"DateTimeOffset" => DateTimeOffset.Now,
"TimeSpan" => new TimeSpan(0, 0, 9, 59),
"Guid" => Guid.NewGuid(),
"Byte" => (byte)1,
"SByte" => (sbyte)1,
"Int32" => 1,
"Int16" => (short)1,
"Int64" => (long)1,
"UInt32" => (uint)1,
"UInt16" => (ushort)1,
"UInt64" => (ulong)1,
"Boolean" => false,
"Char" => 'c',
"Decimal" => 1M,
"Double" => 1D,
"float" => 1F,
"Single" => (float)1F,
_ => null,
};
}
return(parameters);
}
public TestParameter(INakedObjectAction action, INakedObjectActionParameter parameter, ITestHasActions owningObject, ITestObjectFactory factory) {
this.action = action;
this.parameter = parameter;
this.owningObject = owningObject;
this.factory = factory;
}
public TestService(object service, ITestObjectFactory factory) : base(factory) {
NakedObject = NakedObjectsContext.ObjectPersistor.GetAdapterFor(service);
}
public TestAction(string contributor, INakedObjectAction action, ITestHasActions owningObject, ITestObjectFactory factory) {
SubMenu = contributor;
this.owningObject = owningObject;
this.factory = factory;
this.action = action;
}
public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
: base(factory)
{
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.transactionManager = transactionManager;
NakedObject = nakedObjectAdapter;
}
private readonly ITestHasActions owningObject; //May be null if it is a MainMenu
public TestMenu(IMenuImmutable menu, ITestObjectFactory factory, ITestHasActions owningObject)
{
this.menu = menu;
this.factory = factory;
this.owningObject = owningObject;
}
public TestCollection(INakedObject collection, ITestObjectFactory factory) {
this.collection = collection;
wrappedCollection = collection.GetAsEnumerable().Select(factory.CreateTestObject);
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, ITransactionManager transactionManager, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager, IMessageBroker messageBroker)
: this(metamodelManager, session, lifecycleManager, transactionManager, string.Empty, actionSpec, owningObject, factory, manager, messageBroker)
{
}
private readonly ITestHasActions owningObject; //Non-null if this is on an objectMenu
public TestMenuItem(IMenuItemImmutable item, ITestObjectFactory factory, ITestHasActions owningObject)
{
this.item = item;
this.factory = factory;
this.owningObject = owningObject;
}
public FakeRepository(ITestObjectFactory testObjectFactory)
{
_factory = testObjectFactory;
}
public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
: base(factory)
{
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.transactionManager = transactionManager;
Log.DebugFormat("Created test object for {0}", nakedObjectAdapter);
NakedObject = nakedObjectAdapter;
}
public TestService(INakedObjectAdapter service, ITestObjectFactory factory) : base(factory) => NakedObject = service;
public TestProperty(INakedObjectAssociation field, ITestHasActions owningObject, ITestObjectFactory factory) {
this.field = field;
this.owningObject = owningObject;
this.factory = factory;
}
public TestParameter(IActionParameterSpec parameterSpec, ITestHasActions owningObject, ITestObjectFactory factory) {
this.parameterSpec = parameterSpec;
this.owningObject = owningObject;
this.factory = factory;
}
public TestParameter(IActionParameterSpec parameterSpec, ITestHasActions owningObject, ITestObjectFactory factory)
{
this.parameterSpec = parameterSpec;
this.owningObject = owningObject;
this.factory = factory;
}
protected TestHasActions(ITestObjectFactory factory)
{
this.factory = factory;
}
protected TestHasActions(ITestObjectFactory factory) {
this.factory = factory;
}
public TestService(INakedObjectAdapter service, ITestObjectFactory factory) : base(factory) {
NakedObject = service;
}
public TestCollection(INakedObject collection, ITestObjectFactory factory, INakedObjectManager manager)
{
this.collection = collection;
wrappedCollection = collection.GetAsEnumerable(manager).Select(factory.CreateTestObject);
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, ITransactionManager transactionManager, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager, IMessageBroker messageBroker)
: this(metamodelManager, session, lifecycleManager, transactionManager, string.Empty, actionSpec, owningObject, factory, manager, messageBroker) {}
public TestAction(INakedObjectsFramework framework, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory)
: this(framework, string.Empty, actionSpec, owningObject, factory)
{
}
private readonly ITestHasActions owningObject; //Non-null if this is on an objectMenu
public TestMenuItem(IMenuItemImmutable item, ITestObjectFactory factory, ITestHasActions owningObject) {
this.item = item;
this.factory = factory;
this.owningObject = owningObject;
}
public TestService(INakedObject service, ITestObjectFactory factory) : base(factory)
{
NakedObject = service;
}
private readonly ITestHasActions owningObject; //May be null if it is a MainMenu
public TestMenu(IMenuImmutable menu, ITestObjectFactory factory, ITestHasActions owningObject) {
this.menu = menu;
this.factory = factory;
this.owningObject = owningObject;
}
public TestAction(INakedObjectAction action, ITestHasActions owningObject, ITestObjectFactory factory)
: this(string.Empty, action, owningObject, factory) {}
protected TestHasActions(ITestObjectFactory factory) => Factory = factory;
public TestObject(INakedObject nakedObject, ITestObjectFactory factory)
: base(factory) {
LOG.DebugFormat("Created test object for {0}", nakedObject);
NakedObject = nakedObject;
}
public TestCollection(INakedObjectAdapter collection, ITestObjectFactory factory, INakedObjectManager manager) {
this.collection = collection;
wrappedCollection = collection.GetAsEnumerable(manager).Select(factory.CreateTestObject);
}
/**********************************************************************/
#region Constructors
// If you think you need to use this, and you're not a Factory or Unit Test, you're wrongc
internal TestResultManager(IFileSystem fileSystem, ITestCaseDiscoveryManager discoveryManager, ITestObjectFactory testObjectFactory)
{
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
_discoveryManager = discoveryManager ?? throw new ArgumentNullException(nameof(discoveryManager));
_testObjectFactory = testObjectFactory ?? throw new ArgumentNullException(nameof(testObjectFactory));
// PENDING: Need to write an IReadOnlyCollection class that can take a HashSet, and/or write IReadOnlySet and implement that.
// ReadOnlyCollection requires IList, due to legacy implementations, and when the new ReadOnly interfaces were added, they didn't
// implement any ReadOnly class that can wrap a HashSet. Goddamnit.
SourceAssemblyPaths = _sourceAssemblyPaths;
_discoveryManager.TestCasesDiscovered += OnTestCasesDiscovered;
_discoveryManager.DiscoveryCompleted += OnDiscoveryComplete;
}
