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

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