As mentioned in the previous Unit Test post (Unit Testing Registry access with RhinoMocks and SystemWrapper) it important to be able to Unit Test code that access the registry without really accessing the registry.

Prerequisites

• It is assumed you have read the previous post, Unit Testing Registry access with RhinoMocks and SystemWrapper and you are ready for the Registry Key example.
• It is assumed you have already heard of Mocking and interface-based design (see this post: Architecting a large application with interface-based architecture) that allows for mocking to occur.

Step 1 – Download SystemWrapper

You may have already done this when reading the previous post, if not do so now.

1. Go to https://github.com/jozefizso/SystemWrapper and download the latest dll or the latest source or add the SystemWrapper.Interfaces and SystemWrapper.Wrappers By jozef.izso
2. Copy the SystemInterface.dll and SystemWrapper.dll into your project (perhaps you already have a libs directory).
3. Add references to these two dlls in your release code.
4. Add a reference only to SystemInterface.dll in your Unit Test project.

Step 2 – Change your code to use Interfaces and Wrappers

Ok, so here we are going to start with an example. Here is an object that I wrote myself that uses the registry to check on which versions of .NET Framework are installed. It is currently using Registry and RegistryKey directly.

1. Find any place in your code where you use touch the system. For example, if you touch the registry, find any place you call Registry or RegistryKey objects or reference Microsoft.Win32.
   Hint: Use the search feature in your IDE.
2. Replace the reference with a reference to SystemWrapper and SystemInterfaces. For example, if replacingrRegistry code,
   SystemInterface.Microsoft.Win32
   SystemWrapper.Microsoft.Win32In the DotNetFramework.cs file above, there is a using statement to Microsoft.Win32. Our new using statements will be:
   ?

   1 2 3

   using System; using SystemInterface.Microsoft.Win32; using SystemWrapper.Microsoft.Win32;

3. For any object that touches the system, change that object to be instantiated using the interface. For example, replace RegistryKey objects with IRegistryKey objects.In the DotNetFramework.cs file, there is only one single line that needs to change to do this, line 113.
   This line…
   ?

   1	RegistryKey localKey = Registry.LocalMachine.OpenSubKey(dotNetRegPath);

   …changes to this line.

   ?

   1	IRegistryKey localKey = new RegistryWrap().LocalMachine.OpenSubKey(dotNetRegPath);

Step 3 – Allow for replacing the IRegistryKey objects

Create a property or function that allows you to replace the object you are mocking so you can pass in an object that is mocked.

This is done for you to some extent for registry access by using the IAccessTheRegistry interface.

1. Implementing the IAccessTheRegistry interface from the SystemInterface.Microsoft.Win32 namespace. You can add the following code to the DotNetFramework object.
   ?

   01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18

   #region IAccessTheRegistry Members   public IRegistryKey BaseKey {     get     {         if (null == _BaseKey)             _BaseKey = new RegistryWrap().LocalMachine;         return _BaseKey;     } } private IRegistryKey _BaseKey;   public void ChangeBaseKey(IRegistryKey inBaseKey) {     _BaseKey = inBaseKey; }   #endregion

   Note: Notice that the Property is read only. Instead of enabling the set ability, a function is created to allow you to change the IRegistryKey instance. This is by design and keeps you from making a mistake such as BaseKey = BaseKey.OpenSubkey(“…”) and replacing the BaseKey.

   Note: You may want to look into the “Factory” design pattern.

2. Change line 113 to use the BaseKey.
   ?

   1	IRegistryKey localKey = BaseKey.OpenSubKey(dotNetRegPath);

Step 4 – Download and Reference RhinoMocks in your Unit Test

You may have already done this when reading the previous post, if not do so now.

In this step you need to download RhinoMocks and reference it with your Unit Test project. If you don’t have a test project, create one.  Your release project won’t need it.

1. Go to http://hibernatingrhinos.com/open-source/rhino-mocks and download RhinoMocks.
2. Add RhinoMocks.dll

Step 5 – Mock IRegistryKey in your Unit Test

For this, you have to understand and know how to use RhinoMocks and this takes some learning. For this we need an example.

1. Add a new class to your test project.
2. Add a using statement:
   ?

   1	using Rhino.Mocks;

3. Add code to create the Mock objects.I put these in separate functions because every test needed the exact same code.
   1. Mock the HKLM key and any calls made using it.
   2. Mock the registry sub key and any calls made using it.
   ?

   01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

   #region Test Helper Functions         /// <summary>         /// Mock to pretend to be this registry subkey:         /// Hive:   HKLM         ///         /// No stubbing is preconfigured         /// </summary>         /// <returns>IRegistryKey</returns>         private IRegistryKey CreateMockOfHKLM()         {             // Mock to pretend to be this registry key:             // Hive:   HKLM             IRegistryKey hklmMock = MockRepository.GenerateMock<IRegistryKey>();             hklmMock.Stub(x => x.Name).Return("HKEY_LOCAL_MACHINE");               return hklmMock;         }           /// <summary>         /// Mock to pretend to be this registry subkey:         /// Hive:   HKLM         ///         /// It has stubs preconfigured         /// </summary>         /// <returns>IRegistry that is a mock of HKLM with IIS Version stubs.</returns>         private IRegistryKey CreateDotNetRegistryOpenSubKeyMock(string inSubkey, bool inIsInstalled = true, int? inSP = null)         {             // Mock to pretend to be this registry subkey:             // Hive:   HKLM             IRegistryKey hklmMock = CreateMockOfHKLM();               // Allow to test a key that doesn't exist (null) or one that does.             IRegistryKey dotNetMock = null;             if (inIsInstalled)             {                 dotNetMock = CreateDotNetRegistryGetValueMock(inSubkey, inSP);             }               // Stubs using hklmMock to open and return this registry key             // and return dotNetMock:             hklmMock.Stub(x => x.OpenSubKey(inSubkey)).Return(dotNetMock);               return hklmMock;         }           private IRegistryKey CreateDotNetRegistryGetValueMock(string inSubkey, int? inSP)         {             // Mock to pretend to be this subkey passed in:             // Hive:   HKLM             // SubKey: HKEY_LOCAL_MACHINE\" + inSubkey             IRegistryKey dotNetMock = MockRepository.GenerateMock<IRegistryKey>();             dotNetMock.Stub(x => x.Name).Return(@"HKEY_LOCAL_MACHINE\" + inSubkey);               // Stubs checking the available registry properties:             // Hive:   HKLM             // SubKey: HKEY_LOCAL_MACHINE\" + inSubkey             // Properties: "Install", "SP"             dotNetMock.Stub(x => x.GetValueNames()).Return(new String[] { "Install", "SP" });               // Stubs checking this registry:             // Hive:   HKLM             // SubKey: HKEY_LOCAL_MACHINE\" + inSubkey             // Property: Install             // Value:  1 - If not installed the whole key shouldn't even exist so it should always be 1             dotNetMock.Stub(x => x.GetValue("Install")).Return(1);               if (null != inSP)             {                 // Stubs checking this registry:                 // Hive:   HKLM                 // SubKey: HKEY_LOCAL_MACHINE\" + inSubkey                 // Property: SP                 // Value:    null or 1, 2, 3, ...                 dotNetMock.Stub(x => x.GetValue("SP")).Return(inSP);             }             return dotNetMock;         }         #endregion

4. Now go forth and mock all your code that uses the Registry.

Here is the final test file.

Return to C# Unit Test Tutorial