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

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.Collections.Generic;
   6 using System.ComponentModel.Composition;
   7 using Microsoft.VisualStudio.TestTools.UnitTesting;
   8 using System.UnitTesting;
   9 using System.ComponentModel.Composition.Factories;
  10 using System.ComponentModel.Composition.Primitives;
  11
  12 namespace System.ComponentModel.Composition
  13 {
  14     [TestClass]
  15     public class ExportDefinitionTests
  16     {
  17         [TestMethod]
  18         public void Constructor1_ShouldSetMetadataPropertyToEmptyDictionary()
  19         {
  20             var definition = new DerivedExportDefinition();
  21
  22             EnumerableAssert.IsEmpty(definition.Metadata);
  23         }
  24
  25         [TestMethod]
  26         public void Constructor1_ShouldSetMetadataPropertyToReadOnlyDictionary()
  27         {
  28             var definition = new DerivedExportDefinition();
  29
  30             ExceptionAssert.Throws<NotSupportedException>(() =>
  31             {
  32                 definition.Metadata["Value"] = "Value";
  33             });
  34         }
  35
  36         [TestMethod]
  37         public void Constructor2_NullAsContractNameArgument_ShouldThrowArgumentNull()
  38         {
  39             ExceptionAssert.ThrowsArgument<ArgumentNullException>("contractName", () =>
  40             {
  41                 new ExportDefinition((string)null, new Dictionary<string, object>());
  42             });
  43         }
  44
  45         [TestMethod]
  46         public void Constructor2_EmptyStringAsContractNameArgument_ShouldThrowArgument()
  47         {
  48             ExceptionAssert.ThrowsArgument<ArgumentException>("contractName", () =>
  49             {
  50                 new ExportDefinition(string.Empty, new Dictionary<string, object>());
  51             });
  52         }
  53
  54         [TestMethod]
  55         public void Constructor2_ValueAsContractNameArgument_ShouldSetContractNameProperty()
  56         {
  57             var expectations = Expectations.GetContractNames();
  58
  59             foreach (var e in expectations)
  60             {
  61                 var definition = new ExportDefinition(e, new Dictionary<string, object>());
  62
  63                 Assert.AreEqual(e, definition.ContractName);
  64             }
  65         }
  66
  67         [TestMethod]
  68         public void Constructor2_NullAsMetadataArgument_ShouldSetMetadataPropertyToEmptyDictionary()
  69         {
  70             var definition = new ExportDefinition("Contract", (IDictionary<string, object>)null); ;
  71
  72             EnumerableAssert.IsEmpty(definition.Metadata);
  73         }
  74
  75         [TestMethod]
  76         public void Constructor2_NullAsMetadataArgument_ShouldSetMetadataPropertyToReadOnlyDictionary()
  77         {
  78             var definition = new ExportDefinition("Contract", (IDictionary<string, object>)null);
  79
  80             ExceptionAssert.Throws<NotSupportedException>(() =>
  81             {
  82                 definition.Metadata["Value"] = "Value";
  83             });
  84         }
  85
  86         [TestMethod]
  87         public void Constructor2_WritableDictionaryAsMetadataArgument_ShouldSetMetadataPropertyToReadOnlyDictionary()
  88         {
  89             var definition = new ExportDefinition("Contract", new Dictionary<string, object>());
  90
  91             ExceptionAssert.Throws<NotSupportedException>(() =>
  92             {
  93                 definition.Metadata["Value"] = "Value";
  94             });
  95         }
  96
  97         [TestMethod]
  98         public void Constructor2_DictionaryAsMetadataArgument_ShouldSetMetadataProperty()
  99         {
 100             var expectations = Expectations.GetMetadata();
 101
 102             foreach (var e in expectations)
 103             {
 104                 var definition = new ExportDefinition("Contract", e);
 105
 106                 EnumerableAssert.AreEqual(e, definition.Metadata);
 107             }
 108         }
 109
 110         [TestMethod]
 111         public void ContractName_WhenNotOverridden_ShouldThrowNotImplemented()
 112         {
 113             var definition = new DerivedExportDefinition();
 114
 115             ExceptionAssert.Throws<NotImplementedException>(() =>
 116             {
 117                 var contractName = definition.ContractName;
 118             });
 119         }
 120
 121         [TestMethod]
 122         public void ToString_WhenContractNameNotOverridden_ShouldThrowNotImplemented()
 123         {
 124             var definition = new DerivedExportDefinition();
 125
 126             ExceptionAssert.Throws<NotImplementedException>(() =>
 127             {
 128                 definition.ToString();
 129             });
 130         }
 131
 132         [TestMethod]
 133         public void ToString_ShouldReturnContractNameProperty()
 134         {
 135             var expectations = Expectations.GetContractNames();
 136
 137             foreach (var e in expectations)
 138             {
 139                 var definition = new ExportDefinition(e, new Dictionary<string, object>());
 140
 141                 Assert.AreEqual(e, definition.ToString());
 142             }
 143         }
 144
 145         [TestMethod]
 146         public void ToString_ShouldReturnOverriddenContractNameProperty()
 147         {
 148             var expectations = Expectations.GetContractNamesWithEmpty();
 149
 150             foreach (var e in expectations)
 151             {
 152                 var definition = new DerivedExportDefinition(() => e);
 153
 154                 Assert.AreEqual(e, definition.ToString());
 155             }
 156         }
 157
 158         private class DerivedExportDefinition : ExportDefinition
 159         {
 160             private readonly Func<string> _contractNameGetter;
 161
 162             public DerivedExportDefinition()
 163             {
 164             }
 165
 166             public DerivedExportDefinition(Func<string> contractNameGetter)
 167             {
 168                 _contractNameGetter = contractNameGetter;
 169             }
 170
 171             public override string ContractName
 172             {
 173                 get
 174                 {
 175                     if (_contractNameGetter != null)
 176                     {
 177                         return _contractNameGetter();
 178                     }
 179
 180                     return base.ContractName;
 181                 }
 182             }
 183         }
 184     }
 185 }
 186