PageRenderTime 45ms CodeModel.GetById 15ms RepoModel.GetById 1ms app.codeStats 0ms

/V2.2/trunk/CAL/Desktop/Composite.Tests/Modularity/ModuleCatalogFixture.cs

#
C# | 510 lines | 394 code | 95 blank | 21 comment | 3 complexity | d9a299384009682f3c5976752497942a MD5 | raw file
  1. //===================================================================================
  2. // Microsoft patterns & practices
  3. // Composite Application Guidance for Windows Presentation Foundation and Silverlight
  4. //===================================================================================
  5. // Copyright (c) Microsoft Corporation. All rights reserved.
  6. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
  7. // OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
  8. // LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  9. // FITNESS FOR A PARTICULAR PURPOSE.
  10. //===================================================================================
  11. // The example companies, organizations, products, domain names,
  12. // e-mail addresses, logos, people, places, and events depicted
  13. // herein are fictitious. No association with any real company,
  14. // organization, product, domain name, email address, logo, person,
  15. // places, or events is intended or should be inferred.
  16. //===================================================================================
  17. using System;
  18. using System.Collections.Generic;
  19. using System.IO;
  20. using System.Linq;
  21. using System.Reflection;
  22. using Microsoft.Practices.Composite.Modularity;
  23. using Microsoft.VisualStudio.TestTools.UnitTesting;
  24. namespace Microsoft.Practices.Composite.Tests.Modularity
  25. {
  26. [TestClass]
  27. public class ModuleCatalogFixture
  28. {
  29. [TestMethod]
  30. public void CanCreateCatalogFromList()
  31. {
  32. var moduleInfo = new ModuleInfo("MockModule", "type");
  33. List<ModuleInfo> moduleInfos = new List<ModuleInfo> { moduleInfo };
  34. var moduleCatalog = new ModuleCatalog(moduleInfos);
  35. Assert.AreEqual(1, moduleCatalog.Modules.Count());
  36. Assert.AreEqual(moduleInfo, moduleCatalog.Modules.ElementAt(0));
  37. }
  38. [TestMethod]
  39. public void CanGetDependenciesForModule()
  40. {
  41. // A <- B
  42. var moduleInfoA = CreateModuleInfo("A");
  43. var moduleInfoB = CreateModuleInfo("B", "A");
  44. List<ModuleInfo> moduleInfos = new List<ModuleInfo>
  45. {
  46. moduleInfoA
  47. , moduleInfoB
  48. };
  49. var moduleCatalog = new ModuleCatalog(moduleInfos);
  50. IEnumerable<ModuleInfo> dependentModules = moduleCatalog.GetDependentModules(moduleInfoB);
  51. Assert.AreEqual(1, dependentModules.Count());
  52. Assert.AreEqual(moduleInfoA, dependentModules.ElementAt(0));
  53. }
  54. [TestMethod]
  55. public void CanCompleteListWithTheirDependencies()
  56. {
  57. // A <- B <- C
  58. var moduleInfoA = CreateModuleInfo("A");
  59. var moduleInfoB = CreateModuleInfo("B", "A");
  60. var moduleInfoC = CreateModuleInfo("C", "B");
  61. var moduleInfoOrphan = CreateModuleInfo("X", "B");
  62. List<ModuleInfo> moduleInfos = new List<ModuleInfo>
  63. {
  64. moduleInfoA
  65. , moduleInfoB
  66. , moduleInfoC
  67. , moduleInfoOrphan
  68. };
  69. var moduleCatalog = new ModuleCatalog(moduleInfos);
  70. IEnumerable<ModuleInfo> dependantModules = moduleCatalog.CompleteListWithDependencies(new[] { moduleInfoC });
  71. Assert.AreEqual(3, dependantModules.Count());
  72. Assert.IsTrue(dependantModules.Contains(moduleInfoA));
  73. Assert.IsTrue(dependantModules.Contains(moduleInfoB));
  74. Assert.IsTrue(dependantModules.Contains(moduleInfoC));
  75. }
  76. [TestMethod]
  77. [ExpectedException(typeof(CyclicDependencyFoundException))]
  78. public void ShouldThrowOnCyclicDependency()
  79. {
  80. // A <- B <- C <- A
  81. var moduleInfoA = CreateModuleInfo("A", "C");
  82. var moduleInfoB = CreateModuleInfo("B", "A");
  83. var moduleInfoC = CreateModuleInfo("C", "B");
  84. List<ModuleInfo> moduleInfos = new List<ModuleInfo>
  85. {
  86. moduleInfoA
  87. , moduleInfoB
  88. , moduleInfoC
  89. };
  90. new ModuleCatalog(moduleInfos).Validate();
  91. }
  92. [TestMethod]
  93. [ExpectedException(typeof(DuplicateModuleException))]
  94. public void ShouldThrowOnDuplicateModule()
  95. {
  96. var moduleInfoA1 = CreateModuleInfo("A");
  97. var moduleInfoA2 = CreateModuleInfo("A");
  98. List<ModuleInfo> moduleInfos = new List<ModuleInfo>
  99. {
  100. moduleInfoA1
  101. , moduleInfoA2
  102. };
  103. new ModuleCatalog(moduleInfos).Validate();
  104. }
  105. [TestMethod]
  106. [ExpectedException(typeof(ModularityException))]
  107. public void ShouldThrowOnMissingDependency()
  108. {
  109. var moduleInfoA = CreateModuleInfo("A", "B");
  110. List<ModuleInfo> moduleInfos = new List<ModuleInfo>
  111. {
  112. moduleInfoA
  113. };
  114. new ModuleCatalog(moduleInfos).Validate();
  115. }
  116. [TestMethod]
  117. public void CanAddModules()
  118. {
  119. var catalog = new ModuleCatalog();
  120. catalog.AddModule(typeof(MockModule));
  121. Assert.AreEqual(1, catalog.Modules.Count());
  122. Assert.AreEqual("MockModule", catalog.Modules.First().ModuleName);
  123. }
  124. [TestMethod]
  125. public void CanAddGroups()
  126. {
  127. var catalog = new ModuleCatalog();
  128. ModuleInfo moduleInfo = new ModuleInfo();
  129. ModuleInfoGroup group = new ModuleInfoGroup { moduleInfo };
  130. catalog.Items.Add(group);
  131. Assert.AreEqual(1, catalog.Modules.Count());
  132. Assert.AreSame(moduleInfo, catalog.Modules.ElementAt(0));
  133. }
  134. [TestMethod]
  135. public void ShouldAggregateGroupsAndLooseModuleInfos()
  136. {
  137. var catalog = new ModuleCatalog();
  138. ModuleInfo moduleInfo1 = new ModuleInfo();
  139. ModuleInfo moduleInfo2 = new ModuleInfo();
  140. ModuleInfo moduleInfo3 = new ModuleInfo();
  141. catalog.Items.Add(new ModuleInfoGroup() { moduleInfo1 });
  142. catalog.Items.Add(new ModuleInfoGroup() { moduleInfo2 });
  143. catalog.AddModule(moduleInfo3);
  144. Assert.AreEqual(3, catalog.Modules.Count());
  145. Assert.IsTrue(catalog.Modules.Contains(moduleInfo1));
  146. Assert.IsTrue(catalog.Modules.Contains(moduleInfo2));
  147. Assert.IsTrue(catalog.Modules.Contains(moduleInfo3));
  148. }
  149. [TestMethod]
  150. [ExpectedException(typeof(ArgumentNullException))]
  151. public void CompleteListWithDependenciesThrowsWithNull()
  152. {
  153. var catalog = new ModuleCatalog();
  154. catalog.CompleteListWithDependencies(null);
  155. }
  156. [TestMethod]
  157. public void LooseModuleIfDependentOnModuleInGroupThrows()
  158. {
  159. var catalog = new ModuleCatalog();
  160. catalog.Items.Add(new ModuleInfoGroup() { CreateModuleInfo("ModuleA") });
  161. catalog.AddModule(CreateModuleInfo("ModuleB", "ModuleA"));
  162. try
  163. {
  164. catalog.Validate();
  165. }
  166. catch (Exception ex)
  167. {
  168. Assert.IsInstanceOfType(ex, typeof(ModularityException));
  169. Assert.AreEqual("ModuleB", ((ModularityException)ex).ModuleName);
  170. return;
  171. }
  172. Assert.Fail("Exception not thrown.");
  173. }
  174. [TestMethod]
  175. public void ModuleInGroupDependsOnModuleInOtherGroupThrows()
  176. {
  177. var catalog = new ModuleCatalog();
  178. catalog.Items.Add(new ModuleInfoGroup() { CreateModuleInfo("ModuleA") });
  179. catalog.Items.Add(new ModuleInfoGroup() { CreateModuleInfo("ModuleB", "ModuleA") });
  180. try
  181. {
  182. catalog.Validate();
  183. }
  184. catch (Exception ex)
  185. {
  186. Assert.IsInstanceOfType(ex, typeof(ModularityException));
  187. Assert.AreEqual("ModuleB", ((ModularityException)ex).ModuleName);
  188. return;
  189. }
  190. Assert.Fail("Exception not thrown.");
  191. }
  192. [TestMethod]
  193. public void ShouldRevalidateWhenAddingNewModuleIfValidated()
  194. {
  195. var testableCatalog = new TestableModuleCatalog();
  196. testableCatalog.Items.Add(new ModuleInfoGroup() { CreateModuleInfo("ModuleA") });
  197. testableCatalog.Validate();
  198. testableCatalog.Items.Add(new ModuleInfoGroup() { CreateModuleInfo("ModuleB") });
  199. Assert.IsTrue(testableCatalog.ValidateCalled);
  200. }
  201. [TestMethod]
  202. public void ModuleInGroupCanDependOnModuleInSameGroup()
  203. {
  204. var catalog = new ModuleCatalog();
  205. var moduleA = CreateModuleInfo("ModuleA");
  206. var moduleB = CreateModuleInfo("ModuleB", "ModuleA");
  207. catalog.Items.Add(new ModuleInfoGroup()
  208. {
  209. moduleA,
  210. moduleB
  211. });
  212. var moduleBDependencies = catalog.GetDependentModules(moduleB);
  213. Assert.AreEqual(1, moduleBDependencies.Count());
  214. Assert.AreEqual(moduleA, moduleBDependencies.First());
  215. }
  216. [TestMethod]
  217. public void StartupModuleDependentOnAnOnDemandModuleThrows()
  218. {
  219. var catalog = new ModuleCatalog();
  220. var moduleOnDemand = CreateModuleInfo("ModuleA");
  221. moduleOnDemand.InitializationMode = InitializationMode.OnDemand;
  222. catalog.AddModule(moduleOnDemand);
  223. catalog.AddModule(CreateModuleInfo("ModuleB", "ModuleA"));
  224. try
  225. {
  226. catalog.Validate();
  227. }
  228. catch (Exception ex)
  229. {
  230. Assert.IsInstanceOfType(ex, typeof(ModularityException));
  231. Assert.AreEqual("ModuleB", ((ModularityException)ex).ModuleName);
  232. return;
  233. }
  234. Assert.Fail("Exception not thrown.");
  235. }
  236. [TestMethod]
  237. public void ShouldReturnInCorrectRetrieveOrderWhenCompletingListWithDependencies()
  238. {
  239. // A <- B <- C <- D, C <- X
  240. var moduleA = CreateModuleInfo("A");
  241. var moduleB = CreateModuleInfo("B", "A");
  242. var moduleC = CreateModuleInfo("C", "B");
  243. var moduleD = CreateModuleInfo("D", "C");
  244. var moduleX = CreateModuleInfo("X", "C");
  245. var moduleCatalog = new ModuleCatalog();
  246. // Add the modules in random order
  247. moduleCatalog.AddModule(moduleB);
  248. moduleCatalog.AddModule(moduleA);
  249. moduleCatalog.AddModule(moduleD);
  250. moduleCatalog.AddModule(moduleX);
  251. moduleCatalog.AddModule(moduleC);
  252. var dependantModules = moduleCatalog.CompleteListWithDependencies(new[] { moduleD, moduleX }).ToList();
  253. Assert.AreEqual(5, dependantModules.Count);
  254. Assert.IsTrue(dependantModules.IndexOf(moduleA) < dependantModules.IndexOf(moduleB));
  255. Assert.IsTrue(dependantModules.IndexOf(moduleB) < dependantModules.IndexOf(moduleC));
  256. Assert.IsTrue(dependantModules.IndexOf(moduleC) < dependantModules.IndexOf(moduleD));
  257. Assert.IsTrue(dependantModules.IndexOf(moduleC) < dependantModules.IndexOf(moduleX));
  258. }
  259. [TestMethod]
  260. public void CanLoadCatalogFromXaml()
  261. {
  262. Stream stream =
  263. Assembly.GetExecutingAssembly().GetManifestResourceStream(
  264. "Microsoft.Practices.Composite.Tests.Modularity.ModuleCatalogXaml.SimpleModuleCatalog.xaml");
  265. var catalog = ModuleCatalog.CreateFromXaml(stream);
  266. Assert.IsNotNull(catalog);
  267. Assert.AreEqual(4, catalog.Modules.Count());
  268. }
  269. [TestMethod]
  270. public void ShouldLoadAndValidateOnInitialize()
  271. {
  272. var catalog = new TestableModuleCatalog();
  273. var testableCatalog = new TestableModuleCatalog();
  274. Assert.IsFalse(testableCatalog.LoadCalled);
  275. Assert.IsFalse(testableCatalog.ValidateCalled);
  276. testableCatalog.Initialize();
  277. Assert.IsTrue(testableCatalog.LoadCalled);
  278. Assert.IsTrue(testableCatalog.ValidateCalled);
  279. Assert.IsTrue(testableCatalog.LoadCalledFirst);
  280. }
  281. [TestMethod]
  282. public void ShouldNotLoadAgainIfInitializedCalledMoreThanOnce()
  283. {
  284. var catalog = new TestableModuleCatalog();
  285. var testableCatalog = new TestableModuleCatalog();
  286. Assert.IsFalse(testableCatalog.LoadCalled);
  287. Assert.IsFalse(testableCatalog.ValidateCalled);
  288. testableCatalog.Initialize();
  289. Assert.AreEqual<int>(1, testableCatalog.LoadCalledCount);
  290. testableCatalog.Initialize();
  291. Assert.AreEqual<int>(1, testableCatalog.LoadCalledCount);
  292. }
  293. [TestMethod]
  294. public void ShouldNotLoadAgainDuringInitialize()
  295. {
  296. var catalog = new TestableModuleCatalog();
  297. var testableCatalog = new TestableModuleCatalog();
  298. Assert.IsFalse(testableCatalog.LoadCalled);
  299. Assert.IsFalse(testableCatalog.ValidateCalled);
  300. testableCatalog.Load();
  301. Assert.AreEqual<int>(1, testableCatalog.LoadCalledCount);
  302. testableCatalog.Initialize();
  303. Assert.AreEqual<int>(1, testableCatalog.LoadCalledCount);
  304. }
  305. [TestMethod]
  306. public void ShouldAllowLoadToBeInvokedTwice()
  307. {
  308. var catalog = new TestableModuleCatalog();
  309. var testableCatalog = new TestableModuleCatalog();
  310. testableCatalog.Load();
  311. Assert.AreEqual<int>(1, testableCatalog.LoadCalledCount);
  312. testableCatalog.Load();
  313. Assert.AreEqual<int>(2, testableCatalog.LoadCalledCount);
  314. }
  315. [TestMethod]
  316. public void CanAddModule1()
  317. {
  318. ModuleCatalog catalog = new ModuleCatalog();
  319. catalog.AddModule("Module", "ModuleType", InitializationMode.OnDemand, "DependsOn1", "DependsOn2");
  320. Assert.AreEqual(1, catalog.Modules.Count());
  321. Assert.AreEqual("Module", catalog.Modules.First().ModuleName);
  322. Assert.AreEqual("ModuleType", catalog.Modules.First().ModuleType);
  323. Assert.AreEqual(InitializationMode.OnDemand, catalog.Modules.First().InitializationMode);
  324. Assert.AreEqual(2, catalog.Modules.First().DependsOn.Count);
  325. Assert.AreEqual("DependsOn1", catalog.Modules.First().DependsOn[0]);
  326. Assert.AreEqual("DependsOn2", catalog.Modules.First().DependsOn[1]);
  327. }
  328. [TestMethod]
  329. public void CanAddModule2()
  330. {
  331. ModuleCatalog catalog = new ModuleCatalog();
  332. catalog.AddModule("Module", "ModuleType", "DependsOn1", "DependsOn2");
  333. Assert.AreEqual(1, catalog.Modules.Count());
  334. Assert.AreEqual("Module", catalog.Modules.First().ModuleName);
  335. Assert.AreEqual("ModuleType", catalog.Modules.First().ModuleType);
  336. Assert.AreEqual(InitializationMode.WhenAvailable, catalog.Modules.First().InitializationMode);
  337. Assert.AreEqual(2, catalog.Modules.First().DependsOn.Count);
  338. Assert.AreEqual("DependsOn1", catalog.Modules.First().DependsOn[0]);
  339. Assert.AreEqual("DependsOn2", catalog.Modules.First().DependsOn[1]);
  340. }
  341. [TestMethod]
  342. public void CanAddModule3()
  343. {
  344. ModuleCatalog catalog = new ModuleCatalog();
  345. catalog.AddModule(typeof (MockModule), InitializationMode.OnDemand, "DependsOn1", "DependsOn2");
  346. Assert.AreEqual(1, catalog.Modules.Count());
  347. Assert.AreEqual("MockModule", catalog.Modules.First().ModuleName);
  348. Assert.AreEqual(typeof(MockModule).AssemblyQualifiedName, catalog.Modules.First().ModuleType);
  349. Assert.AreEqual(InitializationMode.OnDemand, catalog.Modules.First().InitializationMode);
  350. Assert.AreEqual(2, catalog.Modules.First().DependsOn.Count);
  351. Assert.AreEqual("DependsOn1", catalog.Modules.First().DependsOn[0]);
  352. Assert.AreEqual("DependsOn2", catalog.Modules.First().DependsOn[1]);
  353. }
  354. [TestMethod]
  355. public void CanAddModule4()
  356. {
  357. ModuleCatalog catalog = new ModuleCatalog();
  358. catalog.AddModule(typeof(MockModule), "DependsOn1", "DependsOn2");
  359. Assert.AreEqual(1, catalog.Modules.Count());
  360. Assert.AreEqual("MockModule", catalog.Modules.First().ModuleName);
  361. Assert.AreEqual(typeof(MockModule).AssemblyQualifiedName, catalog.Modules.First().ModuleType);
  362. Assert.AreEqual(InitializationMode.WhenAvailable, catalog.Modules.First().InitializationMode);
  363. Assert.AreEqual(2, catalog.Modules.First().DependsOn.Count);
  364. Assert.AreEqual("DependsOn1", catalog.Modules.First().DependsOn[0]);
  365. Assert.AreEqual("DependsOn2", catalog.Modules.First().DependsOn[1]);
  366. }
  367. [TestMethod]
  368. public void CanAddGroup()
  369. {
  370. ModuleCatalog catalog = new ModuleCatalog();
  371. catalog.Items.Add(new ModuleInfoGroup());
  372. catalog.AddGroup(InitializationMode.OnDemand, "Ref1",
  373. new ModuleInfo("M1", "T1"),
  374. new ModuleInfo("M2", "T2", "M1"));
  375. Assert.AreEqual(2, catalog.Modules.Count());
  376. var module1 = catalog.Modules.First();
  377. var module2 = catalog.Modules.Skip(1).First();
  378. Assert.AreEqual("M1", module1.ModuleName);
  379. Assert.AreEqual("T1", module1.ModuleType);
  380. Assert.AreEqual("Ref1", module1.Ref);
  381. Assert.AreEqual(InitializationMode.OnDemand, module1.InitializationMode);
  382. Assert.AreEqual("M2", module2.ModuleName);
  383. Assert.AreEqual("T2", module2.ModuleType);
  384. Assert.AreEqual("Ref1", module2.Ref);
  385. Assert.AreEqual(InitializationMode.OnDemand, module2.InitializationMode);
  386. }
  387. private class TestableModuleCatalog : ModuleCatalog
  388. {
  389. public bool ValidateCalled { get; set; }
  390. public bool LoadCalledFirst { get; set; }
  391. public bool LoadCalled
  392. {
  393. get { return LoadCalledCount > 0; }
  394. }
  395. public int LoadCalledCount { get; set; }
  396. public override void Validate()
  397. {
  398. ValidateCalled = true;
  399. Validated = true;
  400. }
  401. protected override void InnerLoad()
  402. {
  403. if (ValidateCalled == false && !LoadCalled)
  404. LoadCalledFirst = true;
  405. LoadCalledCount++;
  406. }
  407. }
  408. private static ModuleInfo CreateModuleInfo(string name, params string[] dependsOn)
  409. {
  410. ModuleInfo moduleInfo = new ModuleInfo(name, name);
  411. moduleInfo.DependsOn.AddRange(dependsOn);
  412. return moduleInfo;
  413. }
  414. }
  415. }