Microsoft Fakesとは？

本来、プログラムコードはまっとうなプログラマーが、まっとうなスケジュールで設計、実装すれば自然とテストしやすくなります。

しかしながら、我々は楽園には住んでいないので、さまざまな理由で名状しがたきプログラムコードは作成され、厳しい選択肢を突き付けられます。

選択①　トムデマルコのような管理者がプログラムを修正するようなスケジュールを引き直す。
選択②　オブジェクト指向を理解した増員が来て助けてくれる。
選択③　直せない。現実は非情である。

Microsoft Fakesはこのような非情な現実を突き付けられた者にとっての一助になります。

MicrosoftFakesのShim機能を使用することで、複雑に依存した機能を切り離して特定の箇所のみテストを実施することが可能になります。

Microsoft Fakes を使用したテストでのコードの分離
https://msdn.microsoft.com/ja-jp/library/hh549175.aspx

たとえば、データベースや別システムに通信するような機能のテストであっても、データベースや別システムがテストに都合のいいデータを返すように偽装できます。

たとえば、現在時刻に依存したテスト対象や、ユーザ名に依存したものでもテストに都合のいい現在時刻やユーザ名を偽装して返すことができます。

これにより、テスト対象に手を加えることなくテストを実施することが可能になります。

ただし、VisualStudio2013ではPremiume以上、VisualStudio2015ではEnterpriseのエディションが必要になります。

また基本的なVisualStudioでのテストコードの書き方は下記を参照してください。
http://qiita.com/mima_ita/items/55394bcc851eb8b6dc24

Microsoft Fakesを試す

環境構築

VisualStudioEnterpriseは下記のページから無料試用版を取得することができます。
https://www.visualstudio.com/ja/downloads/

なお、75万円くらいするのでなかなかハードルが高いです。

簡単なチュートリアル

(1)以下のような構成のプロジェクトを用意する

プロジェクト名	説明
ClassLibrary1	テスト対象
UnitTestProject1	テストプログラム

テスト対象

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ClassLibrary1
{
    public class Class1
    {
        private int a;
        public Class1(int a)
        {
            this.a = a;
        }
        public int Cal(int x, int y)
        {
            return a + x + y;
        }

    }

    public class Class2
    {
        Class1 c1 = new Class1(5);
        public int CallCal()
        {
            return c1.Cal(1, 2);
        }
    }
}

(2)テストプロジェクトの参照から偽装したいアセンブリを選択して右クリックをして「Fakesアセンブリに追加」を実行する。

(3)Fakesフォルダに拡張子がfakesのファイルが作成される。

構成管理にあげる場合は、このfakesファイルを上げること。

(4)テストコードの実装

テストコードの例

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Microsoft.QualityTools.Testing.Fakes;

namespace UnitTestProject1
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                var c2 = new ClassLibrary1.Class2();

                ClassLibrary1.Fakes.ShimClass1.AllInstances.CalInt32Int32 = (ClassLibrary1.Class1 obj, int x, int y) =>
                {
                    // c1.Cal(1, 2); が実行されていることを確認する
                    Assert.AreEqual(c2.c1, obj);
                    Assert.AreEqual(1, x);
                    Assert.AreEqual(2, y);

                    return 999999;
                };

                var act = c2.CallCal();

                // Shimで偽装した値が返ってくることを確認する。
                Assert.AreEqual(999999, act);
            }
        }
    }
}

(5)テストを実施するとShimで偽装した値が取得できることが確認できる。

Shimの使い方

Shimの対象

public/private/protectedのあらゆるスコープのメソッドを偽装できるが、privateの内部クラスや型をパラメータもしくは戻り値にする関数は偽装はできない。

偽装対象のクラス

    public class Class3
    {
        public int test1()
        {
            return 1;
        }

        public static int test2()
        {
            return 2;
        }
        private int test3()
        {
            return 3;
        }
        protected int test4()
        {
            return 5;
        }

        public class Test5Ret
        {
        }

        private Test5Ret test5()
        {
            return new Test5Ret();
        }

        private class Test6Ret
        { }

        // パラメータまたは戻り値が公開された型でないので偽装ができない。
        private Test6Ret test6()
        {
            return new Test6Ret();
        }
    }

Shimによる偽装の方法

        [TestMethod]
        public void TestMethod4()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                var c2 = new ClassLibrary1.Class2();

                ClassLibrary1.Fakes.ShimClass3.AllInstances.test1 = (ClassLibrary1.Class3 obj) =>
                {
                    return 11;
                };

                ClassLibrary1.Fakes.ShimClass3.test2 = () =>
                {
                    return 22;
                };

                ClassLibrary1.Fakes.ShimClass3.AllInstances.test3 = (ClassLibrary1.Class3 obj) =>
                {
                    return 33;
                };

                ClassLibrary1.Fakes.ShimClass3.AllInstances.test4 = (ClassLibrary1.Class3 obj) =>
                {
                    return 44;
                };

                ClassLibrary1.Fakes.ShimClass3.AllInstances.test5 = (ClassLibrary1.Class3 obj) =>
                {
                    return null;
                };

                //これは作られない。
                //ClassLibrary1.Fakes.ShimClass3.AllInstances.test6 = (ClassLibrary1.Class3 obj) =>
                //{
                //    return null;
                //};

            }
        }

Shimの関数名の作成ルール

偽装するための関数は以下の命名規則で作成される。

インスタンスのメソッドの場合：
【テスト対象の名前空間】.Fakes..Shim【クラス名】.AllInstances.【関数名】【パラメータ1の型】【パラメータ2の型】..【パラメータnの型】(クラスのインスタンス,パラメータ1,パラメータ2...)

スタティックのメソッドの場合：
【テスト対象の名前空間】.Fakes..Shim【クラス名】..【関数名】【パラメータ1の型]【パラメータ2の型】..【パラメータnの型】(パラメータ1,パラメータ2...)

プロパティの場合：
【テスト対象の名前空間】.Fakes..Shim【クラス名】.AllInstances.Get【プロパティ名】(クラス)
【テスト対象の名前空間】.Fakes..Shim【クラス名】.AllInstances.Set【プロパティ名】【パラメータの型】(クラスのインスタンス,パラメータ)

偽装対象の関数のパラメータ数分だけ名称がながくなるので注意が必要。
古いVS2012だと長すぎると偽装用の関数が作成されない。（256あたり？）
VS2015だと、後方の文字を切って適正な文字に変換しているようだ。

現在日付の偽装

現在日付はテストをするうえでやっかいだが、これも偽装できる。

(1)System.dllのfakesアセンブリを追加する。

(2)System.DateTime.Nowを偽装する。

        [TestMethod]
        public void TestMethod2()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                DateTime exp = new DateTime(2000, 10, 5);
                System.Fakes.ShimDateTime.NowGet = () =>
                {
                    return exp;
                };

                var act = System.DateTime.Now;

                Assert.AreEqual(exp, act);
            }
        }

現在ユーザやマシン名などのSysetem.Environmentを偽装する。

(1)Fakesフォルダの「mscorlib.fakes」を開く

(2)ShimGenerationにSystem.Environmentを追加する。

<Fakes xmlns="http://schemas.microsoft.com/fakes/2011/">
  <Assembly Name="mscorlib" Version="4.0.0.0"/>
  <ShimGeneration>
    <Add FullName="System.Environment"/>
  </ShimGeneration>  
</Fakes>

(3)リビルドを行う。

(4)下記のように偽装を行う。

        [TestMethod]
        public void TestMethod3()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                System.Fakes.ShimEnvironment.UserNameGet = () =>
                {
                    return "user";
                };
                System.Fakes.ShimEnvironment.MachineNameGet = () =>
                {
                    return "machine";
                };

                Assert.AreEqual("user", Environment.UserName);
                Assert.AreEqual("machine", Environment.MachineName);
            }
        }

内部クラスのメソッドを偽装

内部クラスはShim親クラス名.Shim内部クラス名という形で偽装が可能である。

内部クラス

    public class Class5
    {
        public class Class5Inner
        {
            public int Test5Inner()
            {
                return 5;
            }
        }
    }

内部クラスのメソッドを偽装

        [TestMethod]
        public void TestMethod5()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                ClassLibrary1.Fakes.ShimClass5.ShimClass5Inner.AllInstances.Test5Inner = (ClassLibrary1.Class5.Class5Inner obj) =>
                {
                    return 99;
                };
                var o = new ClassLibrary1.Class5.Class5Inner();
                Assert.AreEqual(99, o.Test5Inner());
            }
        }

ベースクラスのメソッドを偽装

ベースクラスの偽装はベースクラス自体を偽装する必要がある。継承先のShimにはベースクラスのメソッドは存在しない。

テスト対象

    public class Class6Base
    {
        protected int Test6Base()
        {
            return 6;
        }
    }

    public class Class6: Class6Base
    {
        public int Test6BasePlus1()
        {
            return base.Test6Base() + 1;
        }
    }

テストコード

        [TestMethod]
        public void TestMethod6()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                ClassLibrary1.Fakes.ShimClass6Base.AllInstances.Test6Base = (ClassLibrary1.Class6Base obj) =>
                {
                    return 99;
                };
                var o = new ClassLibrary1.Class6();
                Assert.AreEqual(100, o.Test6BasePlus1());
            }
        }

ジェネリックメソッドの偽装方法

ジェネリックメソッドの偽装方法は型を指定したShimを作成する必要がある。

テスト対象

    public static class Class7
    {
        /// <summary>
        /// xとyを入れ替える
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="x"></param>
        /// <param name="y"></param>
        static void Swap<T>(ref T x, ref T y)
        {
            T temp;
            temp = x;
            y = x;
            x = temp;
        }

        public static void Test7()
        {
            int x = 1;
            int y = 9;
            Swap(ref x, ref y);
        }
    }

テストコード

        [TestMethod]
        public void TestMethod7()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                bool callSwap = false;
                ClassLibrary1.Fakes.ShimClass7.SwapOf1M0RefM0Ref<int>((ref int x, ref int y) =>
                {
                    // 
                    callSwap = true;
                    Assert.AreEqual(1, x);
                    Assert.AreEqual(9, y);
                    return;
                });
                ClassLibrary1.Class7.Test7();
                Assert.AreEqual(true, callSwap);
            }
        }

ジェネリッククラスの偽装

ジェネリッククラスのShimを使うにはShimクラス名<型>を定義する必要がある。

偽装対象

    public class Class8<K, V>
    {
        public K key {set; get;}
        public V value { set; get; }

        public void Log()
        {
            Console.WriteLine(key.ToString() + value.ToString());
        }
    }

テストコード

       [TestMethod]
        public void TestMethod8()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                bool callLog = false;

                ClassLibrary1.Fakes.ShimClass8<int,string>.AllInstances.Log = (ClassLibrary1.Class8<int,string> obj) => 
                {
                    // 
                    callLog = true;
                };
                var o = new ClassLibrary1.Class8<int, string>();
                o.Log();
                Assert.AreEqual(true, callLog);
            }
        }

どう利用するか？

Shimは強力なツールであります。これにより多くのコードを通すことが可能になり、カバレッジも100%近くにすることができるかもしれません。

しかし、適切に実行が検証されないテストは、無意味です。
ここでは、この強力なツールをどう利用してコードの検証を行うかを考えてみます。

パラメータやShimを実行した際のオブジェクトの状態を確認するようにする。

Shimのパラメータをチェックすることで、渡された値が期待値通りか？実行時のオブジェクトが期待通りの状態か検査すべきです。

            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                ClassLibrary1.Fakes.ShimClass1.AllInstances.CalInt32Int32 = (ClassLibrary1.Class1 obj, int x, int y) =>
                {
                    // c1.Cal(1, 2); が実行されていることを確認する
                    Assert.AreEqual(1, x);
                    Assert.AreEqual(2, y);
                    // 実行時のClass1.xxxxが123であることを確認する
                    Assert.AreEqual(123, obj.xxxx);

                    return 999999;
                };
            }

実行回数または実行されたか否かの検査を行う

Shimの実行回数をカウントとするか、フラグで管理することによりShimが期待の回数実行されるかどうかを確認します。

        public void TestMethod10()
        {
            // ShimsContextのブロック内のみ偽装する。
            using (ShimsContext.Create())
            {
                int callCalCnt = 0;
                ClassLibrary1.Fakes.ShimClass1.AllInstances.CalInt32Int32 = (ClassLibrary1.Class1 obj, int x, int y) =>
                {
                    // 実行した回数を数える
                    ++callCalCnt;
                    return 999999;
                };

                var c2 = new ClassLibrary1.Class2();
                var act = c2.CallCal();
                Assert.AreEqual(1, callCalCnt, "c1.Calが1回実行されていることを確認");
            }
        }

複数回実行されるShimの場合

Shimが複数回実行される場合は、以下のようにリストで期待するパラメータとShimが返す値を設定します。

テスト対象

    public class Class11
    {
        private int x = 0;
        private int Inc(int i)
        {
            x += i;
            return x;
        }

        public int Test11()
        {
            int i = 0;
            i = Inc(5);
            i = Inc(i);
            i = Inc(i);
            return i;
        }
    }

テスト対象

        class ShimIncData
        {
            public int expParam { set; get; }
            public int returnVal { set; get; }
        }

        [TestMethod]
        public void TestMethod11()
        {
            using (ShimsContext.Create())
            {
                int callIncCnt = 0;
                var incShimDataList = new List<ShimIncData>();
                incShimDataList.Add(new ShimIncData
                {
                    expParam = 5,
                    returnVal = 6
                });
                incShimDataList.Add(new ShimIncData
                {
                    expParam = 6,
                    returnVal = 7
                });
                incShimDataList.Add(new ShimIncData
                {
                    expParam = 7,
                    returnVal = 8
                });

                ClassLibrary1.Fakes.ShimClass11.AllInstances.IncInt32 = (ClassLibrary1.Class11 obj, int i) =>
                {
                    // 実行した回数を数える
                    int ix = callIncCnt;
                    ++callIncCnt;

                    Assert.AreEqual(incShimDataList[ix].expParam, i);

                    // 
                    return incShimDataList[ix].returnVal;
                };

                var o = new ClassLibrary1.Class11();
                var act = o.Test11();

                Assert.AreEqual(3, callIncCnt, "Incが3回実行されること");
                Assert.AreEqual(8, act);
            }
        }

今回は回数で返す値を替えたが、分岐を作ってパラメータが～だったら～を返すという方法でもいいでしょう。

まとめ

Microsoft Fakesを使用するとテスト対象の依存先のコードを偽装することができます。
これにより、テスト対象に手を加えずにテストコードを記述することができます。

概要

この記事ではVisualStudioインストール時に導入されるMsTestの使用方法について解説する。

参考：

単体テストの基本
https://msdn.microsoft.com/ja-jp/library/hh694602.aspx

環境：
VisualStudio Community 2013

簡単なテストプロジェクト

1.VisualStudioにてテストプロジェクトを追加する。

2.UnitTestを記述する。

UnitTest1.cs

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTestSample
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            int exp = 10;
            int act = 5 + 5;
            Assert.AreEqual(exp, act);
        }
    }
}

3.テストを実行する

4.テストエクスプローラーで結果を確認

コマンドラインからのテストの実行

継続的インテグレーションにMsTestを組み込む場合、コマンドラインにてMsTestを実行する必要がある。

注意
下記の情報は古いです。Microsoft Fakesを使用するには「VSTest.Console.exe」を使用しましょう。
https://msdn.microsoft.com/ja-jp/library/ms182486.aspx

# 環境変数の設定
"C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\Tools\VsDevCmd.bat"

# テストの実行
mstest /testcontainer:UnitTestSample\UnitTestSample\bin\Debug\UnitTestSample.dll

環境変数の設定で実行しているバッチファイルは、「開発者コマンド プロンプト for VS2013」で実行しているバッチと同じものである。

mstestはテストを実行するコマンドである。
/testcontainerのあとにテストプロジェクトが作成した、DLLを指定する。
その他、MsTestの使用方法については下記のヘルプコマンドで確認のこと。

mstest /help

標準出力の出力例：

Microsoft(R) Test Execution Command Line Tool Version 12.0.21005.1
Copyright (c) Microsoft Corporation. All rights reserved.

UnitTestSample\UnitTestSample\bin\Debug\UnitTestSample.dll を読み込んでいます...
実行を開始しています...

結果            トップ レベルのテスト
--            -----------
成功            UnitTestSample.UnitTest1.TestMethod1
1/1 テスト 成功

概要
--
テストの実行 完了 です。
  成功  1
  -----
  合計  1
結果ファイル:C:\Users\xxxx\Documents\Visual Studio 2013\Projects\Sample\TestResults\XXX-YYYY-PC 2015-05-26 17_59_47.trx
テストの設定:既定のテストの設定

テストを実行することで、「TestResults」というフォルダがカレントディレクトリに作成されて、テスト結果とテストを行ったバイナリのコピーが格納される。
この際、作成されたテスト結果は「.trx」拡張子のファイルとなり、VisualStudioを使用して開くことで内容を確認できる。

このリストには、すべての列が表示されているわけではない。
列のヘッダを右クリックすることで、列の追加削除が行える。

また、この内容はXMLなので自前でパースしてExcelなどに結果を記述することも可能である。

テストエクスプローラーの機能

テストエクスプローラーでは任意の方法でテストをグループ化できる。

下記の例ではクラスごとにテストを分類したものである。

また、Category属性を使用することで、各テストメソッドに特徴を指定でき分類が可能になる。

[TestMethod, TestCategory("カテゴリ1"), TestCategory("カテゴリ2")]
public void 足し算の確認()
{
}

[TestMethod, TestCategory("カテゴリ1")]
public void 引き算の確認()
{
}

[TestMethod, TestCategory("カテゴリ3")]
public void 常にオッケーのテスト()
{
}

その他、テストエクスプローラーの各機能については下記を参照。
https://msdn.microsoft.com/ja-jp/library/hh694602.aspx#BKMK_Running_tests_in_Test_Explorer

様々なAssert機能

MsTestはAssertクラスで様々なAssertの方法を提供している。
もっとも単純なものは以下のように期待値、結果、メッセージを付与するものである。

Assert.AreEqual(expected, actual, message)
Expected: 期待値
Actual:実際の値
Message:アサーションが失敗した時のメッセージ。テスト結果にでる

このほかにも、浮動小数点をAreEqualする際に、許容範囲を指定できたり、Collectionに対しての検証も行える。

        [TestMethod]
        public void TestDouble()
        {
            double e = 1.5;
            double r = 1.51;
            Assert.AreEqual(e, r, 0.011); // 0.01だとNG
        }

       [TestMethod]
        public void TestCollection()
        {
            var expected = new List<int> { 1, 1, 2, 3, 4, 5};

            // 等価かどうか？
            // 2 つのコレクションが等価であるためには、同じ要素が同じ数だけ含まれている必要があります。要素の順番が一致している必要はありません。 2 つの要素が同一であるためには、その値が一致している必要があります。それぞれの要素が同一のオブジェクトを参照している必要はありません。
            CollectionAssert.AreEquivalent(expected, new List<int> { 1, 5, 4, 3, 2, 1 });

            // 同一であるか？
            CollectionAssert.AreEqual(expected, new List<int> { 1, 1, 2, 3, 4, 5 });

            // 一意であるか？
            CollectionAssert.AllItemsAreUnique(new List<int> { 1, 2, 3, 4, 5 });

            // 特定の値が含まれるか？
            CollectionAssert.Contains(new List<int> { 1, 2, 3, 4, 5 }, 3);

        }

詳細は下記を参照。

Assert クラス
https://msdn.microsoft.com/ja-jp/library/Microsoft.VisualStudio.TestTools.UnitTesting.Assert.aspx

CollectionAssert クラス
https://msdn.microsoft.com/ja-jp/library/microsoft.visualstudio.testtools.unittesting.collectionassert.aspx

テストコードをステップ実行する方法

下記のメニューをすることデバッグ実行が行える。
「テスト」 > 「デバッグ」 > 「選択したテスト」　又は 「すべてのテスト」

こうすることで、ブレイクポイントを指定した行で止めることができる。

テスト中の標準出力

以下のようにテストメソッドで標準出力をしたとする。

        [TestMethod]
        public void TestStdOut()
        {
            Console.WriteLine("stdout {0} {1}", 1, "text");
        }

この場合、テストエクスプローラーの結果で確認することができる。

「出力」をクリックすることで、テスト結果の詳細が表示されて、標準出力の箇所に該当の文字が出力される。

この内容は、コマンドラインで実行した場合に作成された「.trx」ファイルにも記録されている。

テスト結果.trx

<TestRun>
  <Results>
    ...
    <UnitTestResult ...>
      <Output>
        <StdOut>stdout 1 text</StdOut>
      </Output>
    </UnitTestResult>
  </Results>
</TestRun>

出力ウィンドウ には出力されないので注意すること。

出力ウィンドウに出力したい場合は、Traceメソッドで該当のメッセージを記述して、Debug実行を行うこと。

        [TestMethod]
        public void TestStdOut()
        {
            System.Diagnostics.Trace.WriteLine("test");
        }

なお、Debugではない通常のテストを実行した場合、この出力は行われない。

テストケース共通の初期処理と終了処理

テストクラスにおいて、各テストメソッドの初期処理と終了処理を共通化したい場合は、TestInitialize、TestCleanupなどを使用する。

以下では、このコードには、メソッド、クラス、およびアセンブリの初期化とクリーンアップの実行順序を制御する属性を実験したものとなる。

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTestSample
{
    [TestClass]
    public class UnitTest2
    {
        [TestMethod]
        public void TestMethod1()
        {
            System.Diagnostics.Trace.WriteLine("TestMethod1");
        }

        [TestMethod]
        public void TestMethod2()
        {
            System.Diagnostics.Trace.WriteLine("TestMethod2");
        }

        [AssemblyInitialize]
        public static void AssemblyInit(TestContext context)
        {
            // アセンブリ内のすべてのテストが実行される前に、アセンブリによって取得されるリソースを割り当てるために使用されるコードを含むメソッドを識別します。 
            System.Diagnostics.Trace.WriteLine("AssemblyInit " + context.TestName);
        }

        [AssemblyCleanup]
        public static void AssemblyCleanup()
        {
            // アセンブリ内のすべてのテストが実行された後、アセンブリによって取得されたリソースを開放するために使用されるコードを含むメソッドを識別します。
            System.Diagnostics.Trace.WriteLine("AssemblyCleanup");
        }

        [ClassInitialize]
        public static void ClassInit(TestContext context)
        {
            // テスト クラス内の任意のテストが実行される前に、テスト クラスによって使用されるリソースを割り当てるために使用する必要のあるコードを含むメソッドを識別します。 
            System.Diagnostics.Trace.WriteLine("ClassInit " + context.TestName);
        }

        [ClassCleanup]
        public static void ClassCleanup()
        {
            // テスト クラスのすべてのテストが実行された後、テスト クラスによって取得されたリソースを解放するために使用されるコードを含むメソッドを識別します。
            System.Diagnostics.Trace.WriteLine("ClassCleanup");
        }

        [TestInitialize]
        public void TestInitialize()
        {
            // テスト クラスのすべてのテストに必要なリソースの割り当ておよび構成を行うために、テストの前に実行するメソッドを識別します。
            System.Diagnostics.Trace.WriteLine("TestInitialize");
        }

        [TestCleanup]
        public void TestCelean()
        {
            // テストが実行された後、テスト クラス内のすべてのテストによって取得されたリソースを開放するために使用される必要のあるコードを含むメソッドを識別します。 
            System.Diagnostics.Trace.WriteLine("TestCelean");
        }

    }
}

デバッグ実行をした場合の、出力結果は以下のようになる。

AssemblyInit TestMethod1
'vstest.executionengine.x86.exe' (CLR v4.0.30319: UnitTestAdapter: Running test): 'C:\Windows\Microsoft.Net\assembly\GAC_32\System.Transactions\v4.0_4.0.0.0__b77a5c561934e089\System.Transactions.dll' が読み込まれました。シンボルの読み込みをスキップしました。モジュールは最適化されていて、デバッグ オプションの [マイ コードのみ] 設定が有効になっています。
'vstest.executionengine.x86.exe' (CLR v4.0.30319: UnitTestAdapter: Running test): 'C:\Windows\Microsoft.Net\assembly\GAC_32\System.EnterpriseServices\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.EnterpriseServices.dll' が読み込まれました。シンボルの読み込みをスキップしました。モジュールは最適化されていて、デバッグ オプションの [マイ コードのみ] 設定が有効になっています。
'vstest.executionengine.x86.exe' (CLR v4.0.30319: UnitTestAdapter: Running test): 'C:\Windows\Microsoft.Net\assembly\GAC_32\System.EnterpriseServices\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.EnterpriseServices.Wrapper.dll' が読み込まれました。シンボルの読み込みをスキップしました。モジュールは最適化されていて、デバッグ オプションの [マイ コードのみ] 設定が有効になっています。
'vstest.executionengine.x86.exe' (CLR v4.0.30319: UnitTestAdapter: Running test): 'C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Numerics\v4.0_4.0.0.0__b77a5c561934e089\System.Numerics.dll' が読み込まれました。シンボルの読み込みをスキップしました。モジュールは最適化されていて、デバッグ オプションの [マイ コードのみ] 設定が有効になっています。
ClassInit TestMethod1
TestInitialize
TestMethod1
TestCelean
TestInitialize
TestMethod2
TestCelean
ClassCleanup
AssemblyCleanup

TestInitialize,TestCeleanはテストメソッド毎に実行されことが確認できる。

テストデータの利用

MSTestではDataSource属性を使用することで、外部のファイルをテストデータとして使用できる。

前提

System.Dataが必要なので参照に追加しておくこと。

もっともシンプルな例

1.以下のようなtest.csvファイルを用意する。

test.csv

a,b,result
1,2,3
2,4,6
3,5,8

このCSVはCP932で保存する

2.CSVをテストプロジェクトの直下に配置する。

3.追加したCSVのプロパティで、テストデータを「出力ディレクトリ―」にコピーするようにする。

4.テストコードを記述する

        public TestContext TestContext { get; set; }

        [TestMethod]
        [DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", @"test.csv", "test#csv", DataAccessMethod.Sequential)]
        public void TestCsv()
        {
            int a = (int)TestContext.DataRow["a"];
            int b = (int)TestContext.DataRow["b"];
            int result = (int)TestContext.DataRow["result"];
            System.Diagnostics.Trace.WriteLine("TestCsv " + a + " " + b + " " + result);
            Assert.AreEqual(result, a + b);
        }

5.テストを実行すると、CSVを１行づつ順番によみこんでTestCsvを都度実行する。
デバッグ実行をすると以下のような出力がされ、順次実行されていることがわかる。

TestCsv 1 2 3
TestCsv 2 4 6
TestCsv 3 5 8

テストデータを格納するフォルダを指定する

実際にテストデータを配置する場合、プロジェクトの直下ではなくフォルダを構成して配置する。

DataSource属性には、|DataDirectory|を指定して、その後、プロジェクトからの相対パスを記述する。

        [TestMethod]
        [DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", @"|DataDirectory|\TestData\Test001\test.csv", "test#csv", DataAccessMethod.Sequential)]
        public void TestCsv()
        {
            int a = (int)TestContext.DataRow["a"];
            int b = (int)TestContext.DataRow["b"];
            int result = (int)TestContext.DataRow["result"];
            System.Diagnostics.Trace.WriteLine("TestCsv " + a + " " + b + " " + result);
            Assert.AreEqual(result, a + b);
        }

コマンドラインから実行した場合に、テストデータもコピーする。

コマンドラインからMSTestを実行すると、テスト結果のOutフォルダにdllなどが出力される。
この際、テストデータも出力したい場合は、DeploymentItem属性を使用する。

    [TestClass]
    [DeploymentItem(@"TestData\Test001\test.csv", @"TestData\Test001")]
    public class UnitTest1
    {
       // 略
    }

これにより、Outフォルダにdllと共にテストデータが出力される。

ランダムアクセスによるデータの読み込み

DataAccessMethod.Randomを実行することで、CSVをランダムな順番に読み込むことができる。

        [TestMethod]
        [DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV", @"|DataDirectory|\TestData\Test001\test.csv", "test#csv", DataAccessMethod.Random)]
        public void TestCsvRandom()
        {
            int a = (int)TestContext.DataRow["a"];
            int b = (int)TestContext.DataRow["b"];
            int result = (int)TestContext.DataRow["result"];
            System.Diagnostics.Trace.WriteLine("TestCsvRandom " + a + " " + b + " " + result);
            Assert.AreEqual(result, a + b);
        }

デバッグ出力の例:

TestCsvRandom 3 5 8
TestCsvRandom 1 2 3
TestCsvRandom 2 4 6

参考：
Data-driven troubles
http://www.codeproject.com/Articles/710072/Data-driven-troubles

未確定なテスト項目

現在、テストを一時的に無視したり、テストの成功・失敗の条件がわからない場合がある。
この時は、コメントアウトをしないで、明確に無視するなり、未確定とすべき。

テスト項目を一時的に無視する

ペンディングのテスト項目を実行させないで、警告を出力させたい場合がある。
この際は、Ignore属性を使用する。

未確定な物

Assert.Inconclusiveを使用する。

        [TestMethod]
        public void TestInconclusive()
        {
            Assert.AreEqual(1, 1);
            Assert.Inconclusive("Unable to determine success or failure");
        }

この場合も、Ignoreと同様に警告として扱われる。

Privateメソッドのテスト

Privateのメソッドについても、「PrivateObject」を利用することでテストが行える。

            var pbObj = new PrivateObject(_obj);
            var ret = pbObj.Invoke("privateAdd", 1, 2) as int?;
            Assert.AreEqual(3, ret);    

PrivateObject クラス
https://msdn.microsoft.com/ja-jp/library/ms245564(v=vs.110).aspx

例外のテスト方法

例外が発生する方法を確認する方法について説明する

ExpectedException属性を使用する

ExpectedExceptionは以下のように使用する

        [TestMethod()]
        [ExpectedException(typeof(System.DivideByZeroException))]
        public void DivideTest()
        {
            int x = 1;
            int y = 0;
            int r = x / y;
            System.Diagnostics.Trace.WriteLine(r);
        }    

System.DivideByZeroExceptionが発生した場合は成功、それ以外の場合は、テストは失敗する。
この方法でテストした場合、１メソッドについて、１例外しか確認できない。

自分でTry-catchして例外をテストする方法

自分でTry-catchして例外をテストする場合は、例外が発生しなかった場合に、Assert.Failを利用してテストを失敗させる。

ノーマルにMSTestを使おう
http://qiita.com/moonmile/items/269295ad5758fa69d203

        [TestMethod]
        public void DivideTest3()
        {
            try
            {
                int x = 0;
                int ans = 1 / x;
            }
            catch (System.DivideByZeroException ex)
            {
                // 例外が発生すればOK
                return;
            }
            // 別の例外が出た場合は、予期せぬ例外となって、テストの失敗となる。
            // 例外が発生ない場合は、以下のコードで例外を発生させる
            Assert.Fail("例外が発生しませんでした");
        }

例外を投げるメソッドのテストを確認する関数を作る方法

例外を投げるメソッドのテストを確認する関数を作り、確認することもできる。

[Visual Studio 2012, C#] ユニットテストのメモ
http://fernweh.jp/b/vs2012-unittesting

        // http://fernweh.jp/b/vs2012-unittesting/#id-1
        private E GetException<E>(Action action) where E : Exception
        {
            try
            {
                action();
                return null;
            }
            catch (E ex)
            {
                return ex;
            }
        }

        [TestMethod()]
        public void DivideTest2()
        {
            var ex = GetException<Exception>(
                delegate() {
                    int x = 0;
                    int y = 1 / x;
                }
            );
            Assert.AreEqual("System.DivideByZeroException", ex.GetType().FullName);
        }

タイムアウトの設定

タイムアウトは、個々のメソッドと全体に対して指定することができる。

個々のテストメソッドにタイムアウトを指定する

Timeoutにてミリ秒を指定することで、テストメソッド毎にタイムアウトを指定できる。
テスト中に指定した期間を超えた場合、NGとなる。

        [TestMethod]
        [Timeout(2000)]  // Milliseconds
        public void TestTimeout1()
        {
            // NG
            System.Threading.Thread.Sleep(10000);
        }

        [TestMethod]
        [Timeout(TestTimeout.Infinite)]
        public void TestTimeout2()
        {
            // OK
            System.Threading.Thread.Sleep(10000);
        }

テスト全体のタイムアウトの指定

テスト全体にタイムアウトを指定するには、テスト設定ファイルを作成する必要がある。
まず、ソリューションの [ソリューション項目] フォルダーで、テストの設定ファイルを追加する。

テスト設定ファイルを作成するウィザードが起動するので、タイムアウトの設定がでるまで、既定の値で次に進む。

その後、ウィザードを終了すると、ソリューションにテスト設定ファイルが追加される。

単体テストを実行する際に、この作成したテスト設定ファイルを適用して実行すると、タイムアウトが全体に適用される。

VisualStudioでテストする場合、「テスト」→「テスト設定」→「テスト設定ファイルの選択」を指定できる。

コマンドラインから実行する場合に、テスト設定ファイルを指定するには「/testsettings」を使用する。

MSTest /testcontainer:UnitTestSample\bin\Debug\UnitTestSample.dll　/testsettings:TestSettings1.testsettings

参考：
https://msdn.microsoft.com/ja-jp/library/ms243175.aspx

テスト結果に埋め込み可能な情報

いくつかの属性を使用することで、テスト結果のXMLに情報を埋め込むことが可能である。

Description属性

テストについての説明を指定するために使用される。

 [TestMethod]
 [Description("Test Case Description")]
 public void EnsureTestCaseValid()
 {      
 }

Owner属性

テストの維持、実行、およびデバッグの担当者を指定するために使用する。

        [TestMethod]
        [Owner("mitagaki")]
        public void 常にオッケーのテスト()
        {
            Assert.AreEqual(true, true, message: "常時オッケー");
            Console.WriteLine("常時OK");
        }

Priority属性

単体テストの優先順位を指定するために使用される。
MSTestはテスト実行時に優先順位で絞り込むことが可能である。

        [TestMethod]
        [Priority(1)]
        public void TestPriority1()
        {
        }

優先度の絞りこみには、minpriority,maxpriorityを用いる。

MSTest /testcontainer:UnitTestSample\bin\Debug\UnitTestSample.dll /minpriority:2 /maxpriority:3

Moq

単体テストを行う場合、クラス間の依存関係をなくすために、実際のオブジェクトの代わりにテスト用のオブジェクトを使用することがある。

Moqは、このテスト用のオブジェクトを簡単に作成するためのライブラリである。
https://github.com/Moq/moq4

インストール方法

パッケージマネージャコンソールから下記のコマンドを実行

PM> Install-Package Moq

簡単なサンプル

テスト対象

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CalcLib
{
    public interface IDataCalc
    {
        int GetData();
    }
    public class DataCalc : IDataCalc {
        virtual public int GetData() 
        {
            return 100;
        }
    }
    public class Calc
    {
        private IDataCalc _data;
        public Calc()
            : this(new DataCalc())
        {

        }

        public Calc(IDataCalc data)
        {
            _data = data;
        }

        public int IncData(int i)
        {
            return _data.GetData() + i;
        }
    }
}

既定のDataCalc をモックを使用して実装する。
モックで使うメソッドは、virtual でなければならない。

テストコード

        [TestMethod]
        public void モックのテスト()
        {
            var mock = new Mock<CalcLib.DataCalc>();
            mock.Setup(c => c.GetData()).Returns(
               5
            );
            var con = mock.Object;
            var o = new CalcLib.Calc(con);
            Assert.AreEqual(10, o.IncData(5));
        }

Microsoft Fakes

Microsoft Fakesでテストでのコードの分離がおこなえる。
https://msdn.microsoft.com/ja-jp/library/hh549175.aspx

しかし、Visual Studio Ultimate または Premiumが必要になる。

詳細は下記を参照。
http://qiita.com/mima_ita/items/9ebb0f40d3209f33a45d

コード カバレッジの計測

Ultimate、または、Premiumを購入しないと無理。
https://www.visualstudio.com/ja-jp/products/compare-visual-studio-products-vs.aspx

コードカバレッジを100％目指そうとすると、まず頓挫するので、相応のコストを支払う覚悟がなければ気にしなくていいかもしれない。

実際の使いかたは下記参照。
http://qiita.com/mima_ita/items/05ce44c3eb1fd6e9dd46#テストコードで保障されていない箇所を調べてテストコードを書く

Pex

Microsoftが開発中のPexを使用すると、検査対象のメソッドの単体テストのひな形を作成してくれる。

http://research.microsoft.com/en-us/projects/pex/

対象のメソッドを選択して「Generate Inputs /Outputs Table」を実行する。

すると、そのメソッドに対して入力と結果の一覧が作成できる。

これにより、単体テストのコードを作成したり、メソッドの内容を調べることが可能になる。
しかし、VisualStudio2013時点では、自動生成された項目をユニットテストとして保存できないようなので、導入するなら2015が出るまで待った方が良いだろう。

Using Pex and Microsoft Code Digger to Better Understand and Test Your Code
http://www.codeproject.com/Articles/583520/UsingplusPexplusandplusMicrosoftplusCodeplusDigger

Visual Studio 2015 の新機能: Pex はユニットテストの福音となるか!?
http://www.slideshare.net/yasuhikoy/pex-44098704