mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/Hosting/DirectoryCatalogTests.cs

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 #if !SILVERLIGHT\r
   5 \r
   6 using System;\r
   7 using System.Collections.Generic;\r
   8 using System.ComponentModel.Composition.Hosting;\r
   9 using System.ComponentModel.Composition.Factories;\r
  10 using System.IO;\r
  11 using System.Linq;\r
  12 using System.Linq.Expressions;\r
  13 using System.UnitTesting;\r
  14 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  15 using System.ComponentModel.Composition.Primitives;\r
  16 using System.Reflection;\r
  17 \r
  18 namespace System.ComponentModel.Composition\r
  19 {\r
  20     [TestClass]\r
  21     public class DirectoryCatalogTests\r
  22     {\r
  23         internal const string NonExistentSearchPattern = "*.NonExistentSearchPattern";\r
  24 \r
  25         [TestMethod]\r
  26         public void ICompositionElementDisplayName_ShouldIncludeCatalogTypeNameAndDirectoryPath()\r
  27         {\r
  28             var paths = GetPathExpectations();\r
  29 \r
  30             foreach (var path in paths)\r
  31             {\r
  32                 var catalog = (ICompositionElement)CreateDirectoryCatalog(path, NonExistentSearchPattern);\r
  33 \r
  34                 string expected = string.Format("DirectoryCatalog (Path=\"{0}\")", path);\r
  35 \r
  36                 Assert.AreEqual(expected, catalog.DisplayName);\r
  37             }\r
  38         }\r
  39 \r
  40         [TestMethod]\r
  41         public void ICompositionElementDisplayName_ShouldIncludeDerivedCatalogTypeNameAndAssemblyFullName()\r
  42         {\r
  43             var paths = GetPathExpectations();\r
  44 \r
  45             foreach (var path in paths)\r
  46             {\r
  47                 var catalog = (ICompositionElement)new DerivedDirectoryCatalog(path, NonExistentSearchPattern);\r
  48 \r
  49                 string expected = string.Format("DerivedDirectoryCatalog (Path=\"{0}\")", path);\r
  50 \r
  51                 Assert.AreEqual(expected, catalog.DisplayName);\r
  52             }\r
  53         }\r
  54 \r
  55         [TestMethod]\r
  56         public void ToString_ShouldReturnICompositionElementDisplayName()\r
  57         {\r
  58             var paths = GetPathExpectations();\r
  59 \r
  60             foreach (var path in paths)\r
  61             {\r
  62                 var catalog = (ICompositionElement)CreateDirectoryCatalog(path, NonExistentSearchPattern);\r
  63 \r
  64                 Assert.AreEqual(catalog.DisplayName, catalog.ToString());\r
  65             }\r
  66         }\r
  67 \r
  68         [TestMethod]\r
  69         public void ICompositionElementDisplayName_WhenCatalogDisposed_ShouldNotThrow()\r
  70         {\r
  71             var catalog = CreateDirectoryCatalog();\r
  72             catalog.Dispose();\r
  73 \r
  74             var displayName = ((ICompositionElement)catalog).DisplayName;\r
  75         }\r
  76 \r
  77         [TestMethod]\r
  78         public void ICompositionElementOrigin_WhenCatalogDisposed_ShouldNotThrow()\r
  79         {\r
  80             var catalog = CreateDirectoryCatalog();\r
  81             catalog.Dispose();\r
  82 \r
  83             var origin = ((ICompositionElement)catalog).Origin;\r
  84         }\r
  85 \r
  86         [TestMethod]\r
  87         public void Parts_WhenCatalogDisposed_ShouldThrowObjectDisposed()\r
  88         {\r
  89             var catalog = CreateDirectoryCatalog();\r
  90             catalog.Dispose();\r
  91 \r
  92             ExceptionAssert.ThrowsDisposed(catalog, () =>\r
  93             {\r
  94                 var parts = catalog.Parts;\r
  95             });\r
  96         }\r
  97 \r
  98         [TestMethod]\r
  99         public void GetExports_WhenCatalogDisposed_ShouldThrowObjectDisposed()\r
 100         {\r
 101             var catalog = CreateDirectoryCatalog();\r
 102             catalog.Dispose();\r
 103             var definition = ImportDefinitionFactory.Create();\r
 104 \r
 105             ExceptionAssert.ThrowsDisposed(catalog, () =>\r
 106             {\r
 107                 catalog.GetExports(definition);\r
 108             });\r
 109         }\r
 110 \r
 111         [TestMethod]\r
 112         public void Refresh_WhenCatalogDisposed_ShouldThrowObjectDisposed()\r
 113         {\r
 114             var catalog = CreateDirectoryCatalog();\r
 115             catalog.Dispose();\r
 116 \r
 117             ExceptionAssert.ThrowsDisposed(catalog, () =>\r
 118             {\r
 119                 catalog.Refresh();\r
 120             });\r
 121         }\r
 122 \r
 123         [TestMethod]\r
 124         public void ToString_WhenCatalogDisposed_ShouldNotThrow()\r
 125         {\r
 126             var catalog = CreateDirectoryCatalog();\r
 127             catalog.Dispose();\r
 128 \r
 129             catalog.ToString();\r
 130         }\r
 131 \r
 132         [TestMethod]\r
 133         public void GetExports_NullAsConstraintArgument_ShouldThrowArgumentNull()\r
 134         {\r
 135             var catalog = CreateDirectoryCatalog();\r
 136 \r
 137             ExceptionAssert.ThrowsArgument<ArgumentNullException>("definition", () =>\r
 138             {\r
 139                 catalog.GetExports((ImportDefinition)null);\r
 140             });\r
 141         }\r
 142 \r
 143 \r
 144         [TestMethod]\r
 145         public void Dispose_ShouldNotThrow()\r
 146         {\r
 147             using (var catalog = CreateDirectoryCatalog())\r
 148             {\r
 149             }\r
 150         }\r
 151 \r
 152         [TestMethod]\r
 153         public void Dispose_CanBeCalledMultipleTimes()\r
 154         {\r
 155             var catalog = CreateDirectoryCatalog();\r
 156             catalog.Dispose();\r
 157             catalog.Dispose();\r
 158             catalog.Dispose();\r
 159         }\r
 160 \r
 161 \r
 162         [TestMethod]\r
 163         public void AddAssembly1_NonExistentUriAsAssemblyFileNameArgument_ShouldNotSupportedException()\r
 164         {\r
 165             ExceptionAssert.Throws<NotSupportedException>(() =>\r
 166             {\r
 167                 var catalog = new DirectoryCatalog("http://microsoft.com/myassembly.dll");\r
 168             });\r
 169         }\r
 170 \r
 171         [TestMethod]\r
 172         public void AddAssembly1_NullPathArgument_ShouldThrowArugmentNull()\r
 173         {\r
 174             ExceptionAssert.Throws<ArgumentNullException>(() =>\r
 175                 new DirectoryCatalog((string)null));\r
 176         }\r
 177 \r
 178         [TestMethod]\r
 179         public void AddAssembly1_EmptyPathArgument_ShouldThrowArugment()\r
 180         {\r
 181             ExceptionAssert.Throws<ArgumentException>(() =>\r
 182                 new DirectoryCatalog(""));\r
 183         }\r
 184 \r
 185         [TestMethod]\r
 186         public void AddAssembly1_InvalidPathName_ShouldThrowDirectoryNotFound()\r
 187         {\r
 188             ExceptionAssert.Throws<ArgumentException>(() =>\r
 189             {\r
 190                 var c1 = new DirectoryCatalog("*");\r
 191             });\r
 192         }\r
 193 \r
 194         [TestMethod]\r
 195         public void AddAssembly1_TooLongPathNameArgument_ShouldThrowPathTooLongException()\r
 196         {\r
 197             ExceptionAssert.Throws<PathTooLongException>(() =>\r
 198             {\r
 199                 var c1 = new DirectoryCatalog(@"c:\This is a very long path\And Just to make sure\We will continue to make it very long\This is a very long path\And Just to make sure\We will continue to make it very long\This is a very long path\And Just to make sure\We will continue to make it very long\myassembly.dll");\r
 200             });\r
 201         }\r
 202 \r
 203 \r
 204         [TestMethod]\r
 205         public void Parts()\r
 206         {\r
 207             using (var directory = CreateTemporaryDirectory())\r
 208             {\r
 209                 var catalog = new DirectoryCatalog(directory.DirectoryPath);\r
 210                 Assert.IsNotNull(catalog.Parts);\r
 211                 Assert.IsTrue(catalog.Parts.Count() > 0);\r
 212             }\r
 213         }\r
 214 \r
 215         [TestMethod]\r
 216         public void Parts_ShouldSetDefinitionOriginToCatalogItself()\r
 217         {\r
 218             using (var directory = CreateTemporaryDirectory())\r
 219             {\r
 220                 var catalog = new DirectoryCatalog(directory.DirectoryPath);\r
 221                 Assert.IsTrue(catalog.Parts.Count() > 0);\r
 222 \r
 223                 foreach (ICompositionElement definition in catalog.Parts)\r
 224                 {\r
 225                     Assert.AreSame(catalog, definition.Origin);\r
 226                 }\r
 227             }\r
 228         }\r
 229 \r
 230         [TestMethod]\r
 231         public void Path_ValidPath_ShouldBeFine()\r
 232         {\r
 233             using (var directory = CreateTemporaryDirectory())\r
 234             {\r
 235                 var expectations = new ExpectationCollection<string, string>();\r
 236 \r
 237                 expectations.Add(".", ".");\r
 238                 expectations.Add(FileIO.RootTemporaryDirectoryName, FileIO.RootTemporaryDirectoryName);\r
 239                 expectations.Add(FileIO.GetRootTemporaryDirectory(), FileIO.GetRootTemporaryDirectory());\r
 240                 expectations.Add(directory.DirectoryPath, directory.DirectoryPath);\r
 241 \r
 242                 foreach (var e in expectations)\r
 243                 {\r
 244                     var cat = CreateDirectoryCatalog(e.Input, NonExistentSearchPattern);\r
 245 \r
 246                     Assert.AreEqual(e.Output, cat.Path);\r
 247                 }\r
 248             }\r
 249         }\r
 250 \r
 251         [TestMethod]\r
 252         public void FullPath_ValidPath_ShouldBeFine()\r
 253         {\r
 254             using (var directory = CreateTemporaryDirectory())\r
 255             {\r
 256                 var expectations = new ExpectationCollection<string, string>();\r
 257 \r
 258                 // Ensure the path is always normalized properly.\r
 259                 string rootTempPath = Path.GetFullPath(FileIO.GetRootTemporaryDirectory()).ToUpperInvariant();\r
 260 \r
 261                 // Note: These relative paths work properly because the unit test temporary directories are always\r
 262                 // created as a subfolder off the AppDomain.CurrentDomain.BaseDirectory.\r
 263                 expectations.Add(".", Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, ".")).ToUpperInvariant());\r
 264                 expectations.Add(FileIO.RootTemporaryDirectoryName, rootTempPath);\r
 265                 expectations.Add(FileIO.GetRootTemporaryDirectory(), rootTempPath);\r
 266                 expectations.Add(directory.DirectoryPath, Path.GetFullPath(directory.DirectoryPath).ToUpperInvariant());\r
 267 \r
 268                 foreach (var e in expectations)\r
 269                 {\r
 270                     var cat = CreateDirectoryCatalog(e.Input, NonExistentSearchPattern);\r
 271 \r
 272                     Assert.AreEqual(e.Output, cat.FullPath);\r
 273                 }\r
 274             }\r
 275         }\r
 276 \r
 277         [TestMethod]\r
 278         public void LoadedFiles_EmptyDirectory_ShouldBeFine()\r
 279         {\r
 280             using (var directory = new TemporaryDirectory())\r
 281             {\r
 282                 var cat = new DirectoryCatalog(directory.DirectoryPath);\r
 283 \r
 284                 Assert.AreEqual(0, cat.LoadedFiles.Count);\r
 285             }\r
 286         }\r
 287 \r
 288         [TestMethod]\r
 289         public void LoadedFiles_ContainsMultipleDllsAndSomeNonDll_ShouldOnlyContainDlls()\r
 290         {\r
 291             using (var directory = new TemporaryDirectory())\r
 292             {\r
 293                 // Add one text file\r
 294                 using (File.CreateText(Path.Combine(directory.DirectoryPath, "Test.txt"))) { }\r
 295 \r
 296                 // Add two dll's\r
 297                 string dll1 = Path.Combine(directory.DirectoryPath, "Test1.dll");\r
 298                 string dll2 = Path.Combine(directory.DirectoryPath, "Test2.dll");\r
 299                 File.Copy(Assembly.GetExecutingAssembly().Location, dll1);\r
 300                 File.Copy(Assembly.GetExecutingAssembly().Location, dll2);\r
 301 \r
 302                 var cat = new DirectoryCatalog(directory.DirectoryPath);\r
 303 \r
 304                 CollectionAssert.AreEquivalent(new string[] { dll1.ToUpperInvariant(), dll2.ToUpperInvariant() },\r
 305                     cat.LoadedFiles);\r
 306             }\r
 307         }\r
 308 \r
 309         [TestMethod]\r
 310         public void Constructor_InvalidAssembly_ShouldBeFine()\r
 311         {\r
 312             using (var directory = CreateTemporaryDirectory())\r
 313             {\r
 314                 using (File.CreateText(Path.Combine(directory.DirectoryPath, "Test.dll"))) { }\r
 315                 var cat = new DirectoryCatalog(directory.DirectoryPath);\r
 316             }\r
 317         }\r
 318 \r
 319         [TestMethod]\r
 320         public void Constructor_NonExistentDirectory_ShouldThrow()\r
 321         {\r
 322             using (var directory = CreateTemporaryDirectory())\r
 323             {\r
 324                 ExceptionAssert.Throws<DirectoryNotFoundException>( () =>\r
 325                     new DirectoryCatalog(directory.DirectoryPath + @"\NonexistentDirectoryWithoutEndingSlash"));\r
 326 \r
 327                 ExceptionAssert.Throws<DirectoryNotFoundException>( () =>\r
 328                     new DirectoryCatalog(directory.DirectoryPath + @"\NonexistentDirectoryWithEndingSlash\"));\r
 329 \r
 330             }\r
 331         }\r
 332 \r
 333         [TestMethod]\r
 334         public void Constructor_PassExistingFileName_ShouldThrow()\r
 335         {\r
 336             using (var directory = CreateTemporaryDirectory())\r
 337             {\r
 338                 using (File.CreateText(Path.Combine(directory.DirectoryPath, "Test.txt"))) { }\r
 339                 ExceptionAssert.Throws<IOException>(() =>\r
 340                     new DirectoryCatalog(Path.Combine(directory.DirectoryPath, "Test.txt")));\r
 341             }\r
 342         }\r
 343 \r
 344         [TestMethod]\r
 345         public void Constructor_PassNonExistingFileName_ShouldThrow()\r
 346         {\r
 347             using (var directory = CreateTemporaryDirectory())\r
 348             {\r
 349                 ExceptionAssert.Throws<DirectoryNotFoundException>(() =>\r
 350                     new DirectoryCatalog(Path.Combine(directory.DirectoryPath, "NonExistingFile.txt")));\r
 351             }\r
 352         }\r
 353 \r
 354         [TestMethod]\r
 355         public void Refresh_AssemblyAdded_ShouldFireOnChanged()\r
 356         {\r
 357             using (var directory = new TemporaryDirectory())\r
 358             {\r
 359                 bool changedFired = false;\r
 360                 bool changingFired = false;\r
 361                 var cat = new DirectoryCatalog(directory.DirectoryPath);\r
 362 \r
 363                 Assert.AreEqual(0, cat.Parts.Count(), "Catalog should initially be empty");\r
 364 \r
 365                 cat.Changing += new EventHandler<ComposablePartCatalogChangeEventArgs>((o, e) =>\r
 366                     {\r
 367                         Assert.AreEqual(0, cat.Parts.Count(), "Catalog changes should NOT have been completeed yet");\r
 368                         changingFired = true;\r
 369                     });\r
 370 \r
 371                 cat.Changed += new EventHandler<ComposablePartCatalogChangeEventArgs>((o, e) =>\r
 372                     {\r
 373                         Assert.AreNotEqual(0, cat.Parts.Count(), "Catalog changes should have been completeed");\r
 374                         changedFired = true;\r
 375                     });\r
 376 \r
 377 \r
 378                 File.Copy(Assembly.GetExecutingAssembly().Location, Path.Combine(directory.DirectoryPath, "Test.dll"));\r
 379 \r
 380                 cat.Refresh();\r
 381 \r
 382                 Assert.IsTrue(changingFired);\r
 383                 Assert.IsTrue(changedFired);\r
 384             }\r
 385         }\r
 386 \r
 387         [TestMethod]\r
 388         public void Refresh_AssemblyRemoved_ShouldFireOnChanged()\r
 389         {\r
 390             using (var directory = CreateTemporaryDirectory())\r
 391             {\r
 392                 string file = Path.Combine(directory.DirectoryPath, "Test.dll");\r
 393                 File.Copy(Assembly.GetExecutingAssembly().Location, file);\r
 394                 bool changedFired = false;\r
 395                 var cat = new DirectoryCatalog(directory.DirectoryPath);\r
 396 \r
 397                 cat.Changed += new EventHandler<ComposablePartCatalogChangeEventArgs>((o, e) =>\r
 398                     changedFired = true);\r
 399 \r
 400                 // This assembly can be deleted because it was already loaded by the CLR in another context\r
 401                 // in another location so it isn't locked on disk.\r
 402                 File.Delete(file);\r
 403 \r
 404                 cat.Refresh();\r
 405 \r
 406                 Assert.IsTrue(changedFired);\r
 407             }\r
 408         }\r
 409 \r
 410         [TestMethod]\r
 411         public void Refresh_NoChanges_ShouldNotFireOnChanged()\r
 412         {\r
 413             using (var directory = CreateTemporaryDirectory())\r
 414             {\r
 415                 var cat = new DirectoryCatalog(directory.DirectoryPath);\r
 416 \r
 417                 cat.Changed += new EventHandler<ComposablePartCatalogChangeEventArgs>((o, e) =>\r
 418                     Assert.Fail("Should not recieve any change notifications"));\r
 419 \r
 420                 cat.Refresh();\r
 421             }\r
 422         }\r
 423 \r
 424         [TestMethod]\r
 425         public void Refresh_DirectoryRemoved_ShouldThrowDirectoryNotFound()\r
 426         {\r
 427             DirectoryCatalog cat;\r
 428             using (var directory = CreateTemporaryDirectory())\r
 429             {\r
 430                 cat = new DirectoryCatalog(directory.DirectoryPath);\r
 431             }\r
 432 \r
 433             ExceptionAssert.Throws<DirectoryNotFoundException>(RetryMode.DoNotRetry, () =>\r
 434                 cat.Refresh());\r
 435         }\r
 436 \r
 437         [TestMethod]\r
 438         public void GetExports()\r
 439         {\r
 440             using (var directory = CreateTemporaryDirectory())\r
 441             {\r
 442                 var catalog = new AggregateCatalog();\r
 443                 Expression<Func<ExportDefinition, bool>> constraint = (ExportDefinition exportDefinition) => exportDefinition.ContractName == AttributedModelServices.GetContractName(typeof(MyExport));\r
 444                 IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> matchingExports = null;\r
 445     \r
 446                 matchingExports = catalog.GetExports(constraint);\r
 447                 Assert.IsNotNull(matchingExports);\r
 448                 Assert.IsTrue(matchingExports.Count() == 0);\r
 449 \r
 450                 var testsDirectoryCatalog = new DirectoryCatalog(directory.DirectoryPath);\r
 451                 catalog.Catalogs.Add(testsDirectoryCatalog);\r
 452                 matchingExports = catalog.GetExports(constraint);\r
 453 \r
 454                 Assert.IsNotNull(matchingExports);\r
 455                 Assert.IsTrue(matchingExports.Count() >= 0);\r
 456 \r
 457                 IEnumerable<Tuple<ComposablePartDefinition, ExportDefinition>> expectedMatchingExports = catalog.Parts\r
 458                     .SelectMany(part => part.ExportDefinitions, (part, export) => new Tuple<ComposablePartDefinition, ExportDefinition>(part, export))\r
 459                     .Where(partAndExport => partAndExport.Item2.ContractName == AttributedModelServices.GetContractName(typeof(MyExport)));\r
 460 \r
 461                 Assert.IsTrue(matchingExports.SequenceEqual(expectedMatchingExports));\r
 462 \r
 463                 catalog.Catalogs.Remove(testsDirectoryCatalog);\r
 464                 matchingExports = catalog.GetExports(constraint);\r
 465                 Assert.IsNotNull(matchingExports);\r
 466                 Assert.IsTrue(matchingExports.Count() == 0);\r
 467             }\r
 468         }\r
 469 \r
 470         [TestMethod]\r
 471         public void AddAndRemoveDirectory()\r
 472         {\r
 473             using (var directory = CreateTemporaryDirectory())\r
 474             {\r
 475                 var cat = new AggregateCatalog();\r
 476                 var container = new CompositionContainer(cat);\r
 477 \r
 478                 Assert.IsFalse(container.IsPresent<MyExport>());\r
 479 \r
 480                 var dir1 = new DirectoryCatalog(directory.DirectoryPath);\r
 481                 cat.Catalogs.Add(dir1);\r
 482                 Assert.IsTrue(container.IsPresent<MyExport>());\r
 483 \r
 484                 cat.Catalogs.Remove(dir1);\r
 485 \r
 486                 Assert.IsFalse(container.IsPresent<MyExport>());\r
 487             }\r
 488         }\r
 489 \r
 490         [TestMethod]\r
 491         public void AddDirectoryNotFoundException()\r
 492         {\r
 493             ExceptionAssert.Throws<DirectoryNotFoundException>(() =>\r
 494             {\r
 495                 var cat = new DirectoryCatalog("Directory That Should Never Exist tadfasdfasdfsdf");\r
 496             });\r
 497         }\r
 498 \r
 499         [TestMethod]\r
 500         public void ExecuteOnCreationThread()\r
 501         {\r
 502             // Add a proper test for event notification on caller thread\r
 503         }\r
 504 \r
 505 \r
 506         private DirectoryCatalog CreateDirectoryCatalog()\r
 507         {\r
 508             return CreateDirectoryCatalog(FileIO.GetNewTemporaryDirectory());\r
 509         }\r
 510 \r
 511         private DirectoryCatalog CreateDirectoryCatalog(string path)\r
 512         {\r
 513             return new DirectoryCatalog(path);\r
 514         }\r
 515 \r
 516         private DirectoryCatalog CreateDirectoryCatalog(string path, string searchPattern)\r
 517         {\r
 518             return new DirectoryCatalog(path, searchPattern);\r
 519         }\r
 520 \r
 521         private TemporaryDirectory CreateTemporaryDirectory()\r
 522         {\r
 523             return new TemporaryFileCopier(typeof(DirectoryCatalogTests).Assembly.Location);\r
 524         }\r
 525 \r
 526         public IEnumerable<string> GetPathExpectations()\r
 527         {\r
 528             yield return AppDomain.CurrentDomain.BaseDirectory;\r
 529             yield return AppDomain.CurrentDomain.BaseDirectory + @"\";\r
 530             yield return ".";            \r
 531         }\r
 532 \r
 533         private class DerivedDirectoryCatalog : DirectoryCatalog\r
 534         {\r
 535             public DerivedDirectoryCatalog(string path, string searchPattern)\r
 536                 : base(path, searchPattern)\r
 537             {\r
 538             }\r
 539         }\r
 540     }\r
 541 }\r
 542 \r
 543 #endif\r