Testing a dismantled LINQ Expression

In my last Blog post I complained about my testability woes with LINQ expressions. Here are the test methods I used to track down the bug. Oh and I violated the coding conventions which tell us to use the “Should…” naming strategy for test methods. I’m a mean old man, tsk tsk tsk. ;-)

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using SharedComponents;
 
namespace ServiceLocatorTests
{
   [TestClass]
   public class ConfigFileTests
   {
      private string file = string.Empty;
 
      public ConfigFileTests()
      {
         file = Path.Combine(GetProjectPath(EnvironmentMode.UnitTests), "ServiceLocator.xml");
      }
 
      /// <summary>
      ///Gets or sets the test context which provides
      ///information about and functionality for the current test run.
      ///</summary>
      public TestContext TestContext { get; set; }
 
      [TestMethod]
      public void DoesTheFileExist()
      {
         Assert.IsTrue(File.Exists(file));
      }
 
      [TestMethod]
      public void CanTheElementsBeRead()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         Assert.IsNotNull(elements);
      }
 
      [TestMethod]
      public void CanTheAttributesBeRead()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         XElement element = elements.First();
         Assert.IsNotNull(element);
      }
 
      [TestMethod]
      public void IsTheFirstAttributeTheContract()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         XElement element = elements.First();
         Assert.AreEqual("contract", element.FirstAttribute.Name);
         Assert.AreEqual("SharedComponents.IMovieFinder, SharedComponents", element.FirstAttribute.Value);
      }
 
      [TestMethod]
      public void IsTheLastAttributeTheType()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         XElement element = elements.First();
         Assert.AreEqual("type", element.LastAttribute.Name);
         Assert.AreEqual("SharedComponents.MovieFinder, SharedComponents", element.LastAttribute.Value);
      }
 
      // Make sure the syntax is right.
      [TestMethod]
      public void CanTheAttributesBeResolvedByName()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         XElement element = elements.First();
         Assert.AreEqual("SharedComponents.IMovieFinder, SharedComponents",
            element.Attribute("contract").Value);
         Assert.AreEqual("SharedComponents.MovieFinder, SharedComponents",
            element.Attribute("type").Value);
      }
 
      // Make sure the syntax is right.
      [TestMethod]
      public void CanTheAttributesBeExtractedBySelect()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         var contracts = elements.Select(x => x.Attribute("contract").Value);
         var types = elements.Select(x => x.Attribute("type").Value);
         Assert.AreEqual(1, contracts.Count());
         Assert.AreEqual(1, types.Count());
      }
 
      [TestMethod]
      public void CanGetTypeHandleTheElement()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         var element = elements.First();
         var type = Type.GetType(element.Attribute("contract").Value);
         Assert.AreEqual(typeof(IMovieFinder), type);
      }
 
      [TestMethod]
      public void CanTheTypesBeResolvedCorrectly()
      {
         IEnumerable<XElement> elements = XElement.Load(file).Element("mappings").Elements("mapping");
         var contractType = elements.Select(x => Type.GetType(x.Attribute("contract").Value));
         var types = elements.Select(x => Type.GetType(x.Attribute("type").Value));
         Assert.AreEqual(typeof(IMovieFinder), contractType.First());
         Assert.AreEqual(typeof(MovieFinder), types.First());
      }
 
      #region Helpers
 
      /// <summary>
      /// Holt den Pfad zum aktuellen Projekt-Ordner.
      /// Dieses Property bitte nicht im Produktivcode benutzen.
      /// </summary>
      /// <returns>der Pfad zum aktuellen Projekt-Ordner.</returns>
      private string GetProjectPath(EnvironmentMode mode)
      {
         // Ergebnis: Debug- oder Release-Ordner im Projektordner.
         string projectPath = Environment.CurrentDirectory;
         // Mit jedem Durchlauf geht es im Verzeichnisbaum eine Stufe höher.
         for(int i = 0; i < (int)mode; i++)
         {
            projectPath = System.IO.Path.GetDirectoryName(projectPath);
         }
         return projectPath + @"\";
      }
 
      /// <summary>
      /// Je nach Umgebung variiert die Anzahl der Stufen,
      /// die in der Ordnerstruktur nach oben geklettert werden muß.
      /// </summary>
      private enum EnvironmentMode
      {
         /// <summary>
         /// Klettert in der Ordnerstruktur 2 Stufen nach oben.
         /// </summary>
         Regular = 2,
         /// <summary>
         /// Klettert in der Ordnerstruktur 3 Stufen nach oben.
         /// </summary>
         UnitTests
      }
 
      #endregion
   }
}
DotNetKicks-DE Image
Published Freitag, 30. Oktober 2009 17:52 von Rainer Hilmer
Abgelegt unter:

Kommentare

# Stripping down a convoluted LINQ expression

Samstag, 31. Oktober 2009 23:30 von Rainer Hilmers Developer-Blog

This is part 3 of my Blog posts about LINQ testability issues. You know what this is all about when you

# Lambda Expressions: Warum ich denke daß sie schnell gegen CCD –Prinzipien verstoßen

Donnerstag, 18. Februar 2010 13:16 von Rainer Hilmers Developer-Blog

Oft wird mir etwas unwohl wenn ich eine Lambda expression sehe. Lange Zeit wußte ich nur vage warum überhaupt

Kommentar abgeben

(verpflichtend) 
(verpflichtend) 
(optional)
(verpflichtend)