Release/v0.2.0 (#3)

* act の戻り値が `Task` や `IEnumerable<T>` の場合、`Act()` 内で即時実行して結果を確定するよう更新 (#1) * `ActAsync()` を削除 * `Assert()` の exception パラメーターを省略可能化。省略時に `TestActual` に例外が含まれていれば再スロー * テストを修正
in-async · Nov 15, 2019 · d83aa2f · d83aa2f
1 parent a46ce12
commit d83aa2f
Show file tree

Hide file tree

Showing 10 changed files with 331 additions and 184 deletions.
diff --git a/appveyor.yml b/appveyor.yml
@@ -16,6 +16,6 @@ deploy:
     appveyor_repo_tag: true
 - provider: NuGet
   api_key:
-    secure: zUlOhbjj+3Jsywco3QlyLXz4zSXS9fqQdEWTOCpmwzEl5cBLHFSrYnOR8xnNaSaB
+    secure: vQBIGqLxb5sEvl0To9hWNmzmzaXw4INcIDqrPjj5pjQoLuYQzDj9mrqEdJI6NZJK
   on:
     appveyor_repo_tag: true
diff --git a/src/Inasync.TestAA/Inasync.TestAA.csproj b/src/Inasync.TestAA/Inasync.TestAA.csproj
@@ -9,7 +9,7 @@
     <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.1.0</Version>
+    <Version>0.2.0</Version>
   </PropertyGroup>
 
 </Project>
diff --git a/src/Inasync.TestAA/TestAA.Act.cs b/src/Inasync.TestAA/TestAA.Act.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Threading.Tasks;
 
 namespace Inasync {
 
@@ -44,50 +43,5 @@ public static TestActual<TReturn> Act<TReturn>(Func<TReturn> act) {
                 return new TestActual<TReturn>(default, exception: ex);
             }
         }
-
-        /// <summary>
-        /// テスト対象の非同期デリゲートを実行します。
-        /// </summary>
-        /// <param name="act">テスト対象の非同期デリゲート。</param>
-        /// <returns>非同期デリゲートの実行結果。</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="act"/> is <c>null</c>.</exception>
-        public static Task<TestActual> ActAsync(Func<Task> act) {
-            if (act == null) { throw new ArgumentNullException(nameof(act)); }
-
-            return Internal();
-
-            async Task<TestActual> Internal() {
-                try {
-                    await act().ConfigureAwait(false);
-                    return new TestActual(exception: null);
-                }
-                catch (Exception ex) {
-                    return new TestActual(exception: ex);
-                }
-            }
-        }
-
-        /// <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 Task<TestActual<TReturn>> ActAsync<TReturn>(Func<Task<TReturn>> act) {
-            if (act == null) { throw new ArgumentNullException(nameof(act)); }
-
-            return Internal();
-
-            async Task<TestActual<TReturn>> Internal() {
-                try {
-                    var @return = await act().ConfigureAwait(false);
-                    return new TestActual<TReturn>(@return, exception: null);
-                }
-                catch (Exception ex) {
-                    return new TestActual<TReturn>(default, exception: ex);
-                }
-            }
-        }
     }
 }
diff --git a/src/Inasync.TestAA/TestAA.ActExtensions..cs b/src/Inasync.TestAA/TestAA.ActExtensions..cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Inasync {
+
+    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());
+        }
+    }
+}
diff --git a/src/Inasync.TestAA/TestAA.Assert.cs b/src/Inasync.TestAA/TestAA.Assert.cs
@@ -8,13 +8,14 @@ public static partial class TestAA {
         /// Act の実行結果を検証します。
         /// </summary>
         /// <param name="actual">Act の実行結果。</param>
-        /// <param name="exception">Act で生じた例外を検証するデリゲート。</param>
-        /// <param name="others">その他の Act の実行結果を検証するデリゲート。</param>
-        /// <exception cref="ArgumentNullException"><paramref name="exception"/> is <c>null</c>.</exception>
-        public static void Assert(this TestActual actual, Action<Exception> exception, Action others = null) {
-            if (exception == null) { throw new ArgumentNullException(nameof(exception)); }
+        /// <param name="exception">Act で生じた例外を検証するデリゲート。<c>null</c> の場合、<paramref name="actual"/> に例外が含まれていれば再スローされる。</param>
+        /// <param name="others">その他の Act の実行結果を検証するデリゲート。追加の検証が必要なければ <c>null</c>。</param>
+        public static void Assert(this TestActual actual, Action<Exception> exception = null, Action others = null) {
+            if (exception != null) {
+                exception(actual.Exception);
+            }
+            else if (actual.Exception != null) { throw actual.Exception; }
 
-            exception(actual.Exception);
             others?.Invoke();
         }
 
@@ -24,19 +25,22 @@ public static void Assert(this TestActual actual, Action<Exception> exception, A
         /// <typeparam name="TReturn">Act の戻り値の型。</typeparam>
         /// <param name="actual">Act の実行結果。</param>
         /// <param name="return">Act の戻り値を検証するデリゲート。</param>
-        /// <param name="exception">Act で生じた例外を検証するデリゲート。</param>
-        /// <param name="others">その他の Act の実行結果を検証するデリゲート。</param>
-        /// <exception cref="ArgumentNullException"><paramref name="return"/> or <paramref name="exception"/> is <c>null</c>.</exception>
-        public static void Assert<TReturn>(this TestActual<TReturn> actual, Action<TReturn> @return, Action<Exception> exception, Action others = null) {
+        /// <param name="exception">Act で生じた例外を検証するデリゲート。<c>null</c> の場合、<paramref name="actual"/> に例外が含まれていれば再スローされる。</param>
+        /// <param name="others">その他の Act の実行結果を検証するデリゲート。追加の検証が必要なければ <c>null</c>。</param>
+        /// <exception cref="ArgumentNullException"><paramref name="return"/> is <c>null</c>.</exception>
+        public static void Assert<TReturn>(this TestActual<TReturn> actual, Action<TReturn> @return, Action<Exception> exception = null, Action others = null) {
             if (@return == null) { throw new ArgumentNullException(nameof(@return)); }
-            if (exception == null) { throw new ArgumentNullException(nameof(exception)); }
 
             // 戻り値の検証は非例外時のみ (例外時には actual.Return は必ず default なので、改めて検証する必要が無い)。
             if (actual.Exception == null) {
                 @return(actual.Return);
             }
 
-            exception(actual.Exception);
+            if (exception != null) {
+                exception(actual.Exception);
+            }
+            else if (actual.Exception != null) { throw actual.Exception; }
+
             others?.Invoke();
         }
     }

diff --git a/tests/Inasync.TestAA.Tests/TestAA.Act.Tests.cs b/tests/Inasync.TestAA.Tests/TestAA.Act.Tests.cs
@@ -0,0 +1,78 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Inasync.Tests {
+
+    [TestClass]
+    public class TestAA_Act_Tests {
+
+        [TestMethod]
+        public void Act() {
+            Action TestCase(int testNumber, Action act, Type exceptionType, Type expectedExceptionType = null) => () => {
+                var msg = "No." + testNumber;
+
+                // Act
+                TestActual testActual = default;
+                Exception exception = null;
+                try {
+                    testActual = TestAA.Act(act);
+                }
+                catch (Exception ex) {
+                    exception = ex;
+                }
+
+                // Assert
+                if (exception == null) {
+                    Assert.AreEqual(typeof(TestActual), testActual.GetType(), msg);
+                    Assert.AreEqual(exceptionType, testActual.Exception?.GetType(), msg);
+                }
+                Assert.AreEqual(expectedExceptionType, exception?.GetType(), msg);
+            };
+
+            foreach (var action in new[]{
+                TestCase( 0, act: null                            , exceptionType: null                  , expectedExceptionType: typeof(ArgumentNullException)),
+                TestCase( 1, act: () => { }                       , exceptionType: null                  ),
+                TestCase( 2, act: () => throw new DummyException(), exceptionType: typeof(DummyException)),
+            }) { action(); }
+        }
+
+        [TestMethod]
+        public void Act_TReturn() {
+            Action TestCase(int testNumber, Func<DummyObject> act, (DummyObject @return, Type exceptionType) expected, Type expectedExceptionType = null) => () => {
+                var msg = "No." + testNumber;
+
+                // Act
+                TestActual<DummyObject> testActual = default;
+                Exception exception = null;
+                try {
+                    testActual = TestAA.Act(act);
+                }
+                catch (Exception ex) {
+                    exception = ex;
+                }
+
+                // Assert
+                if (exception == null) {
+                    Assert.AreEqual(expected.exceptionType, testActual.Exception?.GetType(), msg);
+                    Assert.AreEqual(expected.@return, testActual.Return, msg);
+                }
+                Assert.AreEqual(expectedExceptionType, exception?.GetType(), msg);
+            };
+
+            var obj = new DummyObject();
+            foreach (var action in new[]{
+                TestCase( 0, act: null                            , expected: default                       , expectedExceptionType: typeof(ArgumentNullException)),
+                TestCase( 1, act: () => obj                       , expected: (obj , null)                  ),
+                TestCase( 2, act: () => throw new DummyException(), expected: (null, typeof(DummyException))),
+            }) { action(); }
+        }
+
+        #region Helpers
+
+        private sealed class DummyException : Exception { }
+
+        private sealed class DummyObject { }
+
+        #endregion Helpers
+    }
+}