public void SubsetMandatory_1a(Store store) { myTestServices.LogValidationErrors("No Errors Found Initially"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; Role role_2 = (Role)store.ElementDirectory.GetElement(new Guid("82DF5594-2020-4CA3-8154-FD92EE83F726")); myTestServices.LogValidationErrors("Intoduce Error: Make a role of supertype mandatory"); using (Transaction t = store.TransactionManager.BeginTransaction("Add simple mandatory constraint")) { role_2.IsMandatory = true; t.Commit(); } myTestServices.LogValidationErrors("Error Found. Calling Undo to remove error..."); store.UndoManager.Undo(); myTestServices.LogValidationErrors("Error removed with undo."); myTestServices.LogValidationErrors("Intoduce Error: Make a role of subtype mandatory"); using (Transaction t = store.TransactionManager.BeginTransaction("Add simple mandatory constraint")) { role_2.IsMandatory = true; t.Commit(); } myTestServices.LogValidationErrors("Error Found. Calling Undo to remove error..."); using (Transaction t = store.TransactionManager.BeginTransaction("Add simple mandatory constraint")) { role_2.IsMandatory = false; t.Commit(); } myTestServices.LogValidationErrors("Error is removed with changing property value..."); }
public void FCMinMaxTest2a(Store store) { myTestServices.LogValidationErrors("Before adding error"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; FrequencyConstraint constraint = (FrequencyConstraint)model.ConstraintsDictionary.GetElement("FrequencyConstraint1").SingleElement; int min = constraint.MinFrequency; int max = constraint.MaxFrequency; using (Transaction t = store.TransactionManager.BeginTransaction("Fix Constraint")) { //Make the error constraint.MinFrequency = max; constraint.MaxFrequency = min; t.Commit(); } myTestServices.LogValidationErrors("After adding error"); }
public void DTBlankTest2a(Store store) { myTestServices.LogValidationErrors("Before adding error"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; model.Store.ElementDirectory.FindElement(UnspecifiedDataType.DomainClassId); UnspecifiedDataType unspecified = model.Store.ElementDirectory.FindElements <UnspecifiedDataType>()[0]; ObjectType o = (ObjectType)model.ObjectTypesDictionary.GetElement("WifeId").SingleElement; using (Transaction t = store.TransactionManager.BeginTransaction("Add invalid data type error")) { //Make the error o.DataType = unspecified; t.Commit(); } myTestServices.LogValidationErrors("After adding error"); }
public void PopulationSampleTest(Store store) { myTestServices.LogValidationErrors("Expect V2=100 Population Mandatory"); myTestServices.LogMessage("Testing IsIndependent and PopulationMandatoryError associated with implied mandatory constraint"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; ObjectType v2 = (ObjectType)model.ObjectTypesDictionary.GetElement("V2").SingleElement; using (Transaction t = store.TransactionManager.BeginTransaction("Set IsIndependent")) { v2.IsIndependent = true; t.Commit(); } myTestServices.LogValidationErrors("Set IsIndependent, No error expected after explicit transaction"); store.UndoManager.Undo(); DomainTypeDescriptor.CreatePropertyDescriptor(v2, ObjectType.IsIndependentDomainPropertyId).SetValue(v2, true); myTestServices.LogValidationErrors("Set IsIndependent, No error expected after implicit transaction"); store.UndoManager.Undo(); myTestServices.LogMessage("Testing PopulationMandatoryError by turning on a SimpleMandatory constraint."); RoleBase rightRole = v2.PlayedRoleCollection[0]; RoleBase leftRole = rightRole.OppositeRole; FactType factType = rightRole.FactType; ObjectType populateMe = leftRole.Role.RolePlayer; LinkedElementCollection <ObjectTypeInstance> populateMeInstances = populateMe.ObjectTypeInstanceCollection; LinkedElementCollection <ObjectTypeInstance> v2Instances = v2.ObjectTypeInstanceCollection; using (Transaction t = store.TransactionManager.BeginTransaction("Set IsMandatory")) { leftRole.Role.IsMandatory = true; t.Commit(); } myTestServices.LogValidationErrors("Set IsMandatory, expect new errors for instances 'Tom' and 'Dick'"); FactTypeInstance factTypeInstance; using (Transaction t = store.TransactionManager.BeginTransaction("Populate first row")) { factTypeInstance = new FactTypeInstance(store); factTypeInstance.FactType = factType; new FactTypeRoleInstance(leftRole.Role, populateMeInstances[0]).FactTypeInstance = factTypeInstance; new FactTypeRoleInstance(rightRole.Role, v2Instances[0]).FactTypeInstance = factTypeInstance; t.Commit(); } myTestServices.LogMessage("Adding second population row one role at a time"); myTestServices.LogValidationErrors("Add a complete FactTypeInstance for Tom, 1 error remaining for 'Dick'"); using (Transaction t = store.TransactionManager.BeginTransaction("Populate second row")) { factTypeInstance = new FactTypeInstance(store); factTypeInstance.FactType = factType; new FactTypeRoleInstance(leftRole.Role, populateMeInstances[1]).FactTypeInstance = factTypeInstance; t.Commit(); } myTestServices.LogValidationErrors("Add a partial FactTypeInstance for Dick, 1 error remaining for partial FactTypeInstance"); using (Transaction t = store.TransactionManager.BeginTransaction("Finish second row populations")) { new FactTypeRoleInstance(rightRole.Role, v2Instances[0]).FactTypeInstance = factTypeInstance; t.Commit(); } }
public void NMinus1Test2a(Store store) { myTestServices.LogValidationErrors("Before adding error"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; FactType fact = (FactType)store.ElementDirectory.GetElement(new Guid("655E4D9B-9835-4BE2-A7BC-FEBE51A32E84")); LinkedElementCollection <RoleBase> roles = fact.RoleCollection; using (Transaction t = store.TransactionManager.BeginTransaction("Fix Constraint")) { foreach (UniquenessConstraint constraint in fact.GetInternalConstraints <UniquenessConstraint>()) { //Make the error constraint.RoleCollection.Clear(); constraint.RoleCollection.Add(roles[0].Role); break; } t.Commit(); } myTestServices.LogValidationErrors("After adding error"); }
public void Test1(Store store) { // The store has been preloaded at this point with the .orm file specified in the // Tests.Test1.Compare.orm resource embedded into this project. If an embedded resource // is not found with this name, then a new orm file is created by loading the default // 'ORM Model File' template. This creates a model called 'NewModel' with a single diagram // attached to it. // Dump a report of the current model validation errors. The loaded file is missing an // internal constraint on a fact type, so we expect errors myTestServices.LogValidationErrors("Before constraint repair"); // Find the fact that that needs fixing and repair it //ORMModel model = (ORMModel)store.ElementDirectory.GetElement(ORMModel.DomainClassId); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; FactType fact = (FactType)store.ElementDirectory.GetElement(new Guid("CB33E377-9ADC-46BA-8E1B-24AE46BC0854")); Role role = fact.RoleCollection[1].Role; // At this point, we either need to open a transaction on the store with // using (Transaction t = store.TransactionManager.BeginTransaction("Transaction name")) // or we grab the property descriptor, which emulates setting the property through the // property grid and pushes a transaction for us. DomainTypeDescriptor.CreatePropertyDescriptor(role, Role.MultiplicityDomainPropertyId).SetValue(role, RoleMultiplicity.ExactlyOne); // Turn the following code back on to demonstrate a comparison failure // ~~ outdated code, do not turn on ~~// //fact = (FactType)model.FactTypesDictionary.GetElement("FactType2").SingleElement; //fact.CreatePropertyDescriptor(store.MetaDataDirectory.FindMetaAttribute(NamedElement.NameMetaAttributeGuid), fact).SetValue(fact, "changeFactType2"); // ~~ /outdated code, do not turn on ~~// // After the method exits, the Compare and LogValidationErrors methods will be run automatically against // the test service. The expected results for the Compare are in Tests.Test1.Compare.orm. You can also // compare at intermediate stages by explicitly running the IORMToolTestServices.Compare function, generally // with a reference name to distinguish the intermediate stages from the automatic comparison. }
public void ExactlyOneTest1a(Store store) { myTestServices.LogValidationErrors("No errors expected"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; FrequencyConstraint constraint = (FrequencyConstraint)model.ConstraintsDictionary.GetElement("TestFrequency").SingleElement; DomainTypeDescriptor.CreatePropertyDescriptor(constraint, FrequencyConstraint.MaxFrequencyDomainPropertyId).SetValue(constraint, 1); myTestServices.LogValidationErrors("Error introduced"); using (Transaction t = store.TransactionManager.BeginTransaction("Read the error")) { constraint.MinFrequency = 3; constraint.MaxFrequency = 4; t.Commit(); } myTestServices.LogValidationErrors("Error cleared with code"); store.UndoManager.Undo(); ((IORMToolServices)store).ModelErrorActivationService.ActivateError(constraint, constraint.FrequencyConstraintExactlyOneError); myTestServices.LogValidationErrors("Fixing error with error activation service"); }
public void ConstContradictTests_1a(Store store) { myTestServices.LogValidationErrors("ExclusionContradictsEqualityError exists"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; ExclusionConstraint constraint = (ExclusionConstraint)model.ConstraintsDictionary.GetElement("ExConstraint").FirstElement; myTestServices.LogValidationErrors("Removing Exclusion Constraint"); using (Transaction t = store.TransactionManager.BeginTransaction("Remove Ex Constraint")) { constraint.Delete(); t.Commit(); } myTestServices.LogValidationErrors("Error Removed"); }
public void ResolvePreferredTest1(Store store) { IElementDirectory directory = store.ElementDirectory; SubtypeFact FiveToTwo = (SubtypeFact)directory.GetElement(new Guid("9B85CC3F-FAA1-485B-A6CA-DE65165C6AE5")); SubtypeFact FiveToThree = (SubtypeFact)directory.GetElement(new Guid("C48F356A-DC20-4CD8-AD6A-EE4518622FFB")); SubtypeFact SixToFive = (SubtypeFact)directory.GetElement(new Guid("321CD412-8DAA-4D35-8D4E-D8D5915F07E0")); SubtypeFact SixToSeven = (SubtypeFact)directory.GetElement(new Guid("D6A4C2F2-3F99-4E2F-AB2F-407E03AB6F42")); SubtypeFact FiveToFour = (SubtypeFact)directory.GetElement(new Guid("DE1FC770-19A5-4CA9-AEF7-CE1204D80270")); SubtypeFact SevenToFour = (SubtypeFact)directory.GetElement(new Guid("71D29425-481E-445B-8F8A-63E9F29F761A")); ORMModel model = FiveToTwo.Model; RoleValueConstraint valueConstraint = (RoleValueConstraint)model.ConstraintsDictionary.GetElement("RoleValueConstraint1").SingleElement; myTestServices.LogValidationErrors("Expected three initial errors"); myTestServices.LogMessage("Scenario 1: Make 5->2 preferred path, sibling and downstream subtypes should all be preferred"); DomainTypeDescriptor.CreatePropertyDescriptor(FiveToTwo, SubtypeFact.ProvidesPreferredIdentifierDomainPropertyId).SetValue(FiveToTwo, true); myTestServices.LogValidationErrors("No errors expected"); myTestServices.LogMessage("5->4, 6->5, 6->7 are on the preferred path: " + (FiveToFour.ProvidesPreferredIdentifier && SixToFive.ProvidesPreferredIdentifier && SixToSeven.ProvidesPreferredIdentifier).ToString()); myTestServices.LogMessage("ValueConstraint should be a string type: " + valueConstraint.Text); myTestServices.LogMessage("Scenario 2: Make 5->3 preferred path, downstream subtypes are no ambiguous"); DomainTypeDescriptor.CreatePropertyDescriptor(FiveToThree, SubtypeFact.ProvidesPreferredIdentifierDomainPropertyId).SetValue(FiveToThree, true); myTestServices.LogValidationErrors("Two errors expected"); myTestServices.LogMessage("5->2, 5->4, 6->5, 6->7 are not preferred: " + (!(FiveToTwo.ProvidesPreferredIdentifier || FiveToFour.ProvidesPreferredIdentifier || SixToFive.ProvidesPreferredIdentifier || SixToSeven.ProvidesPreferredIdentifier)).ToString()); myTestServices.LogMessage("Scenario 3: Make 6->5 preferred path"); DomainTypeDescriptor.CreatePropertyDescriptor(SixToFive, SubtypeFact.ProvidesPreferredIdentifierDomainPropertyId).SetValue(SixToFive, true); myTestServices.LogValidationErrors("No errors expected"); myTestServices.LogMessage("6->7 is not on the preferred path: " + (!SixToSeven.ProvidesPreferredIdentifier).ToString()); myTestServices.LogMessage("ValueConstraint should be a number type: " + valueConstraint.Text); myTestServices.LogMessage("Scenario 4: Make 6->7 preferred path"); DomainTypeDescriptor.CreatePropertyDescriptor(SixToSeven, SubtypeFact.ProvidesPreferredIdentifierDomainPropertyId).SetValue(SixToSeven, true); myTestServices.LogValidationErrors("No errors expected"); myTestServices.LogMessage("6->5 is not on the preferred path: " + (!SixToFive.ProvidesPreferredIdentifier).ToString()); myTestServices.LogMessage("ValueConstraint should be a string type: " + valueConstraint.Text); myTestServices.LogMessage("Scenario 5: Delete 7->4 to break subtype structure"); using (Transaction t = store.TransactionManager.BeginTransaction("Break graph")) { SevenToFour.Delete(); t.Commit(); } myTestServices.LogValidationErrors("Expecting invalid graph, detached valuetype, and no reference scheme errors"); myTestServices.LogMessage("Scenario 6: Delete 6->5 to make graph valid"); using (Transaction t = store.TransactionManager.BeginTransaction("Graph OK")) { SixToFive.Delete(); t.Commit(); } myTestServices.LogValidationErrors("Expecting detached valuetype and no reference scheme errors"); myTestServices.LogMessage("Scenario 7: Set identifier on 7 to clear errors"); using (Transaction t = store.TransactionManager.BeginTransaction("Clear errors")) { SixToSeven.Supertype.ReferenceModeString = "id"; t.Commit(); } myTestServices.LogValidationErrors("No errors expected"); myTestServices.LogValidationErrors("Scenario 8: (Undo scenarios 5-7) Make 5->4 preferred path and give 4 an explicit id in one transaction"); store.UndoManager.Undo(); store.UndoManager.Undo(); store.UndoManager.Undo(); using (Transaction t = store.TransactionManager.BeginTransaction("Change id and make preferred in one transaction")) { // Note that doing this in the opposite order in two transactions has the same result FiveToFour.ProvidesPreferredIdentifier = true; FiveToFour.Supertype.ReferenceModeString = "id"; t.Commit(); } myTestServices.LogValidationErrors("No errors expected"); myTestServices.LogValidationErrors("Scenario 9: (Undo scenario 8) Make 5->4 preferred path then give 4 an explicit id to make 5 and 6 ambiguous"); store.UndoManager.Undo(); using (Transaction t = store.TransactionManager.BeginTransaction("Change preferred path")) { FiveToFour.ProvidesPreferredIdentifier = true; t.Commit(); } using (Transaction t = store.TransactionManager.BeginTransaction("Introduce id that interferes with split identifier path")) { FiveToFour.Supertype.ReferenceModeString = "id"; t.Commit(); } }
/// <summary> /// Run all tests for the given type that match the /// category filters specified for this suite /// </summary> /// <param name="testType">A type with a Test attribute</param> /// <param name="services">Services used to run the test. IORMToolTestServices can /// be retrieved from services.ServiceProvider.</param> /// <param name="suiteReport">The suite report callback</param> private void RunTests(Type testType, IORMToolServices services, IORMToolTestSuiteReport suiteReport) { IORMToolTestServices testServices = (IORMToolTestServices)services.ServiceProvider.GetService(typeof(IORMToolTestServices)); object testTypeInstance = null; object[] methodParams = null; MethodInfo[] methods = testType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); int methodCount = methods.Length; for (int i = 0; i < methodCount; ++i) { MethodInfo method = methods[i]; object[] testAttributes = method.GetCustomAttributes(typeof(ORMTestAttribute), false); Debug.Assert(testAttributes.Length < 2, "Single use attribute with inherit=false, should only pick up zero or one attributes"); // Make sure that the method is flagged as a Test method that can be run per the current category settings if (testAttributes.Length == 0 || !CheckCategoryFilters((ORMTestAttribute)testAttributes[0])) { continue; } // Make sure we've instantiated the test class if (testTypeInstance == null) { ConstructorInfo constructor; if (null != (constructor = testType.GetConstructor(new Type[] { typeof(IORMToolServices) }))) { testTypeInstance = constructor.Invoke(new object[] { services }); methodParams = new object[1]; } bool loadFailure = null == testTypeInstance; suiteReport.BeginTestClass(testType.Namespace, testType.Name, loadFailure); if (loadFailure) { return; } } ParameterInfo[] methodParamInfos = method.GetParameters(); if (!(methodParamInfos.Length == 1 && typeof(Store).IsAssignableFrom(methodParamInfos[0].ParameterType))) { // The test method does not match the signature we need, it should // not have been marked with the Test attribute suiteReport.ReportTestResults(method.Name, ORMTestResult.FailBind, null); } else { Store store = null; try { // Prepare the test services for a new test testServices.OpenReport(); // Populate a store. Automatically loads the starting // file from the test assembly if one is provided store = testServices.Load(method, null, null); // Run the method methodParams[0] = store; method.Invoke(testTypeInstance, methodParams); // Compare the current contents of the store with the // expected state testServices.Compare(store, method, null); testServices.LogValidationErrors(null); } finally { if (store != null) { ((IDisposable)store).Dispose(); } // Close the report and see if the report matches the expected results using (XmlReader reportReader = testServices.CloseReport(method)) { string methodName = method.Name; string resourceName = string.Concat(testType.FullName, ".", methodName, ".Report.xml"); Stream baselineStream = null; try { Assembly testAssembly = testType.Assembly; // Get the baseline that we're comparing to if (null != testAssembly.GetManifestResourceInfo(resourceName)) { baselineStream = testAssembly.GetManifestResourceStream(resourceName); } if (baselineStream != null) { bool hasDiff = false; // See if the data is different. XmlDiff diff = DiffEngine; XmlReaderSettings readerSettings = DetachableReaderSettings; XmlWriterSettings writerSettings = DetachableWriterSettings; using (MemoryStream diffStream = new MemoryStream()) { using (XmlReader baselineReader = XmlReader.Create(baselineStream, readerSettings)) { using (XmlWriter diffWriter = XmlWriter.Create(diffStream, writerSettings)) { hasDiff = !diff.Compare(baselineReader, reportReader, diffWriter); } } if (hasDiff) { // Record the diffgram in the suite report diffStream.Seek(0, SeekOrigin.Begin); using (XmlReader diffReader = XmlTextReader.Create(diffStream, readerSettings)) { suiteReport.ReportTestResults(methodName, ORMTestResult.FailReportDiffgram, diffReader); } } else { // Record a passing result suiteReport.ReportTestResults(methodName, ORMTestResult.Pass, null); } } } else { // Record the full report, we have no baseline to compare against suiteReport.ReportTestResults(methodName, ORMTestResult.FailReportBaseline, reportReader); } } finally { if (baselineStream != null) { ((IDisposable)baselineStream).Dispose(); } } } } } } }
public void EqualityMandatoryImplied_1a(Store store) { myTestServices.LogValidationErrors("No Errors Found Initialliy"); ORMModel model = store.ElementDirectory.FindElements <ORMModel>()[0]; Role role = (Role)store.ElementDirectory.GetElement(new Guid("1C424E34-8369-41EC-850F-FD24E7B30C7A")); using (Transaction t = store.TransactionManager.BeginTransaction("Add Mandatory Constraint")) { role.IsMandatory = true; t.Commit(); } myTestServices.LogValidationErrors("Error is Introduced"); store.UndoManager.Undo(); myTestServices.LogValidationErrors("Error is removed with Undo"); }