SingleAsyncTest.cs 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314
  1. // Licensed to the .NET Foundation under one or more agreements.
  2. // The .NET Foundation licenses this file to you under the MIT License.
  3. // See the LICENSE file in the project root for more information.
  4. using System;
  5. using System.Reactive.Linq;
  6. using System.Reactive.Threading.Tasks;
  7. using System.Threading.Tasks;
  8. using Microsoft.Reactive.Testing;
  9. using ReactiveTests.Dummies;
  10. using Xunit;
  11. namespace ReactiveTests.Tests
  12. {
  13. public class SingleAsyncTest : ReactiveTest
  14. {
  15. [Fact]
  16. public void SingleAsync_ArgumentChecking()
  17. {
  18. ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SingleAsync(default(IObservable<int>)));
  19. ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SingleAsync(default(IObservable<int>), _ => true));
  20. ReactiveAssert.Throws<ArgumentNullException>(() => Observable.SingleAsync(DummyObservable<int>.Instance, default));
  21. }
  22. [Fact]
  23. public void SingleAsync_Empty()
  24. {
  25. var scheduler = new TestScheduler();
  26. var xs = scheduler.CreateHotObservable(
  27. OnNext(150, 1),
  28. OnCompleted<int>(250)
  29. );
  30. var res = scheduler.Start(() =>
  31. xs.SingleAsync()
  32. );
  33. res.Messages.AssertEqual(
  34. OnError<int>(250, e => e is InvalidOperationException)
  35. );
  36. xs.Subscriptions.AssertEqual(
  37. Subscribe(200, 250)
  38. );
  39. }
  40. [Fact]
  41. public void SingleAsync_One()
  42. {
  43. var scheduler = new TestScheduler();
  44. var xs = scheduler.CreateHotObservable(
  45. OnNext(150, 1),
  46. OnNext(210, 2),
  47. OnCompleted<int>(250)
  48. );
  49. var res = scheduler.Start(() =>
  50. xs.SingleAsync()
  51. );
  52. res.Messages.AssertEqual(
  53. OnNext(250, 2),
  54. OnCompleted<int>(250)
  55. );
  56. xs.Subscriptions.AssertEqual(
  57. Subscribe(200, 250)
  58. );
  59. }
  60. [Fact]
  61. public void SingleAsync_Many()
  62. {
  63. var scheduler = new TestScheduler();
  64. var xs = scheduler.CreateHotObservable(
  65. OnNext(150, 1),
  66. OnNext(210, 2),
  67. OnNext(220, 3),
  68. OnCompleted<int>(250)
  69. );
  70. var res = scheduler.Start(() =>
  71. xs.SingleAsync()
  72. );
  73. res.Messages.AssertEqual(
  74. OnError<int>(220, e => e is InvalidOperationException)
  75. );
  76. xs.Subscriptions.AssertEqual(
  77. Subscribe(200, 220)
  78. );
  79. }
  80. [Fact]
  81. public void SingleAsync_Error()
  82. {
  83. var scheduler = new TestScheduler();
  84. var ex = new Exception();
  85. var xs = scheduler.CreateHotObservable(
  86. OnNext(150, 1),
  87. OnError<int>(210, ex)
  88. );
  89. var res = scheduler.Start(() =>
  90. xs.SingleAsync()
  91. );
  92. res.Messages.AssertEqual(
  93. OnError<int>(210, ex)
  94. );
  95. xs.Subscriptions.AssertEqual(
  96. Subscribe(200, 210)
  97. );
  98. }
  99. [Fact]
  100. public void SingleAsync_Predicate()
  101. {
  102. var scheduler = new TestScheduler();
  103. var xs = scheduler.CreateHotObservable(
  104. OnNext(150, 1),
  105. OnNext(210, 2),
  106. OnNext(220, 3),
  107. OnNext(230, 4),
  108. OnNext(240, 5),
  109. OnCompleted<int>(250)
  110. );
  111. var res = scheduler.Start(() =>
  112. xs.SingleAsync(x => x % 2 == 1)
  113. );
  114. res.Messages.AssertEqual(
  115. OnError<int>(240, e => e is InvalidOperationException)
  116. );
  117. xs.Subscriptions.AssertEqual(
  118. Subscribe(200, 240)
  119. );
  120. }
  121. [Fact]
  122. public void SingleAsync_Predicate_Empty()
  123. {
  124. var scheduler = new TestScheduler();
  125. var ex = new Exception();
  126. var xs = scheduler.CreateHotObservable(
  127. OnNext(150, 1),
  128. OnCompleted<int>(250)
  129. );
  130. var res = scheduler.Start(() =>
  131. xs.SingleAsync(x => x % 2 == 1)
  132. );
  133. res.Messages.AssertEqual(
  134. OnError<int>(250, e => e is InvalidOperationException)
  135. );
  136. xs.Subscriptions.AssertEqual(
  137. Subscribe(200, 250)
  138. );
  139. }
  140. [Fact]
  141. public void SingleAsync_Predicate_One()
  142. {
  143. var scheduler = new TestScheduler();
  144. var xs = scheduler.CreateHotObservable(
  145. OnNext(150, 1),
  146. OnNext(210, 2),
  147. OnNext(220, 3),
  148. OnNext(230, 4),
  149. OnNext(240, 5),
  150. OnCompleted<int>(250)
  151. );
  152. var res = scheduler.Start(() =>
  153. xs.SingleAsync(x => x == 4)
  154. );
  155. res.Messages.AssertEqual(
  156. OnNext(250, 4),
  157. OnCompleted<int>(250)
  158. );
  159. xs.Subscriptions.AssertEqual(
  160. Subscribe(200, 250)
  161. );
  162. }
  163. [Fact]
  164. public void SingleAsync_Predicate_Throw()
  165. {
  166. var scheduler = new TestScheduler();
  167. var ex = new Exception();
  168. var xs = scheduler.CreateHotObservable(
  169. OnNext(150, 1),
  170. OnError<int>(210, ex)
  171. );
  172. var res = scheduler.Start(() =>
  173. xs.SingleAsync(x => x > 10)
  174. );
  175. res.Messages.AssertEqual(
  176. OnError<int>(210, ex)
  177. );
  178. xs.Subscriptions.AssertEqual(
  179. Subscribe(200, 210)
  180. );
  181. }
  182. [Fact]
  183. public void SingleAsync_PredicateThrows()
  184. {
  185. var scheduler = new TestScheduler();
  186. var ex = new Exception();
  187. var xs = scheduler.CreateHotObservable(
  188. OnNext(150, 1),
  189. OnNext(210, 2),
  190. OnNext(220, 3),
  191. OnNext(230, 4),
  192. OnNext(240, 5),
  193. OnCompleted<int>(250)
  194. );
  195. var res = scheduler.Start(() =>
  196. xs.SingleAsync(x => { if (x < 4) { return false; } throw ex; })
  197. );
  198. res.Messages.AssertEqual(
  199. OnError<int>(230, ex)
  200. );
  201. xs.Subscriptions.AssertEqual(
  202. Subscribe(200, 230)
  203. );
  204. }
  205. [Fact] // https://github.com/dotnet/reactive/issues/1235
  206. public void MeaningfulStackTrace()
  207. {
  208. static async Task Core()
  209. {
  210. static void AssertException(Exception e)
  211. {
  212. Assert.IsType(typeof(InvalidOperationException), e);
  213. Assert.NotNull(e.StackTrace);
  214. Assert.NotEqual("", e.StackTrace);
  215. Assert.True(e.StackTrace.Contains("SingleAsync"));
  216. }
  217. var xs = Observable.Range(0, 2).SingleAsync();
  218. try
  219. {
  220. await xs;
  221. }
  222. catch (Exception e)
  223. {
  224. AssertException(e);
  225. }
  226. try
  227. {
  228. await xs.ToTask();
  229. }
  230. catch (Exception e)
  231. {
  232. AssertException(e);
  233. }
  234. var tcs = new TaskCompletionSource<bool>();
  235. xs.Subscribe(
  236. _ => { },
  237. e => tcs.SetException(e),
  238. () => tcs.SetResult(false));
  239. try
  240. {
  241. await tcs.Task;
  242. }
  243. catch (Exception e)
  244. {
  245. AssertException(e);
  246. }
  247. }
  248. Core().GetAwaiter().GetResult();
  249. }
  250. }
  251. }