Release/v0.3.0 (#4)

* assert 処理を `TestActual` の責務として統合。
* `TestAA` の既定の assert ロジックを `TestAssert` によってインジェクションできるよう対応。
* `Assert()` の others パラメーターを削除。
* `Assert()` の @return と exception の評価順序を exception を先にするよう更新。
* `TestAssertException` を削除し、既定の `TestAssert` がテスト失敗時にスローする `TestAssertFailedException` を追加。
* readme を更新。

Author: in-async

README.md

@@ -18,7 +18,7 @@
 ```cs
 TestAA
     .Act(テスト対象コード)
-    .Assert(テスト対象コードの戻り値の検証, 例外の検証, その他の検証);
+    .Assert(テスト対象コードの戻り値の検証, 例外の検証);
 ```
 
 Arrange に相当する処理は `TestAA.Act()` の呼び出しより前に記述します。
@@ -30,7 +30,7 @@ Arrange に相当する処理は `TestAA.Act()` の呼び出しより前に記
 TestAA.Act(...)
 ```
 
-`Act()` の引数には、テスト対象となるメソッドまたはコードのラムダ式やデリゲートを渡して下さい。テストの対象ではないメソッドまたはコードも含めますと、そこから発生した例外がテスト対象コードから生じたものとして扱われてしまい、正しい検証が行えなくなります。
+`Act()` の引数には、テスト対象となるメソッドまたはコードのラムダ式やデリゲートを渡して下さい。テストの対象ではないメソッドやコードを含めますと、そこから発生した例外がテスト対象コードから生じたものとして扱われてしまい、正しい検証が行えなくなります。
 ```cs
 TestAA.Act(() => { /* ここでテスト対象のメソッドを呼ぶ */ })
 ```
@@ -39,63 +39,72 @@ TestAA.Act(() => { /* ここでテスト対象のメソッドを呼ぶ */ })
 ```cs
     .Act(() => int.Parse("123"))
     .Assert(
-        @return: ret => { /* ここで戻り値の検証 */ },
-        exception: ex => { /* ここで例外の検証。省略した場合、Act() で例外が生じていれば再スローされる */ },
-        others: () => { /* ここで上記以外の検証。不要なら省略 */ }
+        @return: ret => { /* ここで戻り値の検証。Act で例外が生じた場合は戻り値が無いので呼ばれない */ },
+        exception: ex => { /* ここで例外の検証 */ }
     );
 ```
 
+検証はラムダ式やデリゲートではなく値を直接入力する事でも可能です。テストの失敗は、既定では `TestAssertFailedException` のスローによって通知されます。
+```cs
+TestAA.Act(() => int.Parse("123")).Assert(123);  // OK
+TestAA.Act(() => int.Parse("abc")).Assert(ret => { }, new FormatException());  // OK
+TestAA.Act(() => int.Parse("abc")).Assert(123);  // TestAssertFailedException
+```
+
 
-## Usage
+## Examples
+### Basic
 ```cs
-public void IntParseTest() {
-    // Success
-    TestAA.Act(() => int.Parse("123")).Assert(
-        ret => ret.Is(123)
-    );
+TestAA.Act(() => int.Parse("123")).Assert(123);
+```
+### Exception
+```cs
+TestAA.Act(() => int.Parse("abc")).Assert(ret => { }, exception: new FormatException());
+```
 
-    // FormatException
-    TestAA.Act(() => int.Parse("abc")).Assert(
-        ret => { },
-        ex => ex?.GetType().Is(typeof(FormatException))
-    );
-}
+### Out parameter
+```cs
+int result = default;
+TestAA.Act(() => int.TryParse("123", out result)).Assert(true);
+
+// Additional Assert
+Assert.AreEqual(123, result);
 ```
 
-下記は *MSTest* を利用した、より実践的な例です：
+### Lambda assert
 ```cs
-[DataTestMethod]
-[DataRow(0, null, null, typeof(ArgumentNullException))]
-[DataRow(1, "123", 123, null)]
-[DataRow(2, "abc", null, typeof(FormatException))]
-public void IntParseTest(int testNumber, string input, int expected, Type expectedExceptionType) {
-    var msg = "No." + testNumber;
+TestAA.Act(() => int.Parse("123")).Assert(
+      @return: ret => Assert.AreEqual(123, ret)
+    , exception: ex => Assert.IsNull(ex)
+);
+```
 
-    TestAA.Act(() => int.Parse(input)).Assert(
-        ret => Assert.AreEqual(expected, ret, msg),
-        ex => Assert.AreEqual(expectedExceptionType, ex?.GetType(), msg)
-    );
+### Replace default assert
+```cs
+class MSTestAssert : TestAssert {
+    public override void Is<T>(T actual, T expected, string message) {
+        Assert.AreEqual(expected, actual, message);
+    }
 }
+...
+TestAA.TestAssert = new MSTestAssert();
+
+TestAA.Act(() => int.Parse("123")).Assert(123);  // Assert.AreEqual()
 ```
-または
+
+### Test cases
 ```cs
-[TestMethod]
-public void IntParseTest() {
-    Action TestCase(int testNumber, string input, int expected, Type expectedExceptionType = null) => () => {
-        var msg = "No." + testNumber;
-
-        TestAA.Act(() => int.Parse(input)).Assert(
-            ret => Assert.AreEqual(expected, ret, msg),
-            ex => Assert.AreEqual(expectedExceptionType, ex?.GetType(), msg)
-        );
-    };
-
-    foreach (var action in new[] {
-        TestCase( 0, null , expected: 0  , expectedExceptionType: typeof(ArgumentNullException)),
-        TestCase( 1, "abc", expected: 0  , expectedExceptionType: typeof(FormatException)),
-        TestCase( 2, "123", expected: 123),
-    }) { action(); }
-}
+Action TestCase(int testNumber, string input, int expected, Exception expectedException = null) => () => {
+    var msg = "No." + testNumber;
+
+    TestAA.Act(() => int.Parse(input)).Assert(expected, expectedException, msg);
+};
+
+foreach (var action in new[] {
+    TestCase( 0, null , expected: 0  , expectedException: new ArgumentNullException()),
+    TestCase( 1, "abc", expected: 0  , expectedException: new FormatException()),
+    TestCase( 2, "123", expected: 123),
+}) { action(); }
 ```
 
 

appveyor.yml

@@ -16,6 +16,6 @@ deploy:
     appveyor_repo_tag: true
 - provider: NuGet
   api_key:
-    secure: vQBIGqLxb5sEvl0To9hWNmzmzaXw4INcIDqrPjj5pjQoLuYQzDj9mrqEdJI6NZJK
+    secure: 5auKjaKm29nXAKSDhhZOM1V+1H+MsUwIRi8xw+vZa4t9rlhg2hHX+BExGh/8XOAd
   on:
     appveyor_repo_tag: true

src/Inasync.TestAA/Inasync.TestAA.csproj

@@ -8,8 +8,8 @@
     <Description>TestAA is a simple library to support writing tests using Arrange-Act-Assert (AAA) pattern.</Description>
     <PackageProjectUrl>https://github.com/in-async/TestAA</PackageProjectUrl>
     <PackageLicenseUrl>https://github.com/in-async/TestAA/blob/master/LICENSE</PackageLicenseUrl>
-    <PackageTags>library test unittest aaa</PackageTags>
-    <Version>0.2.1</Version>
+    <PackageTags>library test unittest AAA</PackageTags>
+    <Version>0.3.0</Version>
   </PropertyGroup>
 
 </Project>

src/Inasync.TestAA/TestAA.Act.cs

@@ -1,4 +1,7 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 
 namespace Inasync {
 
@@ -36,12 +39,66 @@ public static TestActual<TReturn> Act<TReturn>(Func<TReturn> act) {
             if (act == null) { throw new ArgumentNullException(nameof(act)); }
 
             try {
-                var @return = act();
-                return new TestActual<TReturn>(@return, exception: null);
+                var ret = act();
+                return new TestActual<TReturn>(@return: ret);
             }
             catch (Exception ex) {
-                return new TestActual<TReturn>(default, exception: ex);
+                return new TestActual<TReturn>(exception: ex);
             }
         }
     }
+
+    public static partial class TestAA {
+
+        /// <summary>
+        /// テスト対象の非同期デリゲートを同期的に実行します。
+        /// </summary>
+        /// <param name="act">テスト対象の非同期デリゲート。</param>
+        /// <returns>非同期デリゲートの実行結果。</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="act"/> is <c>null</c>.</exception>
+        public static TestActual Act(Func<Task> act) {
+            if (act == null) { throw new ArgumentNullException(nameof(act)); }
+
+            return Act(() => act().GetAwaiter().GetResult());
+        }
+
+        /// <summary>
+        /// テスト対象の非同期デリゲートを同期的に実行します。
+        /// </summary>
+        /// <typeparam name="TReturn">テスト対象の非同期デリゲートの戻り値の型。</typeparam>
+        /// <param name="act">テスト対象の非同期デリゲート。</param>
+        /// <returns>非同期デリゲートの実行結果。</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="act"/> is <c>null</c>.</exception>
+        public static TestActual<TReturn> Act<TReturn>(Func<Task<TReturn>> act) {
+            if (act == null) { throw new ArgumentNullException(nameof(act)); }
+
+            return Act(() => act().GetAwaiter().GetResult());
+        }
+
+        /// <summary>
+        /// テスト対象のデリゲートを実行し、戻り値のシーケンスを配列化します。
+        /// </summary>
+        /// <typeparam name="TItem">テスト対象のデリゲートが戻り値とするシーケンスの要素の型。</typeparam>
+        /// <param name="act">テスト対象のデリゲート。</param>
+        /// <returns>デリゲートの実行結果。</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="act"/> is <c>null</c>.</exception>
+        public static TestActual<TItem[]> Act<TItem>(Func<IEnumerable<TItem>> act) {
+            if (act == null) { throw new ArgumentNullException(nameof(act)); }
+
+            return Act(() => act().ToArray());
+        }
+
+        /// <summary>
+        /// テスト対象の非同期デリゲートを同期的に実行し、戻り値のシーケンスを配列化します。
+        /// </summary>
+        /// <typeparam name="TItem">テスト対象の非同期デリゲートが戻り値とするシーケンスの要素の型。</typeparam>
+        /// <param name="act">テスト対象の非同期デリゲート。</param>
+        /// <returns>非同期デリゲートの実行結果。</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="act"/> is <c>null</c>.</exception>
+        public static TestActual<TItem[]> Act<TItem>(Func<Task<IEnumerable<TItem>>> act) {
+            if (act == null) { throw new ArgumentNullException(nameof(act)); }
+
+            return Act(() => act().GetAwaiter().GetResult().ToArray());
+        }
+    }
 }