mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/ContractBasedImportDefinitionTests.cs

   1 //------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 //------------------------------------------------------------\r
   4 using System;\r
   5 using System.ComponentModel.Composition;\r
   6 using System.Collections.Generic;\r
   7 using System.Linq;\r
   8 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
   9 using System.Linq.Expressions;\r
  10 using System.UnitTesting;\r
  11 using System.ComponentModel.Composition.Factories;\r
  12 using System.ComponentModel.Composition.UnitTesting;\r
  13 using System.ComponentModel.Composition.Primitives;\r
  14 using System.ComponentModel.Composition.Hosting;\r
  15 \r
  16 namespace System.ComponentModel.Composition\r
  17 {\r
  18     [TestClass]\r
  19     public class ContractBasedImportDefinitionTests\r
  20     {\r
  21         [TestMethod]\r
  22         public void Constructor1_ShouldSetRequiredMetadataPropertyToEmptyEnumerable()\r
  23         {\r
  24             var definition = new NoOverridesContractBasedImportDefinition();\r
  25 \r
  26             EnumerableAssert.IsEmpty(definition.RequiredMetadata);\r
  27         }\r
  28 \r
  29         [TestMethod]\r
  30         public void Constructor1_ShouldSetCardinalityPropertyToExactlyOne()\r
  31         {\r
  32             var definition = new NoOverridesContractBasedImportDefinition();\r
  33 \r
  34             Assert.AreEqual(ImportCardinality.ExactlyOne, definition.Cardinality);\r
  35         }\r
  36 \r
  37         [TestMethod]\r
  38         public void Constructor1_ShouldSetIsPrerequisitePropertyToTrue()\r
  39         {\r
  40             var definition = new NoOverridesContractBasedImportDefinition();\r
  41 \r
  42             Assert.IsTrue(definition.IsPrerequisite);\r
  43         }\r
  44 \r
  45         [TestMethod]\r
  46         public void Constructor1_ShouldSetIsRecomposablePropertyToFalse()\r
  47         {\r
  48             var definition = new NoOverridesContractBasedImportDefinition();\r
  49 \r
  50             Assert.IsFalse(definition.IsRecomposable);\r
  51         }\r
  52 \r
  53         [TestMethod]\r
  54         public void Constructor1_ShouldSetRequiredCreationPolicyToAny()\r
  55         {\r
  56             var definition = new NoOverridesContractBasedImportDefinition();\r
  57 \r
  58             Assert.AreEqual(CreationPolicy.Any, definition.RequiredCreationPolicy);\r
  59         }\r
  60 \r
  61         [TestMethod]\r
  62         public void Constructor1_ShouldSetRequiredTypeIdentityToNull()\r
  63         {\r
  64             var definition = new NoOverridesContractBasedImportDefinition();\r
  65 \r
  66             Assert.IsNull(definition.RequiredTypeIdentity);\r
  67         }\r
  68 \r
  69         [TestMethod]\r
  70         public void Constructor2_NullAsContractNameArgument_ShouldThrowArgumentNull()\r
  71         {\r
  72             ExceptionAssert.ThrowsArgument<ArgumentNullException>("contractName", () =>\r
  73             {\r
  74                 new ContractBasedImportDefinition((string)null, (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);\r
  75             });\r
  76         }\r
  77 \r
  78         [TestMethod]\r
  79         public void Constructor2_EmptyStringAsContractNameArgument_ShouldThrowArgument()\r
  80         {\r
  81             ExceptionAssert.ThrowsArgument<ArgumentException>("contractName", () =>\r
  82             {\r
  83                 new ContractBasedImportDefinition("", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);\r
  84             });\r
  85         }\r
  86 \r
  87         [TestMethod]\r
  88         public void RequiredMetadata_ArrayWithNullKeyAsRequiredMetadataArgument_ShouldThrowInvalidOperation()\r
  89         {\r
  90             var requiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>(null, typeof(object)) };\r
  91 \r
  92             var import = new ContractBasedImportDefinition("requiredMetadata", (string)null, requiredMetadata, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);\r
  93 \r
  94             ExceptionAssert.Throws<InvalidOperationException>(() =>\r
  95             {\r
  96                 var m = import.RequiredMetadata;\r
  97             });\r
  98         }\r
  99 \r
 100         [TestMethod]\r
 101         public void RequiredMetadata_ArrayWithNullValueAsRequiredMetadataArgument_ShouldThrowInvalidOperation()\r
 102         {\r
 103             var requiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("key", null) };\r
 104             var import = new ContractBasedImportDefinition("requiredMetadata", (string)null, requiredMetadata, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);\r
 105 \r
 106             ExceptionAssert.Throws<InvalidOperationException>(() =>\r
 107             {\r
 108                 var m = import.RequiredMetadata;\r
 109             });\r
 110         }\r
 111 \r
 112 \r
 113         [TestMethod]\r
 114         public void Constructor2_NullAsRequiredMetadataArgument_ShouldSetRequiredMetadataToEmptyEnumerable()\r
 115         {\r
 116             var definition = new ContractBasedImportDefinition("requiredMetadata", (string)null, (IEnumerable<KeyValuePair<string, Type>>)null, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);\r
 117 \r
 118             EnumerableAssert.IsEmpty(definition.RequiredMetadata);\r
 119         }\r
 120 \r
 121         [TestMethod]\r
 122         public void Constructor2_OutOfRangeValueAsCardinalityArgument_ShouldThrowArgument()\r
 123         {\r
 124             var expectations = Expectations.GetInvalidEnumValues<ImportCardinality>();\r
 125 \r
 126             foreach (var e in expectations)\r
 127             {\r
 128                 ExceptionAssert.ThrowsArgument<ArgumentException>("cardinality", () =>\r
 129                 {\r
 130                     new ContractBasedImportDefinition((string)null, (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), e, false, false, CreationPolicy.Any);\r
 131                 });\r
 132             }\r
 133         }\r
 134 \r
 135         [TestMethod]\r
 136         public void Constructor2_ValueAsCardinalityArgument_ShouldSetCardinalityProperty()\r
 137         {\r
 138             var expectations = Expectations.GetEnumValues<ImportCardinality>();\r
 139 \r
 140             foreach (var e in expectations)\r
 141             {\r
 142                 var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), e, false, false, CreationPolicy.Any);\r
 143 \r
 144                 Assert.AreEqual(e, definition.Cardinality);\r
 145             }\r
 146         }\r
 147 \r
 148         [TestMethod]\r
 149         public void Constructor2_ValueAsContractNameArgument_ShouldSetContractNameProperty()\r
 150         {\r
 151             var expectations = Expectations.GetContractNames();\r
 152 \r
 153             foreach (var e in expectations)\r
 154             {\r
 155                 var definition = new ContractBasedImportDefinition(e, (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);\r
 156 \r
 157                 Assert.AreEqual(e, definition.ContractName);\r
 158             }\r
 159         }\r
 160 \r
 161         [TestMethod]\r
 162         public void Constructor2_ValueAsRequiredMetadataArgument_ShouldSetRequiredMetadataProperty()\r
 163         {\r
 164             var expectations = Expectations.GetRequiredMetadataWithEmpty();\r
 165 \r
 166             foreach (var e in expectations)\r
 167             {\r
 168                 var definition = new ContractBasedImportDefinition("ContractName", (string)null, e, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any);\r
 169 \r
 170                 EnumerableAssert.AreEqual(e, definition.RequiredMetadata);\r
 171             }\r
 172         }\r
 173 \r
 174         [TestMethod]\r
 175         public void Constructor2_ValueAsIsRecomposableArgument_ShouldSetIsRecomposableProperty()\r
 176         {\r
 177             var expectations = Expectations.GetBooleans();\r
 178 \r
 179             foreach (var e in expectations)\r
 180             {\r
 181                 var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, e, false, CreationPolicy.Any);\r
 182 \r
 183                 Assert.AreEqual(e, definition.IsRecomposable);\r
 184             }\r
 185         }\r
 186 \r
 187         [TestMethod]\r
 188         public void Constructor2_ValueAsIsPrerequisiteArgument_ShouldSetIsPrerequisiteProperty()\r
 189         {\r
 190             var expectations = Expectations.GetBooleans();\r
 191 \r
 192             foreach (var e in expectations)\r
 193             {\r
 194                 var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, false, e, CreationPolicy.Any);\r
 195 \r
 196                 Assert.AreEqual(e, definition.IsPrerequisite);\r
 197             }\r
 198         }\r
 199 \r
 200         [TestMethod]\r
 201         public void Constructor2_ShouldSetRequiredCreationPolicyToAny()\r
 202         {\r
 203             var expectations = Expectations.GetEnumValues<CreationPolicy>();\r
 204 \r
 205             foreach (var e in expectations)\r
 206             {\r
 207                 var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty<KeyValuePair<string, Type>>(), ImportCardinality.ExactlyOne, false, false, e);\r
 208 \r
 209                 Assert.AreEqual(e, definition.RequiredCreationPolicy);\r
 210             }\r
 211         }\r
 212 \r
 213         [TestMethod]\r
 214         public void Constraint_ShouldIncludeContractNameProperty()\r
 215         {\r
 216             var expectations = Expectations.GetContractNames();\r
 217 \r
 218             foreach (var e in expectations)\r
 219             {\r
 220                 var definition = new ContractBasedImportDefinition(e, (string)null, (IEnumerable<KeyValuePair<string, Type>>)null, ImportCardinality.ExactlyOne, true, false, CreationPolicy.Any);\r
 221 \r
 222                 ConstraintAssert.Contains(definition.Constraint, e);\r
 223             }\r
 224         }\r
 225 \r
 226         [TestMethod]\r
 227         public void Constraint_ShouldIncludeRequiredMetadataProperty()\r
 228         {\r
 229             var expectations = Expectations.GetRequiredMetadataWithEmpty();\r
 230 \r
 231             foreach (var e in expectations)\r
 232             {\r
 233                 var definition = new ContractBasedImportDefinition("ContractName", (string)null, e, ImportCardinality.ExactlyOne, true, false, CreationPolicy.Any);\r
 234 \r
 235                 ConstraintAssert.Contains(definition.Constraint, "ContractName", e);\r
 236             }\r
 237         }\r
 238 \r
 239         [TestMethod]\r
 240         public void Constraint_ShouldIncludeOverriddenContractNameProperty()\r
 241         {\r
 242             var expectations = Expectations.GetContractNames();\r
 243 \r
 244             foreach (var e in expectations)\r
 245             {\r
 246                 var definition = new DerivedContractBasedImportDefinition(e);\r
 247 \r
 248                 ConstraintAssert.Contains(definition.Constraint, e);\r
 249             }\r
 250         }\r
 251 \r
 252         [TestMethod]\r
 253         public void Constraint_ShouldIncludeOverriddenRequiredMetadata()\r
 254         {\r
 255             var expectations = Expectations.GetRequiredMetadataWithEmpty();\r
 256 \r
 257             foreach (var e in expectations)\r
 258             {\r
 259                 var definition = new DerivedContractBasedImportDefinition("ContractName", e);\r
 260 \r
 261                 ConstraintAssert.Contains(definition.Constraint, "ContractName", e);\r
 262             }\r
 263         }\r
 264 \r
 265         [TestMethod]\r
 266         public void IsConstraintSatisfiedBy_ContractNameMatch()\r
 267         {\r
 268             var export = CreateSimpleExport();\r
 269             var import = CreateSimpleImport("ContractName", "ContractName", new string[0], new Type[0]);\r
 270             Assert.IsTrue(import.IsConstraintSatisfiedBy(export));\r
 271         }\r
 272 \r
 273         [TestMethod]\r
 274         public void IsConstraintSatisfiedBy_ContractNameMismatch()\r
 275         {\r
 276             var export = CreateSimpleExport();\r
 277             var import = CreateSimpleImport("NonContractName", "ContractName", new string[0], new Type[0]);\r
 278             Assert.IsFalse(import.IsConstraintSatisfiedBy(export));\r
 279         }\r
 280 \r
 281         [TestMethod]\r
 282         public void IsConstraintSatisfiedBy_TypeIdentityMismatch()\r
 283         {\r
 284             var export = CreateSimpleExport();\r
 285             var import = CreateSimpleImport("ContractName", "NonContractName", new string[0], new Type[0]);\r
 286             Assert.IsFalse(import.IsConstraintSatisfiedBy(export));\r
 287         }\r
 288 \r
 289         [TestMethod]\r
 290         public void IsConstraintSatisfiedBy_MetadataMatch()\r
 291         {\r
 292             var export = CreateSimpleExport();\r
 293             var import = CreateSimpleImport("ContractName", "ContractName", new string[]{"Int", "String", "Type"}, new Type[]{typeof(int), typeof(string), typeof(Type)});\r
 294             Assert.IsTrue(import.IsConstraintSatisfiedBy(export));\r
 295         }\r
 296 \r
 297         [TestMethod]\r
 298         public void IsConstraintSatisfiedBy_MetadataKeyMismatch()\r
 299         {\r
 300             var export = CreateSimpleExport();\r
 301             var import = CreateSimpleImport("ContractName", "ContractName", new string[] { "Int", "String1", "Type" }, new Type[] { typeof(int), typeof(string), typeof(Type) });\r
 302             Assert.IsFalse(import.IsConstraintSatisfiedBy(export));\r
 303         }\r
 304 \r
 305         [TestMethod]\r
 306         public void IsConstraintSatisfiedBy_MetadataTypeMatch()\r
 307         {\r
 308             var export = CreateSimpleExport();\r
 309             var import = CreateSimpleImport("ContractName", "ContractName", new string[] { "Int", "String", "Type" }, new Type[] { typeof(int), typeof(string), typeof(int) });\r
 310             Assert.IsFalse(import.IsConstraintSatisfiedBy(export));\r
 311         }\r
 312 \r
 313         private static ExportDefinition CreateSimpleExport()\r
 314         {\r
 315             var metadata = new Dictionary<string, object>();\r
 316             metadata.Add("Int", 42);\r
 317             metadata.Add("String", "42");\r
 318             metadata.Add("Type", typeof(string));\r
 319             metadata.Add(CompositionConstants.ExportTypeIdentityMetadataName, "ContractName");\r
 320             return new ExportDefinition("ContractName", metadata);\r
 321         }\r
 322 \r
 323         private static ContractBasedImportDefinition CreateSimpleImport(string contractName, string typeIdentity, string[] metadataKeys, Type[] metadataTypes)\r
 324         {\r
 325             Dictionary<string, Type> requiredMetadata = new Dictionary<string, Type>();\r
 326             Assert.AreEqual(metadataKeys.Length, metadataTypes.Length);\r
 327             for(int i=0; i< metadataKeys.Length; i++)\r
 328             {\r
 329                 requiredMetadata[metadataKeys[i]] = metadataTypes[i];\r
 330             }\r
 331             return new ContractBasedImportDefinition(contractName, typeIdentity, requiredMetadata, ImportCardinality.ZeroOrMore, false, false, CreationPolicy.Any);\r
 332             \r
 333         }\r
 334 \r
 335         private class NoOverridesContractBasedImportDefinition : ContractBasedImportDefinition\r
 336         {\r
 337             public NoOverridesContractBasedImportDefinition()\r
 338             {\r
 339             }\r
 340         }\r
 341 \r
 342         private class DerivedContractBasedImportDefinition : ContractBasedImportDefinition\r
 343         {\r
 344             private readonly string _contractName;\r
 345             private readonly IEnumerable<KeyValuePair<string, Type>> _requiredMetadata;\r
 346 \r
 347             public DerivedContractBasedImportDefinition(string contractName)\r
 348             {\r
 349                 _contractName = contractName;\r
 350             }\r
 351 \r
 352             public DerivedContractBasedImportDefinition(string contractName, IEnumerable<KeyValuePair<string, Type>> requiredMetadata)\r
 353             {\r
 354                 _contractName = contractName;\r
 355                 _requiredMetadata = requiredMetadata;\r
 356             }\r
 357 \r
 358             public override string ContractName\r
 359             {\r
 360                 get { return _contractName; }\r
 361             }\r
 362 \r
 363             public override IEnumerable<KeyValuePair<string, Type>> RequiredMetadata\r
 364             {\r
 365                 get { return _requiredMetadata; }\r
 366             }\r
 367         }\r
 368     }\r
 369 }\r
 370 \r