public void IsClientConnected_ShouldBeConnected_WhenClientExists( ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); Assert.True(sut.IsClientConnected(client.ClientId)); }
public void Add_ShouldMarkForUpdate_WhenAdded( [Frozen] Mock <IUpdateDetector> updateDetector, ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); updateDetector.Verify(x => x.MarkForUpdate(client.Group)); }
public void Find_ShouldFind_WhenAdded( ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); var found = sut.Find(client.ClientId); Assert.Equal(client, found); }
public void Add_ShouldThrow_WhenAlreadyAdded(ConnectedClientStore sut) { Fixture.Customizations.Add( new ClientWithIdBuilder(Create <string>())); sut.Add(Create <ConnectedClient>()); Assert.Throws <ClientAlreadyConnectedException>( () => sut.Add(Create <ConnectedClient>())); }
public void Add_ShouldMarkForUpdateMultipleGroups_WhenAdded( [Frozen] Mock <IUpdateDetector> updateDetector, ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); updateDetector.Verify(x => x.MarkForUpdate(It.Is <IEnumerable <string> >( x => x.Count() == 3 && x.SequenceEqual(client.Groups)))); }
public void Remove_ShouldRemoveClient( ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); Assert.Equal(client, sut.Find(client.ClientId)); sut.Remove(client.ClientId); Assert.Null(sut.Find(client.ClientId)); }
public void Add_ShouldMarkForUpdate_WhenAdded( [Frozen] Mock <IUpdateDetector> updateDetector, ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); updateDetector.Verify(x => x.MarkForUpdate(It.Is <IEnumerable <string> >( x => x.Count() == 1 && x.First() == client.Group))); }
public void Add_ShouldAddClient_WhenNotAdded( ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); var result = sut.Find(client.ClientId); Assert.NotNull(result); Assert.Equal(client, result); }
public void Remove_ShouldMarkForUpdate_WhenRemoved( [Frozen] Mock <IUpdateDetector> updateDetector, ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); updateDetector.Verify(x => x.MarkForUpdate(client.Group), Times.Once); sut.Remove(client.ClientId); updateDetector.Verify(x => x.MarkForUpdate(client.Group), Times.Exactly(2)); }
public void Remove_ShouldMarkForUpdate_WhenRemoved( [Frozen] Mock <IUpdateDetector> updateDetector, ConnectedClient client, ConnectedClientStore sut) { sut.Add(client); updateDetector.Verify(x => x.MarkForUpdate(It.Is <IEnumerable <string> >( x => x.Count() == 1 && x.First() == client.Group)), Times.Once); sut.Remove(client.ClientId); updateDetector.Verify(x => x.MarkForUpdate(It.Is <IEnumerable <string> >( x => x.Count() == 1 && x.First() == client.Group)), Times.Exactly(2)); }
public void Add_ShouldMarkForUpdateMultipleGroups_WhenAddedOneMoreGroup( [Frozen] Mock <IUpdateDetector> updateDetector, ConnectedClient client, string group, ConnectedClientStore sut) { // Possibly improve this unit test. client.AddToGroup(group); sut.Add(client); updateDetector.Verify(x => x.MarkForUpdate(It.Is <IEnumerable <string> >( x => x.Count() == 4 && x.SequenceEqual(client.Groups) && x.Contains(group)))); }
public void Remove_ShouldMarkForUpdateMultiGroupClient_WhenRemoved( [Frozen] Mock <IUpdateDetector> updateDetector, string[] groups, ConnectedClientStore sut) { var client = CreateMultiGroupClient(groups); sut.Add(client); updateDetector.Verify(x => x.MarkForUpdate(It.Is <IEnumerable <string> >( x => x.SequenceEqual(groups))), Times.Once); sut.Remove(client.ClientId); updateDetector.Verify(x => x.MarkForUpdate(It.Is <IEnumerable <string> >( x => x.SequenceEqual(groups))), Times.Exactly(2)); }
public void ShouldFindAllClientsInGroups(FindType findType, ConnectedClientStore sut) { var group1 = Fixture.Create <string>(); var group2 = Fixture.Create <string>(); var group3 = Fixture.Create <string>(); var clientsInGroup1 = Fixture.Build <ConnectedClient>() .With(x => x.Group, group1) .CreateMany(2); var clientsInGroup2 = Fixture.Build <ConnectedClient>() .With(x => x.Group, group2) .CreateMany(2); var clientsInGroup3 = Fixture.Build <ConnectedClient>() .With(x => x.Group, group3) .CreateMany(2); var clientInGroups1And2 = CreateMultiGroupClient(new[] { group1, group2 }); var clientInGroups123 = CreateMultiGroupClient(new[] { group1, group2 }); Assert.Throws <InvalidOperationException>(() => clientInGroups123.Group = group3); clientInGroups123.AddToGroup(group3); foreach (var client in clientsInGroup1 .Concat(clientsInGroup2) .Concat(clientsInGroup3) .Append(clientInGroups1And2) .Append(clientInGroups123)) { sut.Add(client); } var result = findType switch { FindType.RegularMethod => sut.FindInGroups(new[] { group1, group3 }), FindType.ExtensionParamsMethod => sut.FindInGroups(group1, group3), _ => throw new InvalidOperationException() }; Assert.Equal(6, result.Count()); Assert.True(clientsInGroup1.All(x => result.Contains(x))); Assert.True(clientsInGroup2.All(x => !result.Contains(x))); Assert.True(clientsInGroup3.All(x => result.Contains(x))); Assert.Contains(clientInGroups1And2, result); Assert.Contains(clientInGroups123, result); }
public async Task ConcurrencyTest( string clientId, ConnectedClientStore sut) { Fixture.Customizations.Add(new ClientWithIdBuilder(clientId)); var tasks = new List <Task>(); for (var i = 0; i < 100; i++) { tasks.Add(new Task(() => sut.Add(Create <ConnectedClient>()))); tasks.Add(new Task(() => sut.Remove(clientId))); tasks.Add(new Task(() => sut.Find(clientId))); } Parallel.ForEach(tasks, task => task.Start()); try { await Task.WhenAll(tasks); } catch (ClientAlreadyConnectedException) { } try { sut.Add(Create <ConnectedClient>()); } catch (ClientAlreadyConnectedException) { } Assert.NotNull(sut.Find(clientId)); }
public async Task SendAsync_ShouldSendMessageToAllClientsThatAreInSpecifiedGroup(ConnectedClientStore sut) { var connections = Fixture.CreateMany <IConnection>(3).ToList(); var clients = connections .Select(connection => CreateSingleGroupClient(connection)) .ToList(); foreach (var client in clients) { sut.Add(client); } clients[1].Group = clients[0].Group; Mock.Get(connections[0]).Setup(x => x.SendAsync(It.IsAny <object>(), It.IsAny <CancellationToken>())) .Callback(() => { }); var message = Create <TestMessage>(); await sut.SendAsync(message, clients[0].Group, Cts.Token); Mock.Get(connections[0]).Verify(x => x.SendAsync(message, Cts.Token)); Mock.Get(connections[1]).Verify(x => x.SendAsync(message, Cts.Token)); Mock.Get(connections[2]).Verify(x => x.SendAsync(message, Cts.Token), Times.Never); }
public void Find_ShouldReturnNull_WhenNotAdded(ConnectedClientStore sut) { Assert.Null(sut.Find(Create <string>())); }
public void ShouldNotThrow_WhenRemovingNonExistingClient(ConnectedClientStore sut) { sut.Remove(Create <string>()); }
public async Task SendAsync_ShouldSendMessageToAllClientsThatAreInSpecifiedGroup(ConnectedClientStore sut) { var connections = Fixture.CreateMany <IConnection>(3).ToList(); var clients = connections .Select(connection => Create <ConnectedClient>( new ClientWithConnectionBuilder(connection))) .ToList(); foreach (var client in clients) { sut.Add(client); } clients[1].Group = clients[0].Group; var message = Create <TestMessage>(); await sut.SendAsync(message, clients[0].Group, Cts.Token); Mock.Get(connections[0]).Verify(x => x.SendAsync(message, Cts.Token)); Mock.Get(connections[1]).Verify(x => x.SendAsync(message, Cts.Token)); Mock.Get(connections[2]).Verify(x => x.SendAsync(message, Cts.Token), Times.Never); }
public void IsClientConnected_ShouldNotBeConnected_WhenClientDoesNotExist(ConnectedClientStore sut) { Assert.False(sut.IsClientConnected(Create <string>())); }