public void RelatedCatalogueTest_OneCatalogue(bool createExtractionInformation) { TableInfo t = new TableInfo(Repository, "MyTable"); ColumnInfo c = new ColumnInfo(Repository, "MyCol", "varchar(10)", t); Catalogue cata = new Catalogue(Repository, "MyCata"); CatalogueItem ci = new CatalogueItem(Repository, cata, "MyCataItem"); try { if (createExtractionInformation) { new ExtractionInformation(Repository, ci, c, "dbo.SomeFunc('Bob') as MySelectLine"); } else { ci.SetColumnInfo(c); } var catas = t.GetAllRelatedCatalogues(); Assert.AreEqual(1, catas.Length); Assert.AreEqual(cata, catas[0]); } finally { ci.DeleteInDatabase(); cata.DeleteInDatabase(); t.DeleteInDatabase(); } }
public void PreventDeletingCatalogueBecauseOfLinkedDatasetTest() { var obscura = new BetweenCatalogueAndDataExportObscureDependencyFinder(RepositoryLocator); var cata = new Catalogue(CatalogueRepository, "MyCata"); //catalogue exists in isolation so is deletable Assert.DoesNotThrow(()=>obscura.ThrowIfDeleteDisallowed(cata)); //there is a new dataset which is linked to Catalogue var dataset = new ExtractableDataSet(DataExportRepository,cata); //and suddenly we cannot delete the catalogue var ex = Assert.Throws<Exception>(() => obscura.ThrowIfDeleteDisallowed(cata)); Assert.IsTrue(ex.Message.Contains("Cannot delete Catalogue MyCata because there are ExtractableDataSets which depend on them ")); //also if we try to force through a delete it should behave in identical manner var ex2 = Assert.Throws<Exception>(cata.DeleteInDatabase); Assert.IsTrue(ex2.Message.Contains("Cannot delete Catalogue MyCata because there are ExtractableDataSets which depend on them ")); //now we delete the linked dataset dataset.DeleteInDatabase(); //and because there is now no longer a dataset dependency on the catalogue we can delete it Assert.DoesNotThrow(() => obscura.ThrowIfDeleteDisallowed(cata)); //and the delete works too cata.DeleteInDatabase(); //both objects still exist in memory of course but we should be able to see they have disapeared Assert.IsTrue(dataset.HasLocalChanges().Evaluation == ChangeDescription.DatabaseCopyWasDeleted); Assert.IsTrue(cata.HasLocalChanges().Evaluation == ChangeDescription.DatabaseCopyWasDeleted); }
public void update_changeAllPropertiesOfCatalogueItem_passes() { Catalogue parent = new Catalogue(CatalogueRepository, "KONGOR"); CatalogueItem child = new CatalogueItem(CatalogueRepository, parent, "KONGOR_SUPERKING") { Agg_method = "Adding SetUp", Comments = "do not change amagad super secret!", Limitations = "Extreme limitaitons", Description = "Exciting things are going down in the streets of new your this time of year it would be a great idea if you were to go there", Name = "KONGOR_MINIMAN", Periodicity = Catalogue.CataloguePeriodicity.Monthly, Research_relevance = "Highly relevant to all fields of subatomic particle study", Statistical_cons = "Dangerous cons frequent the areas that this stats is happening, be afraid", Topic = "nothing much, lots of stuff" }; child.SaveToDatabase(); CatalogueItem childAfter = CatalogueRepository.GetObjectByID <CatalogueItem>(child.ID); Assert.IsTrue(child.Name == childAfter.Name); Assert.IsTrue(child.Agg_method == childAfter.Agg_method); Assert.IsTrue(child.Comments == childAfter.Comments); Assert.IsTrue(child.Limitations == childAfter.Limitations); Assert.IsTrue(child.Description == childAfter.Description); Assert.IsTrue(child.Periodicity == childAfter.Periodicity); Assert.IsTrue(child.Research_relevance == childAfter.Research_relevance); Assert.IsTrue(child.Statistical_cons == childAfter.Statistical_cons); Assert.IsTrue(child.Topic == childAfter.Topic); child.DeleteInDatabase(); parent.DeleteInDatabase(); }
public void AddSameLinkTwice() { Catalogue predator = null; CatalogueItem lazor = null; TableInfo highEnergyTable = null; ColumnInfo velocityColumn = null; try { ///////////////Create the things that we are going to create relationships between ///////////////// predator = new Catalogue(CatalogueRepository, "Predator"); lazor = new CatalogueItem(CatalogueRepository, predator, "QuadlzorVelocity"); highEnergyTable = new TableInfo(CatalogueRepository, "HighEnergyShizzle"); velocityColumn = new ColumnInfo(CatalogueRepository, "Velocity Of Matter", "int", highEnergyTable); //now you can add as many links as you want, it just skips them lazor.SetColumnInfo(velocityColumn); Assert.AreEqual(lazor.ColumnInfo, velocityColumn); } finally { lazor.DeleteInDatabase(); //delete child predator.DeleteInDatabase(); //delete parent velocityColumn.DeleteInDatabase(); //delete child highEnergyTable.DeleteInDatabase(); //delete parent } }
public void AddLinkBetween_createNewLink_pass() { ///////////////Create the things that we are going to create relationships between ///////////////// var predator = new Catalogue(CatalogueRepository, "Predator"); var lazor = new CatalogueItem(CatalogueRepository, predator, "QuadlzorVelocity"); var highEnergyTable = new TableInfo(CatalogueRepository, "HighEnergyShizzle"); var velocityColumn = new ColumnInfo(CatalogueRepository, "Velocity Of Matter", "int", highEnergyTable); ////////////Check the creation worked ok Assert.IsNotNull(predator); //catalogue Assert.IsNotNull(lazor); Assert.IsNotNull(highEnergyTable); //underlying table stuff Assert.IsNotNull(velocityColumn); ////////////// Create links between stuff and check they were created successfully ////////////// //create a link between catalogue item lazor and velocity column lazor.SetColumnInfo(velocityColumn); Assert.IsTrue(lazor.ColumnInfo.ID == velocityColumn.ID); ////////////////cleanup ---- Delete everything that we created -------- ////////////// velocityColumn.DeleteInDatabase(); //delete causes CASCADE: CatalogueItem no longer associated with ColumnInfo because ColumnInfo died lazor.RevertToDatabaseState(); Assert.IsNull(lazor.ColumnInfo);//involves a database query so won't actually invalidate the below predator.DeleteInDatabase(); highEnergyTable.DeleteInDatabase(); }
public void GovernsCatalogue(bool memoryRepository) { ICatalogueRepository repo = memoryRepository ? (ICatalogueRepository) new MemoryCatalogueRepository() : CatalogueRepository; var gov = GetGov(repo); Catalogue c = new Catalogue(repo, "GovernedCatalogue"); try { Assert.AreEqual(gov.GovernedCatalogues.Count(), 0); //should be no governanced catalogues for this governancer yet gov.CreateGovernanceRelationshipTo(c); var allCatalogues = gov.GovernedCatalogues.ToArray(); var governedCatalogue = allCatalogues[0]; Assert.AreEqual(governedCatalogue, c); //we now govern C } finally { gov.DeleteGovernanceRelationshipTo(c); Assert.AreEqual(gov.GovernedCatalogues.Count(), 0); //we govern c nevermore! c.DeleteInDatabase(); } }
public void ExtractionInformationTriangle() { var t = new TableInfo(CatalogueRepository, "t"); var col = new ColumnInfo(CatalogueRepository, "mycol", "varchar(10)", t); var cat = new Catalogue(CatalogueRepository, "MyCat"); var ci = new CatalogueItem(CatalogueRepository, cat, "myci"); try { //col depends on tr Assert.Contains(t, col.GetObjectsThisDependsOn()); Assert.Contains(col, t.GetObjectsDependingOnThis()); //catalogue depends on catalogue items existing (slightly counter intuitive but think of it as data flow out of technical low level data through transforms into datasets - and then into researchers and research projects) Assert.Contains(cat, ci.GetObjectsDependingOnThis()); Assert.Contains(ci, cat.GetObjectsThisDependsOn()); //catalogue item should not be relying on anything currently (no link to underlying technical data) Assert.IsNull(ci.GetObjectsThisDependsOn()); //now they are associated so the ci should be dependent on the col ci.SetColumnInfo(col); Assert.Contains(col, ci.GetObjectsDependingOnThis()); } finally { t.DeleteInDatabase(); cat.DeleteInDatabase(); } }
/// <summary> /// Deletes the rdmp metadata objects (but not the actual <see cref="BulkDataTable"/>) /// </summary> public void DeleteCatalogue() { var creds = (DataAccessCredentials)tableInfo.GetCredentialsIfExists(DataAccessContext.InternalDataProcessing); if (tableInfo.Exists()) { tableInfo.DeleteInDatabase(); } if (creds != null) { try { creds.DeleteInDatabase(); } catch (CredentialsInUseException e) { Console.WriteLine("Ignored Potential Exception:" + e); } } if (catalogue.Exists()) { catalogue.DeleteInDatabase(); } }
private void CleanCatalogueDatabase() { if (_catalogue != null) { _catalogue.DeleteInDatabase(); } // ensure the database is cleared of test remnants foreach (var ji in CatalogueRepository.GetAllObjects <JoinInfo>()) { ji.DeleteInDatabase(); } // column infos don't appear to delete foreach (var ci in CatalogueRepository.GetAllObjects <ColumnInfo>()) { ci.DeleteInDatabase(); } foreach (var ti in CatalogueRepository.GetAllObjects <TableInfo>()) { ti.DeleteInDatabase(); } foreach (var credentials in CatalogueRepository.GetAllObjects <DataAccessCredentials>()) { credentials.DeleteInDatabase(); } }
public void TearDown() { _config.DeleteInDatabase(); _extractionInformation.DeleteInDatabase(); _table.DeleteInDatabase(); _cata.DeleteInDatabase(); }
public void CreateNewExternalServerAndConfigureItAsDefault() { ServerDefaults defaults = new ServerDefaults(CatalogueRepository); var databaseServer = new ExternalDatabaseServer(CatalogueRepository, "Deleteme", null); try { Assert.AreEqual("Deleteme", databaseServer.Name); databaseServer.Password = "******"; //automatically encrypts password Assert.AreNotEqual("nothing", databaseServer.Password); //should not match what we just set it to Assert.AreEqual("nothing", databaseServer.GetDecryptedPassword()); //should match what we set it to because of explicit call to decrypt databaseServer.Server = "Bob"; databaseServer.Database = "TEST"; databaseServer.SaveToDatabase(); Catalogue cata = new Catalogue(CatalogueRepository, "TestCatalogueFor_CreateNewExternalServerAndConfigureItAsDefault"); cata.DeleteInDatabase(); } finally { databaseServer.DeleteInDatabase(); } }
public void CreateCatalogueWithNoAcronym_CrashesDITAExtractor() { var testDir = _directoryHelper.Directory; try { //create a new Catalogue in the test datbaase that doesnt have a acronym (should crash Dita Extractor) Catalogue myNewCatalogue = new Catalogue(CatalogueRepository, "UnitTestCatalogue"); myNewCatalogue.Acronym = ""; myNewCatalogue.SaveToDatabase(); try { DitaCatalogueExtractor extractor = new DitaCatalogueExtractor(CatalogueRepository, testDir); var ex = Assert.Throws <Exception>(() => extractor.Extract(new ThrowImmediatelyDataLoadEventListener())); Assert.AreEqual("Dita Extraction requires that each catalogue have a unique Acronym, the catalogue UnitTestCatalogue is missing an Acronym", ex.Message); } finally { myNewCatalogue.DeleteInDatabase(); } } finally { foreach (var file in testDir.GetFiles()) { file.Delete(); } } }
public void CatalogueFolder_SubfolderingDuplicateNames() { var c1 = new Catalogue(Repository, "C1"); var c2 = new Catalogue(Repository, "C2"); var c3 = new Catalogue(Repository, "C3"); try { c1.Folder.Path = @"\A\B\C\"; c1.SaveToDatabase(); c2.Folder.Path = @"\B\C\"; c2.SaveToDatabase(); c3.Folder.Path = @"\A\B\"; c3.SaveToDatabase(); //c1 is a subfolder of c3 Assert.IsFalse(c1.Folder.IsSubFolderOf(c2.Folder)); Assert.IsTrue(c1.Folder.IsSubFolderOf(c3.Folder)); //c2 is nobodies subfolder Assert.IsFalse(c2.Folder.IsSubFolderOf(c1.Folder)); Assert.IsFalse(c2.Folder.IsSubFolderOf(c3.Folder)); //c2 is nobodies subfolder Assert.IsFalse(c3.Folder.IsSubFolderOf(c1.Folder)); Assert.IsFalse(c3.Folder.IsSubFolderOf(c2.Folder)); } finally { c1.DeleteInDatabase(); c2.DeleteInDatabase(); } }
public void Dispose() { if (Catalogue != null) { Catalogue.DeleteInDatabase(); } if (LoadMetadata != null) { LoadMetadata.DeleteInDatabase(); } if (ColumnInfo != null) { ColumnInfo.DeleteInDatabase(); } if (TableInfo != null) { TableInfo.DeleteInDatabase(); } if (Credentials != null) { Credentials.DeleteInDatabase(); } }
public void GetCatalogueWithID_validID_pass() { Catalogue c = new Catalogue(Repository, "TEST"); Assert.NotNull(c); Assert.True(c.Name == "TEST"); c.DeleteInDatabase(); }
private void AddToExistingCatalogue(Catalogue addToInstead, ExtractionInformation[] eis) { //move all the CatalogueItems to the other Catalogue instead foreach (ExtractionInformation ei in eis) { var ci = ei.CatalogueItem; ci.Catalogue_ID = addToInstead.ID; ci.SaveToDatabase(); } _choicesFinalised = true; _catalogue.DeleteInDatabase(); _catalogue = null; Activator.RefreshBus.Publish(this, new RefreshObjectEventArgs(addToInstead)); Close(); }
public void Test_GetObjects_Catalogue() { Catalogue catalogueWithId = new Catalogue(Repository, "bob"); Catalogue[] catas = Repository.GetAllObjects <Catalogue>(); Assert.IsTrue(catas.Length > 0); catalogueWithId.DeleteInDatabase(); }
public void test_SupportingDocument_CreateAndDestroy() { Catalogue cata = new Catalogue(CatalogueRepository, "deleteme"); SupportingDocument doc = new SupportingDocument(CatalogueRepository, cata, "davesFile"); Assert.AreEqual(doc.Name, "davesFile"); doc.DeleteInDatabase(); cata.DeleteInDatabase(); }
public void TearDown() { cic.DeleteInDatabase(); acCohort.DeleteInDatabase(); acDataset.DeleteInDatabase(); t.DeleteInDatabase(); c.DeleteInDatabase(); }
public void Test_RowVer() { var cata = new Catalogue(CatalogueRepository, "FFFF"); //When we get all the Catalogues we should include cata Assert.Contains(cata, CatalogueRepository.GetAllObjects <Catalogue>()); Assert.AreEqual(cata, CatalogueRepository.GetAllObjects <Catalogue>()[0]); Assert.AreNotSame(cata, CatalogueRepository.GetAllObjects <Catalogue>()[0]); //create a cache var rowVerCache = new RowVerCache <Catalogue>(CatalogueRepository); //should fill the cache cata = rowVerCache.GetAllObjects()[0]; //should return the same instance Assert.AreSame(cata, rowVerCache.GetAllObjects()[0]); cata.DeleteInDatabase(); Assert.IsEmpty(rowVerCache.GetAllObjects()); //create some catalogues new Catalogue(CatalogueRepository, "1"); new Catalogue(CatalogueRepository, "2"); new Catalogue(CatalogueRepository, "3"); //fill up the cache rowVerCache.GetAllObjects(); //give it a fresh object var cata2 = new Catalogue(CatalogueRepository, "dddd"); //fresh fetch for this Assert.Contains(cata2, rowVerCache.GetAllObjects()); Assert.IsFalse(rowVerCache.GetAllObjects().Contains(cata)); //change a value in the background but first make sure that what the cache has is a Equal but not reference to cata2 Assert.IsFalse(rowVerCache.GetAllObjects().Any(o => ReferenceEquals(o, cata2))); Assert.IsTrue(rowVerCache.GetAllObjects().Any(o => Equals(o, cata2))); cata2.Name = "boom"; cata2.SaveToDatabase(); Assert.AreEqual(1, rowVerCache.GetAllObjects().Count(c => c.Name.Equals("boom"))); cata2.Name = "vroom"; cata2.SaveToDatabase(); Assert.AreEqual(1, rowVerCache.GetAllObjects().Count(c => c.Name.Equals("vroom"))); Assert.AreEqual(1, rowVerCache.GetAllObjects().Count(c => c.Name.Equals("vroom"))); Assert.IsFalse(rowVerCache.Broken); }
public void CatalogueCheck_DodgyName() { var cata = new Catalogue(CatalogueRepository, "fish"); //name broken cata.Name = @"c:\bob.txt#"; var ex = Assert.Throws <Exception>(() => cata.Check(new ThrowImmediatelyCheckNotifier())); Assert.IsTrue(ex.Message.Contains("The following invalid characters were found:'\\','.','#'")); cata.DeleteInDatabase(); }
public void TestSettingColumnInfoToNull() { var parent = new Catalogue(CatalogueRepository, "GROG"); CatalogueItem child1 = new CatalogueItem(CatalogueRepository, parent, "GROG_ITEM1"); child1.SetColumnInfo(null); Assert.IsNull(child1.ColumnInfo_ID); child1.DeleteInDatabase(); parent.DeleteInDatabase(); }
public void Destroy() { var credentials = (DataAccessCredentials)TableInfoCreated.GetCredentialsIfExists(DataAccessContext.InternalDataProcessing); TableInfoCreated.DeleteInDatabase(); if (credentials != null) { credentials.DeleteInDatabase(); } Cata.DeleteInDatabase(); }
public void FindSameName_MixedCaps() { var cata1 = new Catalogue(Repository, "Bob"); var cata2 = new Catalogue(Repository, "bob"); var activator = new ThrowImmediatelyActivator(RepositoryLocator); var cmd = new ExecuteCommandSimilar(activator, cata1, false); Assert.AreEqual(cata2, cmd.Matched.Single()); cata1.DeleteInDatabase(); cata2.DeleteInDatabase(); }
public void CatalogueFolder_DefaultIsRoot() { var c = new Catalogue(Repository, "bob"); try { Assert.AreEqual("\\", c.Folder.Path); } finally { c.DeleteInDatabase(); } }
public void clone_CloneCatalogueItemWithIDIntoCatalogue_passes() { Catalogue parent = new Catalogue(CatalogueRepository, "KONGOR"); Catalogue parent2 = new Catalogue(CatalogueRepository, "KONGOR2"); CatalogueItem child = new CatalogueItem(CatalogueRepository, parent, "KONGOR_SUPERKING") { Agg_method = "Adding SetUp", Comments = "do not change amagad super secret!", Limitations = "Extreme limitaitons", Description = "Exciting things are going down in the streets of new your this time of year it would be a great idea if you were to go there", Name = "KONGOR_MINIMAN", Periodicity = Catalogue.CataloguePeriodicity.Monthly, Research_relevance = "Highly relevant to all fields of subatomic particle study", Statistical_cons = "Dangerous cons frequent the areas that this stats is happening, be afraid", Topic = "nothing much, lots of stuff" }; CatalogueItem cloneChild = null; try { child.SaveToDatabase(); cloneChild = child.CloneCatalogueItemWithIDIntoCatalogue(parent2); //get the clone that was returned Assert.AreEqual(cloneChild.Catalogue_ID, parent2.ID); //it is in the second one Assert.AreNotEqual(cloneChild.Catalogue_ID, parent.ID); //it is not in the first one Assert.AreNotEqual(cloneChild.ID, child.ID); //it has a new ID Assert.AreEqual(cloneChild.Limitations, child.Limitations); Assert.AreEqual(cloneChild.Description, child.Description); Assert.AreEqual(cloneChild.Name, child.Name); Assert.AreEqual(cloneChild.Periodicity, child.Periodicity); Assert.AreEqual(cloneChild.Research_relevance, child.Research_relevance); Assert.AreEqual(cloneChild.Statistical_cons, child.Statistical_cons); Assert.AreEqual(cloneChild.Topic, child.Topic); } finally { if (cloneChild != null) { cloneChild.DeleteInDatabase(); } child.DeleteInDatabase(); parent.DeleteInDatabase(); parent2.DeleteInDatabase(); } }
public void CatalogueFolder_CannotSetToNull() { var c = new Catalogue(Repository, "bob"); try { var ex = Assert.Throws <NotSupportedException>(() => c.Folder.Path = null); Assert.AreEqual(@"An attempt was made to set Catalogue bob Folder to null, every Catalogue must have a folder, set it to \ if you want the root", ex.Message); } finally { c.DeleteInDatabase(); } }
public void CatalogueFolder_CannotSetToNonRoot() { var c = new Catalogue(Repository, "bob"); try { var ex = Assert.Throws <NotSupportedException>(() => c.Folder.Path = "fish"); Assert.AreEqual(@"All catalogue paths must start with \ but Catalogue bob had an attempt to set it's folder to :fish", ex.Message); } finally { c.DeleteInDatabase(); } }
public void GatherAndShare_ExtractionFilter_Test() { //Setup some objects under Catalogue var cata = new Catalogue(CatalogueRepository, "Cata"); cata.Periodicity = Catalogue.CataloguePeriodicity.BiMonthly; cata.SaveToDatabase(); var catalogueItem1 = new CatalogueItem(CatalogueRepository, cata, "Ci1"); var tableInfo = new TableInfo(CatalogueRepository, "Myt"); var colInfo = new ColumnInfo(CatalogueRepository, "[Mt].[C1]", "varchar(10)", tableInfo); catalogueItem1.ColumnInfo_ID = colInfo.ID; catalogueItem1.SaveToDatabase(); //Setup a Filter under this extractable column (the filter is what we will share) var ei = new ExtractionInformation(CatalogueRepository, catalogueItem1, colInfo, "UPPER(C1) as Fish"); var filter = new ExtractionFilter(CatalogueRepository, "My Filter", ei); filter.Description = "amagad"; filter.WhereSQL = "UPPER(C1) = @a"; //Give the filter a parameter @a just to make things interesting var declaration = filter.GetQuerySyntaxHelper().GetParameterDeclaration("@a", new DatabaseTypeRequest(typeof(string), 1)); var param = filter.GetFilterFactory().CreateNewParameter(filter, declaration); //Also create a 'known good value' set i.e. recommended value for the parameter to achive some goal (you can have multiple of these - this will not be shared) var set = new ExtractionFilterParameterSet(CatalogueRepository, filter, "Fife"); var val = new ExtractionFilterParameterSetValue(CatalogueRepository, set, (ExtractionFilterParameter)param); val.Value = "'FISH'"; //Gather the dependencies (this is what we are testing) var gatherer = new Gatherer(RepositoryLocator); Assert.IsTrue(gatherer.CanGatherDependencies(filter)); var gathered = gatherer.GatherDependencies(filter); //gatherer should have gathered the filter and the parameter (but not the ExtractionFilterParameterSet sets) Assert.AreEqual(1, gathered.Children.Count); Assert.AreEqual(param, gathered.Children[0].Object); //Cleanup val.DeleteInDatabase(); set.DeleteInDatabase(); cata.DeleteInDatabase(); }
private void MessWithCatalogue() { try { var repository = new CatalogueRepository(CatalogueRepository.ConnectionStringBuilder); var cata = new Catalogue(repository, "bob"); cata.Name = "Fuss"; cata.SaveToDatabase(); cata.DeleteInDatabase(); } catch (Exception ex) { asyncExceptions.Add(ex); } }