/**********************************************************************/ #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; }