public async Task Test_OnConnectedAsync()
{
Mock<IHubCallerClients> mockClients = new Mock<IHubCallerClients>();
Mock<IClientProxy> mockClientProxy = new Mock<IClientProxy>();
var hub = new ChatHub();
hub.Clients = mockClients.Object;
await hub.OnConnectedAsync();
mockClients.VerifyAll();
}
public ChatBox(UserInfo userInfo)
{
_chatHub = new ChatHub(userInfo);
_bizService = new BizService(new HttpClient()
{
BaseAddress = new Uri(URLConfig.API_Host)
});
InitializeComponent();
InitMessageBoxEvent();
}
public AuthController(UserManager <User> userManager,
SignInManager <User> signInManager, ISetUserStatusCommand setUserStatus,
ChatHub chatHub, IGetUserByUsernameCommand getUserByUsernameCommand)
{
_userManager = userManager;
_signInManager = signInManager;
_setUserStatus = setUserStatus;
_chatHub = chatHub;
_getUserByUsername = getUserByUsernameCommand;
}
public LobbyController(UserManager <ApplicationUser> userManager,
Arena arena,
Hubs.ChatHub chatHubContext,
CombatManager combatManager)
{
_chatHubContext = chatHubContext;
_arena = arena;
_userManager = userManager;
_combatManager = combatManager;
}
public ChatHubTests()
{
var currentDirectory = Directory.GetCurrentDirectory();
var fullFilePath = $"{currentDirectory}/History.txt";
Service = new FileMessageHistory(fullFilePath);
var connectedUsersService = new ConnectedUsersService();
Hub = new ChatHub(Service, connectedUsersService);
}
public MainPage()
{
InitializeComponent();
CollectionMessage = new ObservableCollection <Message>();
HubConnect = new HubConnection(URLServer);
ChatHub = HubConnect.CreateHubProxy("ChatHub");
ChatHub.On("Ready", OnReady);
ChatHub.On <string, string>("Message", OnMessage);
MainListView.ItemsSource = CollectionMessage;
}
public void AcceptChat_Initiated()
{
var guid1 = Guid.NewGuid();
var guid2 = Guid.NewGuid();
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid1,
Language = "English",
UserName = "******",
IsChatting = false,
Invites = new List<Guid>() { guid2 },
ConnectionIds = new Dictionary<string, List<string>>() { { "Lobby", new List<string>() { "C7" } } }
});
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid2,
Language = "French",
UserName = "******",
IsChatting = false,
Invites = new List<Guid>(),
ConnectionIds = new Dictionary<string, List<string>>() { { "Lobby", new List<string>() { "C8" } } }
});
ChatRoom chatRoom = new ChatRoom();
var hub = new ChatHub(new MockTranslator());
var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>();
hub.Clients = mockClients.Object;
var mockGroupManager = new Mock<IGroupManager>();
hub.Groups = mockGroupManager.Object;
dynamic all = new ExpandoObject();
all.joinRoom = new Action<ChatRoom>((room) =>
{
chatRoom = room;
});
AttachIdentity(hub, "Tester8", "C8");
mockClients.Setup(m => m.All).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Caller).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Others).Returns((ExpandoObject)all);
mockClients.Setup(m => m.OthersInGroup(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.User(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Group(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Clients(It.IsAny<List<string>>())).Returns((ExpandoObject)all);
hub.AcceptChat(guid2, guid1);
Assert.AreEqual(1, chatRoom.Id);
Assert.AreEqual(2, chatRoom.Users.Count);
}
public ActionResult Chat(string name)
{
var currentUsername = User.Identity.Name;
var currentUser = repo.GetUser(currentUsername);
ViewBag.FullName = name;
ViewBag.Image = helper.LoadImage(currentUser.ImagePath);
ChatHub.SelectedPeer(name);
return(View());
}
public ActionResult Index()
{
if (_chatHub == null)
{
_chatHub = new ChatHub();
}
GetUserDetails();
return(View());
}
void downloader_PageDownloaded(object sender, PageDownloadedEventArgs e)
{
var downloader = (ISiteDownloader)sender;
var sessionId = downloader.SessionId;
var connectionId = ChatHub.GetConnectionId(sessionId);
if (!string.IsNullOrEmpty(connectionId))
{
//GlobalHost.ConnectionManager.GetHubContext<ChatHub>().Clients.Client(connectionId).broadcastMessage("test", "downloader_PageDownloaded");
GlobalHost.ConnectionManager.GetHubContext <ChatHub>().Clients.Client(connectionId).onPageDownloaded(new { CurrentPage = e.DownloadedPage, DownloadedPages = downloader.DownloadedPages.Count, Remains = downloader.DownloadQueue.Count });
}
}
public async Task <ActionResult> SubmitTipKarma(string chatHandle, int chatMessageId)
{
using (var context = new ApplicationDbContext())
{
var senderId = User.Identity.GetUserId();
var sender = await context.Users.FirstOrDefaultAsync(x => x.Id == senderId).ConfigureAwait(false);
if (sender == null)
{
return(Json(new { Success = false, Message = Resources.Layout.karmaErrorUnauthorizedMessage }));
}
var user = await context.Users.FirstOrDefaultAsync(x => x.ChatHandle == chatHandle || x.UserName == chatHandle).ConfigureAwait(false);
if (user == null)
{
return(Json(new { Success = false, Message = Resources.Layout.karmaErrorUserNotFoundMessage }));
}
var chatBotId = Constant.SYSTEM_USER_CHATBOT.ToString();
var tip = await context.ChatMessages.FirstOrDefaultAsync(x => x.Id == chatMessageId && x.UserId == chatBotId).ConfigureAwait(false);
if (tip == null || tip.Message.Split(':')[1] != chatHandle)
{
return(Json(new { Success = false, Message = Resources.Layout.karmaTipErrorNotFoundMessage }));
}
var karma = new UserKarma
{
KarmaType = UserKarmaType.Tip,
UserId = user.Id,
SenderId = sender.Id,
Discriminator = chatMessageId.ToString()
};
if (!await SaveKarmaChanges(context, user, karma))
{
return(Json(new { Success = false, Message = string.Format(Resources.Layout.karmaTipErrorAlreadySentMessage, chatHandle) }));
}
await SendKarmaNotification(context, user, string.Format(Resources.Layout.karmaTipNotificationMessage, sender.ChatHandle));
await ChatHub.InvalidateUserCache(user.Id);
return(Json(new
{
Success = true,
Message = string.Format(Resources.Layout.karmaTipIsSentMessage, chatHandle),
User = user.UserName,
Count = user.KarmaTotal
}));
}
}
public void AddMessage(Message model)
{
// The user that sent the message
model.User = _chatRepository.GetUser(model.UserId);
model.Date = DateTime.UtcNow;
var id = _chatRepository.AddMessage(model);
model.Id = id;
ChatHub.AddMessage(model.RoomId.ToString(), model);
}
public void CreateSignalRChatHub()
{
// Arrange
var optionsBuilder = new DbContextOptionsBuilder <MessagingContext>();
var context = new MessagingContext(optionsBuilder.Options);
// Act
var chatHub = new ChatHub(context);
// Assert
Assert.IsInstanceOfType(chatHub, typeof(ChatHub));
}
private async void btn_onSendClicked(object sender, EventArgs e)
{
if (ChatEntry.Text.Equals("") || !IsReady)
{
return;
}
SendButton.IsEnabled = false;
await ChatHub.Invoke("Chat", ChatEntry.Text);
ChatEntry.Text = string.Empty;
SendButton.IsEnabled = true;
}
public void PostMessage_Should_InvokeSaveMessage()
{
var testMessage = new ChatMessage {
ChatRoom = "service test", MessageContent = "Test Message, ya'll", UserName = "******"
};
var repo = new Mock <IMessageRepository>();
var target = new ChatHub(repo.Object);
target.PostMessage(testMessage).Wait();
repo.Verify(g => g.SaveMessage(It.IsAny <ChatMessage>()), Times.Once);
repo.Verify(g => g.SaveMessage(It.Is <ChatMessage>(m => m == testMessage)), Times.Once);
}
public void HubsAreMockableViaType()
{
var hub = new ChatHub();
var mockClients = new Mock <IHubCallerConnectionContext <dynamic> >();
var all = new Mock <IClientContract>();
hub.Clients = mockClients.Object;
all.Setup(m => m.broadcastMessage(It.IsAny <string>(),
It.IsAny <string>())).Verifiable();
mockClients.Setup(m => m.All).Returns(all.Object);
hub.Send("TestUser", "TestMessage");
all.VerifyAll();
}
private int EntityId = -1; // passed as a querystring parameter for authorization and used for validation
public ChatHubController(IWebHostEnvironment webHostEnvironment, IHubContext <ChatHub> chatHubContext, ChatHub chatHub, IChatHubRepository chatHubRepository, IChatHubService chatHubService, IHttpContextAccessor httpContextAccessor, ILogManager logger)
{
this.webHostEnvironment = webHostEnvironment;
this.chatHubContext = chatHubContext;
this.chatHub = chatHub;
this.chatHubRepository = chatHubRepository;
this.chatHubService = chatHubService;
this.logger = logger;
if (httpContextAccessor.HttpContext.Request.Query.ContainsKey("entityid"))
{
EntityId = int.Parse(httpContextAccessor.HttpContext.Request.Query["entityid"]);
}
}
public void Start(ChatHub chatHub, List <string> playerNames, Leaderboard leaderboard)
{
hub = chatHub;
players = new List <Player>();
foreach (var name in playerNames)
{
var player = new Player()
{
Name = name,
IsBot = name.StartsWith("Bot")
};
players.Add(player);
var newPlayer = new PlayerStats {
Player = name
};
if (!player.IsBot)
{
leaderboard.LeaderboardEntries.Add(newPlayer);
}
}
var WeaponHelper = new WeaponHelper();
weaponPool = WeaponHelper.CreateWeapons(players.Count);
hub.Broadcast(messageHelper.Begin(players));
hub.Broadcast("--------------------------------------------------");
LootingPhase();
WarPhase();
var winner = players.First(p => p.State != PlayerState.Dead);
if (!winner.IsBot)
{
var leaderboardEntry = leaderboard.LeaderboardEntries.Where(x => x.Player == winner.Name).FirstOrDefault();
leaderboardEntry.Wins++;
leaderboardEntry.TotalKills += winner.KillCount;
}
hub.Broadcast("--------------------------------------------------");
hub.Broadcast(messageHelper.PlayerWins(winner));
hub.Broadcast("--------------------------------------------------");
var kills = messageHelper.GetPlayersKilled(players);
foreach (var kill in kills)
{
hub.Broadcast(kill);
}
}
public async Task Test_SendMessage()
{
Mock<IHubCallerClients> mockClients = new Mock<IHubCallerClients>();
Mock<IClientProxy> mockClientProxy = new Mock<IClientProxy>();
var hub = new ChatHub();
//var all = new Mock<IClientContract>();
hub.Clients = mockClients.Object;
// all.Setup(m => m.broadcastMessage(It.IsAny<string>(),
// It.IsAny<string>())).Verifiable();
mockClients.Setup(clients => clients.All).Returns(mockClientProxy.Object);
await hub.SendMessage("TestUser", "TestMessage");
mockClients.VerifyAll();
}
public void SetUp()
{
_adapter = new Mock <IWepApiAdapter>();
_chatHub = new ChatHub(_adapter.Object);
_mockClients = new Mock <IHubCallerConnectionContext <dynamic> >();
_mockContext = new Mock <HubCallerContext>();
_clientContract = new Mock <IClientContract>();
_chatHub.Clients = _mockClients.Object;
_mockClients.Setup(m => m.All).Returns(_clientContract.Object);
_mockClients.Setup(m => m.Client(It.IsAny <string>())).Returns(_clientContract.Object);
_mockContext.SetupAllProperties();
}
public async Task SendMessage_ShouldSendMessageToClients_WhenCalled()
{
var clientsMock = new Mock <IHubCallerClients <IClientMessage> >();
var clientProxyMock = new Mock <IClientMessage>();
clientsMock.Setup(clients => clients.All).Returns(clientProxyMock.Object);
var chatHub = new ChatHub {
Clients = clientsMock.Object
};
await chatHub.SendMessage("Jack", "Hello all!");
clientsMock.Verify(clients => clients.All, Times.Once);
clientProxyMock.Verify(x => x.ReceiveMessage(It.IsAny <string>(), It.IsAny <string>()));
}
protected override void CreateHubConnection()
{
base.CreateHubConnection();
ChatHub = HubConnection.CreateHubProxy("ChatHub");
AccountHub = HubConnection.CreateHubProxy("AccountHub");
ContactHub = HubConnection.CreateHubProxy("ContactHub");
ChatHub.On("update", () =>
{
if (OnRequestUpdate != null)
{
OnRequestUpdate();
}
});
}
void downloader_DownloadCompleted(object sender, DownloadCompletedEventArgs e)
{
var downloader = (ISiteDownloader)sender;
var sessionId = ((ISiteDownloader)sender).SessionId;
var connectionId = ChatHub.GetConnectionId(sessionId);
if (!string.IsNullOrEmpty(connectionId))
{
//GlobalHost.ConnectionManager.GetHubContext<ChatHub>().Clients.Client(connectionId).broadcastMessage("test", "downloader_DownloadCompleted");
GlobalHost.ConnectionManager.GetHubContext <ChatHub>().Clients.Client(connectionId).onDownloadCompleted(e.DownloadedPages);
}
SiteDownloaderFactory.RemoveSiteDownloader(sessionId);
}
public CheckinCommandProveedores(IHubCallerClients clients, HubCallerContext context, IGroupManager group)
{
_log = new TraceLog();
_hub = new ChatHub(configuration);
try
{
_hub.Clients = clients;
_hub.Context = context;
_hub.Groups = group;
}
catch (Exception e)
{
string mensajeerror = e.Message;
TraceLog.LogTrace("ERROR", "Cliente Notificacion", mensajeerror);
}
}
internal bool SendMessage(int toUserId, string message)
{
try {
int USER_ID = int.Parse(HttpContext.Current.User.Identity.Name);
_Context.Messages.Add(new Message {
FromUser = USER_ID,
ToUser = toUserId,
Message1 = message,
Date = DateTime.Now
});
_Context.SaveChanges();
ChatHub.RecieveMessage(USER_ID, toUserId, message);
return(true);
}
catch { return(false); }
}
public async Task <ActionResult> SubmitTipIgnore(string username)
{
var result = await UserSettingsWriter.UpdateIgnoreList(User.Identity.GetUserId(), UserIgnoreListType.Tip, username);
if (result.Success)
{
await ChatHub.InvalidateUserCache(User.Identity.GetUserId());
}
return(Json(new
{
Success = result.Success,
Message = result.Message,
WasRemoved = result.Result
}));
}
public void HubsAreMockableViaDynamic()
{
bool sendCalled = false;
var hub = new ChatHub();
var mockClients = new Mock <IHubCallerConnectionContext <dynamic> >();
hub.Clients = mockClients.Object;
dynamic all = new ExpandoObject();
all.broadcastMessage = new Action <string, string>((name, message) => {
sendCalled = true;
});
mockClients.Setup(m => m.All).Returns((ExpandoObject)all);
hub.Send("TestUser", "TestMessage");
Assert.True(sendCalled);
}
private async void btn_onGetOutClicked(object sender, EventArgs e)
{
IGetOut = true;
OutRoom.IsEnabled = false;
try
{
await ChatHub.Invoke("Chat", "");
}
catch { }
//Wait for get Message "GetOut", then Stop Connect the HubConnect.
//If, HubConnect.Stop() in line 130, Will be crash, because the asyncho, (stop Hub, still...)
if (HubConnect.State == ConnectionState.Connected)
{
HubConnect.Stop();
}
}
public void Setup()
{
mockClients = new Mock <IHubCallerClients>();
mockClientProxy = new Mock <IClientProxy>();
navn = new Mock <HubCallerContext>();
mockClients.Setup(clients => clients.Group("group1")).Returns(mockClientProxy.Object);
navn.Setup(c => c.ConnectionId).Returns(Guid.NewGuid().ToString());
chatHub = new ChatHub(loggingService)
{
Clients = mockClients.Object,
Context = navn.Object
};
chatHub.Clients.Group("group1");
}
//Create a method for Flushing collection availible for List but not for BlockigCollection
public void Clear()
{
try {
while (this.Count > 0)
{
foreach (T item in this)
{
this.Remove(item);
}
//this.Dispose();
}
//this.Dispose(); //TODO: do we need to dispose of list, will probs be garbage collected
}
catch (Exception e) {
ChatHub.DebugOut("HubBlockingCollection - Failed to Clear(), message : " + e.Message); //TODO: Handle error properly
}
}
public CommandManager(
string connectionId,
int roomId,
ChatHubUser user,
ChatHub chatHub,
IChatHubService service,
IChatHubRepository repository,
UserManager <IdentityUser> userManager)
{
_connectionId = connectionId;
_roomId = roomId;
_caller = user;
_chatHub = chatHub;
_chatService = service;
_repository = repository;
_userManager = userManager;
}
public Notification()
{
var chatHub = new ChatHub();
chatHub.Send("System", "System call every 1 min.");
}
public void Disconnect_Remove()
{
var guid1 = Guid.NewGuid();
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid1,
Language = "English",
UserName = "******",
IsChatting = true,
ConnectionIds = new Dictionary<string, List<string>>() { { "Lobby", new List<string>() { "C4" } } }
});
Guid? disUser = null;
var hub = new ChatHub(new MockTranslator());
var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>();
hub.Clients = mockClients.Object;
dynamic all = new ExpandoObject();
all.userDisconnected = new Action<Guid>((name) =>
{
disUser = name;
});
AttachIdentity(hub, "Tester4", "C4");
mockClients.Setup(m => m.All).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Caller).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Others).Returns((ExpandoObject)all);
mockClients.Setup(m => m.OthersInGroup(It.IsAny<string>())).Returns((ExpandoObject)all);
hub.OnDisconnected(true);
Assert.AreEqual(0, ChatHub.ConnectedUsers.Count);
Assert.AreEqual(guid1, disUser);
}
public void GetUsers_NoUsers()
{
var hub = new ChatHub(new MockTranslator());
AttachIdentity(hub, "Tester1");
var users = hub.GetUsers();
Assert.AreEqual(0, users.Count);
}
public void GetUsers_OneLobbyOneChatting()
{
var guid1 = Guid.NewGuid();
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid1,
IsChatting = false,
Language = "French",
UserName = "******",
ConnectionIds = new Dictionary<string,List<string>>() { {"Lobby", new List<string>() {"C1"}}}
});
ChatHub.ConnectedUsers.Add(new UserModel()
{
IsChatting = true,
Language = "English",
UserName = "******",
ConnectionIds = new Dictionary<string, List<string>>() { { "Lobby", new List<string>() { "C2" } } }
});
var hub = new ChatHub(new MockTranslator());
AttachIdentity(hub, "Tester1", "C1");
var users = hub.GetUsers();
Assert.AreEqual(2, users.Count);
Assert.AreEqual("Tester1", users.FirstOrDefault(u => !u.IsChatting).UserName);
Assert.AreEqual("Tester2", users.FirstOrDefault(u => u.IsChatting).UserName);
}
public void InviteToChat()
{
var guid1 = Guid.NewGuid();
var guid2 = Guid.NewGuid();
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid1,
Language = "English",
UserName = "******",
IsChatting = false,
Invites = new List<Guid>(),
ConnectionIds = new Dictionary<string, List<string>>() { { "Lobby", new List<string>() { "C5" } } }
});
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid2,
Language = "French",
UserName = "******",
IsChatting = false,
Invites = new List<Guid>(),
ConnectionIds = new Dictionary<string, List<string>>() { { "Lobby", new List<string>() { "C6" } } }
});
UserModel inviter = null;
var hub = new ChatHub(new MockTranslator());
var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>();
hub.Clients = mockClients.Object;
dynamic all = new ExpandoObject();
all.inviteReceived = new Action<UserModel>((name) =>
{
inviter = name;
});
AttachIdentity(hub, "Tester5", "C5");
mockClients.Setup(m => m.All).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Caller).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Others).Returns((ExpandoObject)all);
mockClients.Setup(m => m.OthersInGroup(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.User(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Client(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Clients(It.IsAny<List<string>>())).Returns((ExpandoObject)all);
hub.InviteUser(guid1, guid2);
Assert.AreEqual(guid2, ChatHub.ConnectedUsers.First(cu => cu.UserName == "Tester5").Invites[0]);
Assert.IsNotNull(inviter);
Assert.AreEqual(guid1, inviter.Id);
}
public void JoinLobby()
{
UserModel userModel = new UserModel();
var hub = new ChatHub(new MockTranslator());
var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>();
hub.Clients = mockClients.Object;
var mockGroupManager = new Mock<IGroupManager>();
hub.Groups = mockGroupManager.Object;
dynamic all = new ExpandoObject();
all.userJoined = new Action<UserModel>((model) =>
{
userModel = model;
});
AttachIdentity(hub, "Tester3", "C3");
mockClients.Setup(m => m.All).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Caller).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Others).Returns((ExpandoObject)all);
mockClients.Setup(m => m.OthersInGroup(It.IsAny<string>())).Returns((ExpandoObject)all);
hub.JoinLobby("Tester3", "French", null);
Assert.AreEqual(1, ChatHub.ConnectedUsers.Count);
Assert.AreEqual(false, userModel.IsChatting);
Assert.AreEqual("French", userModel.Language);
Assert.AreEqual("Tester3", userModel.UserName);
}
public void SendMessage()
{
var guid1 = Guid.NewGuid();
var guid2 = Guid.NewGuid();
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid1,
Language = "English",
UserName = "******",
IsChatting = false,
Invites = new List<Guid>(),
ConnectionIds = new Dictionary<string, List<string>>() { { "Room2", new List<string>() { "C9" } } }
});
ChatHub.ConnectedUsers.Add(new UserModel()
{
Id = guid2,
Language = "French",
UserName = "******",
IsChatting = false,
Invites = new List<Guid>(),
ConnectionIds = new Dictionary<string, List<string>>() { { "Room2", new List<string>() { "C10" } } }
});
ChatRoom chatRoom = new ChatRoom() { Id = 2, Users = ChatHub.ConnectedUsers.ToList() };
ChatHub.ChatRooms.Add(chatRoom);
ChatMessage mess = new ChatMessage();
var hub = new ChatHub(new MockTranslator());
var mockClients = new Mock<IHubCallerConnectionContext<dynamic>>();
hub.Clients = mockClients.Object;
var mockGroupManager = new Mock<IGroupManager>();
hub.Groups = mockGroupManager.Object;
dynamic all = new ExpandoObject();
all.receiveMessage = new Action<ChatMessage>((message) =>
{
mess = message;
});
AttachIdentity(hub, "Tester9", "C9");
mockClients.Setup(m => m.All).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Caller).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Others).Returns((ExpandoObject)all);
mockClients.Setup(m => m.OthersInGroup(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.User(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Client(It.IsAny<string>())).Returns((ExpandoObject)all);
mockClients.Setup(m => m.Clients(It.IsAny<List<string>>())).Returns((ExpandoObject)all);
hub.SendMessage(2, new ChatMessage()
{
ClientSent = DateTime.Now,
Message = "Hello World",
Sender = chatRoom.Users[0]
}).Wait();
Assert.AreEqual(1, mess.Id);
Assert.AreEqual("Tester9", mess.Sender.UserName);
Assert.IsNotNull(mess.ServerSent);
Assert.AreNotEqual(DateTime.MinValue, mess.ServerSent);
Assert.IsTrue(mess.ServerSent > mess.ClientSent);
Assert.AreEqual("English", mess.Sender.Language);
Assert.AreEqual("Hello World", mess.Message);
Assert.AreEqual("French: Hello World", mess.Translation);
}
private void AttachIdentity(ChatHub hub, string name, string connectionId = "1")
{
var mockIdentity =
Mock.Of<ClaimsIdentity>(ci => ci.Name == name);
var mockContext = Mock.Of<HubCallerContext>(cc => cc.User.Identity == mockIdentity
&& cc.ConnectionId == connectionId);
hub.Context = mockContext;
}
