PageRenderTime 64ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 0ms

/SignalR.Tests/HubFacts.cs

https://github.com/kpmrafeeq/SignalR
C# | 384 lines | 292 code | 92 blank | 0 comment | 1 complexity | fcedac3063498cd2f51d442850229a78 MD5 | raw file
Possible License(s): MIT
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Threading;
  5. using System.Threading.Tasks;
  6. using Newtonsoft.Json.Linq;
  7. using SignalR.Client.Hubs;
  8. using SignalR.Hosting.Memory;
  9. using SignalR.Hubs;
  10. using Xunit;
  11. namespace SignalR.Tests
  12. {
  13. public class HubFacts
  14. {
  15. [Fact]
  16. public void ReadingState()
  17. {
  18. var host = new MemoryHost();
  19. host.MapHubs();
  20. var connection = new Client.Hubs.HubConnection("http://foo/");
  21. var hub = connection.CreateProxy("demo");
  22. hub["name"] = "test";
  23. connection.Start(host).Wait();
  24. var result = hub.Invoke<string>("ReadStateValue").Result;
  25. Assert.Equal("test", result);
  26. connection.Stop();
  27. }
  28. [Fact]
  29. public void SettingState()
  30. {
  31. var host = new MemoryHost();
  32. host.MapHubs();
  33. var connection = new Client.Hubs.HubConnection("http://foo/");
  34. var hub = connection.CreateProxy("demo");
  35. connection.Start(host).Wait();
  36. var result = hub.Invoke<string>("SetStateValue", "test").Result;
  37. Assert.Equal("test", result);
  38. Assert.Equal("test", hub["Company"]);
  39. connection.Stop();
  40. }
  41. [Fact]
  42. public void GetValueFromServer()
  43. {
  44. var host = new MemoryHost();
  45. host.MapHubs();
  46. var connection = new Client.Hubs.HubConnection("http://foo/");
  47. var hub = connection.CreateProxy("demo");
  48. connection.Start(host).Wait();
  49. var result = hub.Invoke<int>("GetValue").Result;
  50. Assert.Equal(10, result);
  51. connection.Stop();
  52. }
  53. [Fact]
  54. public void TaskWithException()
  55. {
  56. var host = new MemoryHost();
  57. host.MapHubs();
  58. var connection = new Client.Hubs.HubConnection("http://foo/");
  59. var hub = connection.CreateProxy("demo");
  60. connection.Start(host).Wait();
  61. var ex = Assert.Throws<AggregateException>(() => hub.Invoke("TaskWithException").Wait());
  62. Assert.IsType<InvalidOperationException>(ex.GetBaseException());
  63. Assert.Contains("System.Exception", ex.GetBaseException().Message);
  64. connection.Stop();
  65. }
  66. [Fact]
  67. public void GenericTaskWithException()
  68. {
  69. var host = new MemoryHost();
  70. host.MapHubs();
  71. var connection = new Client.Hubs.HubConnection("http://foo/");
  72. var hub = connection.CreateProxy("demo");
  73. connection.Start(host).Wait();
  74. var ex = Assert.Throws<AggregateException>(() => hub.Invoke("GenericTaskWithException").Wait());
  75. Assert.IsType<InvalidOperationException>(ex.GetBaseException());
  76. Assert.Contains("System.Exception", ex.GetBaseException().Message);
  77. connection.Stop();
  78. }
  79. [Fact]
  80. public void Overloads()
  81. {
  82. var host = new MemoryHost();
  83. host.MapHubs();
  84. var connection = new Client.Hubs.HubConnection("http://foo/");
  85. var hub = connection.CreateProxy("demo");
  86. connection.Start(host).Wait();
  87. hub.Invoke("Overload").Wait();
  88. int n = hub.Invoke<int>("Overload", 1).Result;
  89. Assert.Equal(1, n);
  90. connection.Stop();
  91. }
  92. [Fact]
  93. public void UnsupportedOverloads()
  94. {
  95. var host = new MemoryHost();
  96. host.MapHubs();
  97. var connection = new Client.Hubs.HubConnection("http://foo/");
  98. var hub = connection.CreateProxy("demo");
  99. connection.Start(host).Wait();
  100. var ex = Assert.Throws<InvalidOperationException>(() => hub.Invoke("UnsupportedOverload", 13177).Wait());
  101. Assert.Equal("'UnsupportedOverload' method could not be resolved.", ex.GetBaseException().Message);
  102. connection.Stop();
  103. }
  104. [Fact]
  105. public void ChangeHubUrl()
  106. {
  107. var host = new MemoryHost();
  108. host.MapHubs("/foo");
  109. var connection = new Client.Hubs.HubConnection("http://site/foo", useDefaultUrl: false);
  110. var hub = connection.CreateProxy("demo");
  111. var wh = new ManualResetEvent(false);
  112. hub.On("signal", id =>
  113. {
  114. Assert.NotNull(id);
  115. wh.Set();
  116. });
  117. connection.Start(host).Wait();
  118. hub.Invoke("DynamicTask").Wait();
  119. Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5)));
  120. connection.Stop();
  121. }
  122. [Fact]
  123. public void GuidTest()
  124. {
  125. var host = new MemoryHost();
  126. host.MapHubs();
  127. var connection = new Client.Hubs.HubConnection("http://site/");
  128. var hub = connection.CreateProxy("demo");
  129. var wh = new ManualResetEvent(false);
  130. hub.On<Guid>("TestGuid", id =>
  131. {
  132. Assert.NotNull(id);
  133. wh.Set();
  134. });
  135. connection.Start(host).Wait();
  136. hub.Invoke("TestGuid").Wait();
  137. Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5)));
  138. connection.Stop();
  139. }
  140. [Fact]
  141. public void ComplexPersonState()
  142. {
  143. var host = new MemoryHost();
  144. host.MapHubs();
  145. var connection = new Client.Hubs.HubConnection("http://site/");
  146. var hub = connection.CreateProxy("demo");
  147. var wh = new ManualResetEvent(false);
  148. connection.Start(host).Wait();
  149. var person = new SignalR.Samples.Hubs.DemoHub.DemoHub.Person
  150. {
  151. Address = new SignalR.Samples.Hubs.DemoHub.DemoHub.Address
  152. {
  153. Street = "Redmond",
  154. Zip = "98052"
  155. },
  156. Age = 25,
  157. Name = "David"
  158. };
  159. var person1 = hub.Invoke<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("ComplexType", person).Result;
  160. var person2 = hub.GetValue<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>("person");
  161. JObject obj = ((dynamic)hub).person;
  162. var person3 = obj.ToObject<SignalR.Samples.Hubs.DemoHub.DemoHub.Person>();
  163. Assert.NotNull(person1);
  164. Assert.NotNull(person2);
  165. Assert.NotNull(person3);
  166. Assert.Equal("David", person1.Name);
  167. Assert.Equal("David", person2.Name);
  168. Assert.Equal("David", person3.Name);
  169. Assert.Equal(25, person1.Age);
  170. Assert.Equal(25, person2.Age);
  171. Assert.Equal(25, person3.Age);
  172. Assert.Equal("Redmond", person1.Address.Street);
  173. Assert.Equal("Redmond", person2.Address.Street);
  174. Assert.Equal("Redmond", person3.Address.Street);
  175. Assert.Equal("98052", person1.Address.Zip);
  176. Assert.Equal("98052", person2.Address.Zip);
  177. Assert.Equal("98052", person3.Address.Zip);
  178. connection.Stop();
  179. }
  180. [Fact]
  181. public void DynamicInvokeTest()
  182. {
  183. var host = new MemoryHost();
  184. host.MapHubs();
  185. var connection = new Client.Hubs.HubConnection("http://site/");
  186. string callback = "!!!CallMeBack!!!";
  187. var hub = connection.CreateProxy("demo");
  188. var wh = new ManualResetEvent(false);
  189. hub.On(callback, () => wh.Set());
  190. connection.Start(host).Wait();
  191. hub.Invoke("DynamicInvoke", callback).Wait();
  192. Assert.True(wh.WaitOne(TimeSpan.FromSeconds(5)));
  193. connection.Stop();
  194. }
  195. [Fact]
  196. public void CreateProxyAfterConnectionStartsThrows()
  197. {
  198. var host = new MemoryHost();
  199. host.MapHubs();
  200. var connection = new Client.Hubs.HubConnection("http://site/");
  201. try
  202. {
  203. connection.Start(host).Wait();
  204. Assert.Throws<InvalidOperationException>(() => connection.CreateProxy("demo"));
  205. }
  206. finally
  207. {
  208. connection.Stop();
  209. }
  210. }
  211. [Fact]
  212. public void AddingToMultipleGroups()
  213. {
  214. var host = new MemoryHost();
  215. host.MapHubs();
  216. int max = 100;
  217. var countDown = new CountDown(max);
  218. var list = Enumerable.Range(0, max).ToList();
  219. var connection = new Client.Hubs.HubConnection("http://foo");
  220. var proxy = connection.CreateProxy("MultGroupHub");
  221. proxy.On<User>("onRoomJoin", user =>
  222. {
  223. lock (list)
  224. {
  225. list.Remove(user.Index);
  226. }
  227. countDown.Dec();
  228. });
  229. connection.Start(host).Wait();
  230. for (int i = 0; i < max; i++)
  231. {
  232. proxy.Invoke("login", new User { Index = i, Name = "tester", Room = "test" + i }).Wait();
  233. }
  234. Assert.True(countDown.Wait(TimeSpan.FromSeconds(10)), "Didn't receive " + max + " messages. Got " + (max - countDown.Count) + " missed " + String.Join(",", list.Select(i => i.ToString())));
  235. connection.Stop();
  236. }
  237. [Fact]
  238. public void CustomQueryStringRaw()
  239. {
  240. var host = new MemoryHost();
  241. host.MapHubs();
  242. var connection = new Client.Hubs.HubConnection("http://foo/", "a=b");
  243. var hub = connection.CreateProxy("CustomQueryHub");
  244. connection.Start(host).Wait();
  245. var result = hub.Invoke<string>("GetQueryString", "a").Result;
  246. Assert.Equal("b", result);
  247. connection.Stop();
  248. }
  249. [Fact]
  250. public void CustomQueryString()
  251. {
  252. var host = new MemoryHost();
  253. host.MapHubs();
  254. var qs = new Dictionary<string, string>();
  255. qs["a"] = "b";
  256. var connection = new Client.Hubs.HubConnection("http://foo/", qs);
  257. var hub = connection.CreateProxy("CustomQueryHub");
  258. connection.Start(host).Wait();
  259. var result = hub.Invoke<string>("GetQueryString", "a").Result;
  260. Assert.Equal("b", result);
  261. connection.Stop();
  262. }
  263. public class CustomQueryHub : Hub
  264. {
  265. public string GetQueryString(string key)
  266. {
  267. return Context.QueryString[key];
  268. }
  269. }
  270. public class MultGroupHub : Hub
  271. {
  272. public Task Login(User user)
  273. {
  274. return Task.Factory.StartNew(
  275. () =>
  276. {
  277. Groups.Remove(Context.ConnectionId, "foo").Wait();
  278. Groups.Add(Context.ConnectionId, "foo").Wait();
  279. Groups.Remove(Context.ConnectionId, user.Name).Wait();
  280. Groups.Add(Context.ConnectionId, user.Name).Wait();
  281. Clients[user.Name].onRoomJoin(user).Wait();
  282. });
  283. }
  284. }
  285. public class User
  286. {
  287. public int Index { get; set; }
  288. public string Name { get; set; }
  289. public string Room { get; set; }
  290. }
  291. }
  292. }