public async Task Throws_ListenPortException_Given_Listen_Port_Which_Can_Not_Be_Bound()
{
var(client, mocks) = GetFixture();
var port = Mocks.Port;
var patch = new SoulseekClientOptionsPatch(listenPort: port);
Listener listener = null;
try
{
// listen on the port to bind it
listener = new Listener(port, new ConnectionOptions());
listener.Start();
using (client)
{
var ex = await Record.ExceptionAsync(() => client.ReconfigureOptionsAsync(patch));
Assert.NotNull(ex);
Assert.IsType <ListenPortException>(ex);
Assert.True(ex.Message.ContainsInsensitive($"failed to start listening on port {port}"));
}
}
finally
{
listener?.Stop();
}
}
public void Clones_With_Expected_Properties_Given_A_Patch(
bool?enableListener,
bool?enableDistributedNetwork,
bool?acceptDistributedChildren,
int?distributedChildLimit,
bool?deduplicateSearchRequests,
bool?autoAcknowledgePrivateMessages,
bool?autoAcknowledgePrivilegeNotifications,
bool?acceptPrivateRoomInvitations)
{
var serverConnectionOptions = new ConnectionOptions();
var peerConnectionOptions = new ConnectionOptions();
var transferConnectionOptions = new ConnectionOptions();
var incomingConnectionOptions = new ConnectionOptions();
var distributedConnectionOptions = new ConnectionOptions();
var rnd = new Random();
var listenPort = rnd.Next(1024, 65535);
var patch = new SoulseekClientOptionsPatch(
enableListener,
listenPort,
enableDistributedNetwork: enableDistributedNetwork,
acceptDistributedChildren: acceptDistributedChildren,
distributedChildLimit: distributedChildLimit,
deduplicateSearchRequests: deduplicateSearchRequests,
autoAcknowledgePrivateMessages: autoAcknowledgePrivateMessages,
autoAcknowledgePrivilegeNotifications: autoAcknowledgePrivilegeNotifications,
acceptPrivateRoomInvitations: acceptPrivateRoomInvitations,
serverConnectionOptions: serverConnectionOptions,
peerConnectionOptions: peerConnectionOptions,
transferConnectionOptions: transferConnectionOptions,
incomingConnectionOptions: incomingConnectionOptions,
distributedConnectionOptions: distributedConnectionOptions);
var o = new SoulseekClientOptions().With(patch);
Assert.Equal(enableListener, o.EnableListener);
Assert.Equal(listenPort, o.ListenPort);
Assert.Equal(enableDistributedNetwork, o.EnableDistributedNetwork);
Assert.Equal(acceptDistributedChildren, o.AcceptDistributedChildren);
Assert.Equal(distributedChildLimit, o.DistributedChildLimit);
Assert.Equal(deduplicateSearchRequests, o.DeduplicateSearchRequests);
Assert.Equal(autoAcknowledgePrivateMessages, o.AutoAcknowledgePrivateMessages);
Assert.Equal(autoAcknowledgePrivilegeNotifications, o.AutoAcknowledgePrivilegeNotifications);
Assert.Equal(acceptPrivateRoomInvitations, o.AcceptPrivateRoomInvitations);
Assert.Equal(peerConnectionOptions, o.PeerConnectionOptions);
Assert.Equal(incomingConnectionOptions, o.IncomingConnectionOptions);
Assert.Equal(distributedConnectionOptions, o.DistributedConnectionOptions);
Assert.Equal(serverConnectionOptions.ReadBufferSize, o.ServerConnectionOptions.ReadBufferSize);
Assert.Equal(serverConnectionOptions.WriteBufferSize, o.ServerConnectionOptions.WriteBufferSize);
Assert.Equal(serverConnectionOptions.ConnectTimeout, o.ServerConnectionOptions.ConnectTimeout);
Assert.Equal(-1, o.ServerConnectionOptions.InactivityTimeout);
Assert.Equal(transferConnectionOptions.ReadBufferSize, o.TransferConnectionOptions.ReadBufferSize);
Assert.Equal(transferConnectionOptions.WriteBufferSize, o.TransferConnectionOptions.WriteBufferSize);
Assert.Equal(transferConnectionOptions.ConnectTimeout, o.TransferConnectionOptions.ConnectTimeout);
Assert.Equal(-1, o.TransferConnectionOptions.InactivityTimeout);
}
public void Throws_If_Distributed_Child_Limit_Is_Less_Than_Zero()
{
SoulseekClientOptionsPatch x;
var ex = Record.Exception(() => x = new SoulseekClientOptionsPatch(distributedChildLimit: -1));
Assert.NotNull(ex);
Assert.IsType <ArgumentOutOfRangeException>(ex);
}
public void Throws_If_Listen_Port_Is_Too_Low()
{
SoulseekClientOptionsPatch x;
var ex = Record.Exception(() => x = new SoulseekClientOptionsPatch(listenPort: 1023));
Assert.NotNull(ex);
Assert.IsType <ArgumentOutOfRangeException>(ex);
}
public async Task Updates_Options()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions(
enableListener: false,
listenPort: Mocks.Port,
enableDistributedNetwork: false,
acceptDistributedChildren: false,
distributedChildLimit: 5,
deduplicateSearchRequests: true,
autoAcknowledgePrivateMessages: false,
autoAcknowledgePrivilegeNotifications: false,
acceptPrivateRoomInvitations: false,
serverConnectionOptions: new ConnectionOptions(readBufferSize: 10),
peerConnectionOptions: new ConnectionOptions(),
transferConnectionOptions: new ConnectionOptions(readBufferSize: 20),
incomingConnectionOptions: new ConnectionOptions(),
distributedConnectionOptions: new ConnectionOptions()));
var patch = new SoulseekClientOptionsPatch(
enableListener: true,
listenPort: Mocks.Port,
enableDistributedNetwork: true,
acceptDistributedChildren: true,
distributedChildLimit: 10,
deduplicateSearchRequests: false,
autoAcknowledgePrivateMessages: true,
autoAcknowledgePrivilegeNotifications: true,
acceptPrivateRoomInvitations: true,
serverConnectionOptions: new ConnectionOptions(readBufferSize: 100),
peerConnectionOptions: new ConnectionOptions(),
transferConnectionOptions: new ConnectionOptions(readBufferSize: 200),
incomingConnectionOptions: new ConnectionOptions(),
distributedConnectionOptions: new ConnectionOptions());
using (client)
{
client.SetProperty("State", SoulseekClientStates.Disconnected);
await client.ReconfigureOptionsAsync(patch);
Assert.Equal(patch.EnableListener, client.Options.EnableListener);
Assert.Equal(patch.ListenPort, client.Options.ListenPort);
Assert.Equal(patch.EnableDistributedNetwork, client.Options.EnableDistributedNetwork);
Assert.Equal(patch.AcceptDistributedChildren, client.Options.AcceptDistributedChildren);
Assert.Equal(patch.DistributedChildLimit, client.Options.DistributedChildLimit);
Assert.Equal(patch.DeduplicateSearchRequests, client.Options.DeduplicateSearchRequests);
Assert.Equal(patch.AutoAcknowledgePrivateMessages, client.Options.AutoAcknowledgePrivateMessages);
Assert.Equal(patch.AutoAcknowledgePrivilegeNotifications, client.Options.AutoAcknowledgePrivilegeNotifications);
Assert.Equal(patch.AcceptPrivateRoomInvitations, client.Options.AcceptPrivateRoomInvitations);
Assert.Equal(patch.PeerConnectionOptions, client.Options.PeerConnectionOptions);
Assert.Equal(patch.IncomingConnectionOptions, client.Options.IncomingConnectionOptions);
Assert.Equal(patch.DistributedConnectionOptions, client.Options.DistributedConnectionOptions);
Assert.Equal(patch.ServerConnectionOptions.ReadBufferSize, client.Options.ServerConnectionOptions.ReadBufferSize);
Assert.Equal(patch.TransferConnectionOptions.ReadBufferSize, client.Options.TransferConnectionOptions.ReadBufferSize);
}
}
public void Removes_Timeout_On_Server_And_Transfer_Options()
{
var serverConnectionOptions = new ConnectionOptions();
var transferConnectionOptions = new ConnectionOptions();
var o = new SoulseekClientOptionsPatch(
serverConnectionOptions: serverConnectionOptions,
transferConnectionOptions: transferConnectionOptions);
Assert.Equal(-1, o.ServerConnectionOptions.InactivityTimeout);
Assert.Equal(-1, o.TransferConnectionOptions.InactivityTimeout);
}
public async Task Does_Not_Set_Count_On_DownloadTokenBucket_If_Download_Speed_Did_Not_Change(int speed)
{
var(client, mocks) = GetFixture(new SoulseekClientOptions(maximumDownloadSpeed: speed));
var patch = new SoulseekClientOptionsPatch(maximumDownloadSpeed: speed);
using (client)
{
await client.ReconfigureOptionsAsync(patch);
}
mocks.DownloadTokenBucket.Verify(m => m.SetCapacity(It.IsAny <int>()), Times.Never);
}
public async Task Does_Not_Throw_Given_Empty_Patch()
{
var(client, _) = GetFixture();
var patch = new SoulseekClientOptionsPatch();
using (client)
{
var ex = await Record.ExceptionAsync(() => client.ReconfigureOptionsAsync(patch));
Assert.Null(ex);
}
}
public async Task Does_Not_Send_PrivateRoomToggle_If_Not_Connected()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions());
var patch = new SoulseekClientOptionsPatch();
using (client)
{
client.SetProperty("State", SoulseekClientStates.Disconnected);
await client.ReconfigureOptionsAsync(patch);
}
mocks.ServerConnection.Verify(m => m.WriteAsync(It.IsAny <PrivateRoomToggle>(), It.IsAny <CancellationToken?>()), Times.Never);
}
public async Task Sends_PrivateRoomToggle()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions());
var patch = new SoulseekClientOptionsPatch();
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
await client.ReconfigureOptionsAsync(patch);
}
mocks.ServerConnection.Verify(m => m.WriteAsync(It.IsAny <PrivateRoomToggle>(), It.IsAny <CancellationToken?>()));
}
public async Task Reconfigures_Listener_If_ListenPort_Changed()
{
var(client, _) = GetFixture(new SoulseekClientOptions(listenPort: Mocks.Port));
var patch = new SoulseekClientOptionsPatch(listenPort: Mocks.Port);
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
await client.ReconfigureOptionsAsync(patch);
Assert.Equal(patch.ListenPort, client.Listener.Port);
}
}
public async Task Sends_SetListenPortCommand_If_EnableListener_Changed_From_False_To_true()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions(enableListener: false));
var patch = new SoulseekClientOptionsPatch(enableListener: true);
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
await client.ReconfigureOptionsAsync(patch);
}
mocks.ServerConnection.Verify(m => m.WriteAsync(It.IsAny <SetListenPortCommand>(), It.IsAny <CancellationToken?>()));
}
public async Task Nulls_Listener_If_EnableListener_Changed()
{
var(client, _) = GetFixture(new SoulseekClientOptions(enableListener: true));
var patch = new SoulseekClientOptionsPatch(enableListener: false);
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
await client.ReconfigureOptionsAsync(patch);
Assert.Null(client.Listener);
}
}
public async Task Returns_True_If_Client_Connected_And_ServerConnectionOptions_Changed()
{
var(client, _) = GetFixture(new SoulseekClientOptions(serverConnectionOptions: new ConnectionOptions()));
var patch = new SoulseekClientOptionsPatch(serverConnectionOptions: new ConnectionOptions());
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var reconnectRequired = await client.ReconfigureOptionsAsync(patch);
Assert.True(reconnectRequired);
}
}
public async Task Reconfigures_Listener_If_IncomingConnectionOptions_Changed()
{
var(client, _) = GetFixture(new SoulseekClientOptions(incomingConnectionOptions: new ConnectionOptions()));
var patch = new SoulseekClientOptionsPatch(incomingConnectionOptions: new ConnectionOptions());
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
await client.ReconfigureOptionsAsync(patch);
Assert.Equal(patch.IncomingConnectionOptions, client.Listener.ConnectionOptions);
}
}
public async Task Configures_Distributed_Network_()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions(enableDistributedNetwork: false));
var patch = new SoulseekClientOptionsPatch(enableDistributedNetwork: true);
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
await client.ReconfigureOptionsAsync(patch);
}
mocks.DistributedConnectionManager.Verify(m => m.UpdateStatusAsync(It.IsAny <CancellationToken?>()));
}
public async Task Returns_True_If_Client_Connected_And_EnableDistributedNetwork_Changed_To_False()
{
var(client, _) = GetFixture(new SoulseekClientOptions(enableDistributedNetwork: true));
var patch = new SoulseekClientOptionsPatch(enableDistributedNetwork: false);
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var reconnectRequired = await client.ReconfigureOptionsAsync(patch);
Assert.True(reconnectRequired);
}
}
public async Task Sets_Count_On_DownloadTokenBucket_If_Download_Speed_Changed(int speed)
{
var(client, mocks) = GetFixture(new SoulseekClientOptions(maximumDownloadSpeed: 5));
var patch = new SoulseekClientOptionsPatch(maximumDownloadSpeed: speed);
var expected = (speed * 1024L) / 10;
using (client)
{
await client.ReconfigureOptionsAsync(patch);
}
mocks.DownloadTokenBucket.Verify(m => m.SetCapacity(expected), Times.Once);
}
public async Task Does_Not_Throw_If_Listener_Is_Null()
{
var(client, _) = GetFixture(new SoulseekClientOptions(enableListener: true));
var patch = new SoulseekClientOptionsPatch(enableListener: false);
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
client.SetProperty("Listener", null);
var ex = await Record.ExceptionAsync(() => client.ReconfigureOptionsAsync(patch));
Assert.Null(ex);
}
}
public async Task Does_Not_Reconfigure_Listener_If_Options_Changed_But_Was_Not_Listening()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions(incomingConnectionOptions: new ConnectionOptions()));
mocks.Listener.Setup(m => m.Listening).Returns(false);
var patch = new SoulseekClientOptionsPatch(incomingConnectionOptions: new ConnectionOptions());
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
await client.ReconfigureOptionsAsync(patch);
Assert.Equal(patch.IncomingConnectionOptions, client.Options.IncomingConnectionOptions);
Assert.Null(client.Listener);
}
}
public async Task Throws_TimeoutException_When_Timed_Out()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions());
mocks.ServerConnection
.Setup(m => m.WriteAsync(It.IsAny <IOutgoingMessage>(), It.IsAny <CancellationToken?>()))
.Throws(new TimeoutException());
var patch = new SoulseekClientOptionsPatch();
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var ex = await Record.ExceptionAsync(() => client.ReconfigureOptionsAsync(patch));
Assert.NotNull(ex);
Assert.IsType <TimeoutException>(ex);
}
}
public async Task Throws_SoulseekClientException_On_Any_Other_Error()
{
var expectedEx = new Exception("foo");
var(client, mocks) = GetFixture(new SoulseekClientOptions());
mocks.ServerConnection
.Setup(m => m.WriteAsync(It.IsAny <IOutgoingMessage>(), It.IsAny <CancellationToken?>()))
.Throws(expectedEx);
var patch = new SoulseekClientOptionsPatch();
using (client)
{
client.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var ex = await Record.ExceptionAsync(() => client.ReconfigureOptionsAsync(patch));
Assert.NotNull(ex);
Assert.IsType <SoulseekClientException>(ex);
Assert.Equal(expectedEx, ex.InnerException);
}
}
public void Clones_With_Expected_Properties_Given_A_Patch(
bool?enableListener,
bool?enableDistributedNetwork,
bool?acceptDistributedChildren,
int?maximumUploadSpeed,
int?maximumDownloadSpeed,
int?distributedChildLimit,
bool?deduplicateSearchRequests,
bool?autoAcknowledgePrivateMessages,
bool?autoAcknowledgePrivilegeNotifications,
bool?acceptPrivateRoomInvitations)
{
var serverConnectionOptions = new ConnectionOptions();
var peerConnectionOptions = new ConnectionOptions();
var transferConnectionOptions = new ConnectionOptions();
var incomingConnectionOptions = new ConnectionOptions();
var distributedConnectionOptions = new ConnectionOptions();
var userEndPointCache = new Mock <IUserEndPointCache>();
var searchResponseCache = new Mock <ISearchResponseCache>();
var searchResponseResolver = new Func <string, int, SearchQuery, Task <SearchResponse> >((s, i, q) => Task.FromResult <SearchResponse>(null));
var browseResponseResolver = new Func <string, IPEndPoint, Task <BrowseResponse> >((s, i) => Task.FromResult <BrowseResponse>(null));
var directoryContentsResponseResolver = new Func <string, IPEndPoint, int, string, Task <Directory> >((s, i, ii, ss) => Task.FromResult <Directory>(null));
var userInfoResponseResolver = new Func <string, IPEndPoint, Task <UserInfo> >((s, i) => Task.FromResult <UserInfo>(null));
var enqueueDownloadAction = new Func <string, IPEndPoint, string, Task>((s, i, ss) => Task.CompletedTask);
var placeInQueueResponseResolver = new Func <string, IPEndPoint, string, Task <int?> >((s, i, ss) => Task.FromResult <int?>(0));
var rnd = new Random();
var listenPort = rnd.Next(1024, 65535);
var patch = new SoulseekClientOptionsPatch(
enableListener,
listenPort,
enableDistributedNetwork: enableDistributedNetwork,
acceptDistributedChildren: acceptDistributedChildren,
distributedChildLimit: distributedChildLimit,
maximumUploadSpeed: maximumUploadSpeed,
maximumDownloadSpeed: maximumDownloadSpeed,
deduplicateSearchRequests: deduplicateSearchRequests,
autoAcknowledgePrivateMessages: autoAcknowledgePrivateMessages,
autoAcknowledgePrivilegeNotifications: autoAcknowledgePrivilegeNotifications,
acceptPrivateRoomInvitations: acceptPrivateRoomInvitations,
serverConnectionOptions: serverConnectionOptions,
peerConnectionOptions: peerConnectionOptions,
transferConnectionOptions: transferConnectionOptions,
incomingConnectionOptions: incomingConnectionOptions,
distributedConnectionOptions: distributedConnectionOptions,
userEndPointCache: userEndPointCache.Object,
searchResponseResolver: searchResponseResolver,
searchResponseCache: searchResponseCache.Object,
browseResponseResolver: browseResponseResolver,
directoryContentsResolver: directoryContentsResponseResolver,
userInfoResolver: userInfoResponseResolver,
enqueueDownload: enqueueDownloadAction,
placeInQueueResolver: placeInQueueResponseResolver);
var original = new SoulseekClientOptions(
maximumConcurrentUploads: 42,
maximumConcurrentDownloads: 24,
minimumDiagnosticLevel: DiagnosticLevel.None);
var o = original.With(patch);
// make sure the options that can't be patched did not change
Assert.Equal(42, o.MaximumConcurrentUploads);
Assert.Equal(24, o.MaximumConcurrentDownloads);
Assert.Equal(DiagnosticLevel.None, o.MinimumDiagnosticLevel);
Assert.Equal(enableListener, o.EnableListener);
Assert.Equal(listenPort, o.ListenPort);
Assert.Equal(enableDistributedNetwork, o.EnableDistributedNetwork);
Assert.Equal(acceptDistributedChildren, o.AcceptDistributedChildren);
Assert.Equal(distributedChildLimit, o.DistributedChildLimit);
Assert.Equal(maximumUploadSpeed, o.MaximumUploadSpeed);
Assert.Equal(maximumDownloadSpeed, o.MaximumDownloadSpeed);
Assert.Equal(deduplicateSearchRequests, o.DeduplicateSearchRequests);
Assert.Equal(autoAcknowledgePrivateMessages, o.AutoAcknowledgePrivateMessages);
Assert.Equal(autoAcknowledgePrivilegeNotifications, o.AutoAcknowledgePrivilegeNotifications);
Assert.Equal(acceptPrivateRoomInvitations, o.AcceptPrivateRoomInvitations);
Assert.Equal(peerConnectionOptions, o.PeerConnectionOptions);
Assert.Equal(incomingConnectionOptions, o.IncomingConnectionOptions);
Assert.Equal(distributedConnectionOptions, o.DistributedConnectionOptions);
Assert.Equal(serverConnectionOptions.ReadBufferSize, o.ServerConnectionOptions.ReadBufferSize);
Assert.Equal(serverConnectionOptions.WriteBufferSize, o.ServerConnectionOptions.WriteBufferSize);
Assert.Equal(serverConnectionOptions.ConnectTimeout, o.ServerConnectionOptions.ConnectTimeout);
Assert.Equal(-1, o.ServerConnectionOptions.InactivityTimeout);
Assert.Equal(transferConnectionOptions.ReadBufferSize, o.TransferConnectionOptions.ReadBufferSize);
Assert.Equal(transferConnectionOptions.WriteBufferSize, o.TransferConnectionOptions.WriteBufferSize);
Assert.Equal(transferConnectionOptions.ConnectTimeout, o.TransferConnectionOptions.ConnectTimeout);
Assert.Equal(-1, o.TransferConnectionOptions.InactivityTimeout);
Assert.Equal(userEndPointCache.Object, o.UserEndPointCache);
Assert.Equal(searchResponseResolver, o.SearchResponseResolver);
Assert.Equal(searchResponseCache.Object, o.SearchResponseCache);
Assert.Equal(browseResponseResolver, o.BrowseResponseResolver);
Assert.Equal(directoryContentsResponseResolver, o.DirectoryContentsResolver);
Assert.Equal(userInfoResponseResolver, o.UserInfoResolver);
Assert.Equal(enqueueDownloadAction, o.EnqueueDownload);
Assert.Equal(placeInQueueResponseResolver, o.PlaceInQueueResolver);
}
public async Task Updates_Options()
{
var(client, mocks) = GetFixture(new SoulseekClientOptions(
enableListener: false,
listenPort: Mocks.Port,
enableDistributedNetwork: false,
acceptDistributedChildren: false,
distributedChildLimit: 5,
deduplicateSearchRequests: true,
autoAcknowledgePrivateMessages: false,
autoAcknowledgePrivilegeNotifications: false,
acceptPrivateRoomInvitations: false,
serverConnectionOptions: new ConnectionOptions(readBufferSize: 10),
peerConnectionOptions: new ConnectionOptions(),
transferConnectionOptions: new ConnectionOptions(readBufferSize: 20),
incomingConnectionOptions: new ConnectionOptions(),
distributedConnectionOptions: new ConnectionOptions()));
var userEndPointCache = new Mock <IUserEndPointCache>();
var searchResponseCache = new Mock <ISearchResponseCache>();
var searchResponseResolver = new Func <string, int, SearchQuery, Task <SearchResponse> >((s, i, q) => Task.FromResult <SearchResponse>(null));
var browseResponseResolver = new Func <string, IPEndPoint, Task <BrowseResponse> >((s, i) => Task.FromResult <BrowseResponse>(null));
var directoryContentsResponseResolver = new Func <string, IPEndPoint, int, string, Task <Directory> >((s, i, ii, ss) => Task.FromResult <Directory>(null));
var userInfoResponseResolver = new Func <string, IPEndPoint, Task <UserInfo> >((s, i) => Task.FromResult <UserInfo>(null));
var enqueueDownloadAction = new Func <string, IPEndPoint, string, Task>((s, i, ss) => Task.CompletedTask);
var placeInQueueResponseResolver = new Func <string, IPEndPoint, string, Task <int?> >((s, i, ss) => Task.FromResult <int?>(0));
var patch = new SoulseekClientOptionsPatch(
enableListener: true,
listenPort: Mocks.Port,
enableDistributedNetwork: true,
acceptDistributedChildren: true,
distributedChildLimit: 10,
deduplicateSearchRequests: false,
autoAcknowledgePrivateMessages: true,
autoAcknowledgePrivilegeNotifications: true,
acceptPrivateRoomInvitations: true,
serverConnectionOptions: new ConnectionOptions(readBufferSize: 100),
peerConnectionOptions: new ConnectionOptions(),
transferConnectionOptions: new ConnectionOptions(readBufferSize: 200),
incomingConnectionOptions: new ConnectionOptions(),
distributedConnectionOptions: new ConnectionOptions(),
userEndPointCache: userEndPointCache.Object,
searchResponseResolver: searchResponseResolver,
searchResponseCache: searchResponseCache.Object,
browseResponseResolver: browseResponseResolver,
directoryContentsResolver: directoryContentsResponseResolver,
userInfoResolver: userInfoResponseResolver,
enqueueDownload: enqueueDownloadAction,
placeInQueueResolver: placeInQueueResponseResolver);
using (client)
{
client.SetProperty("State", SoulseekClientStates.Disconnected);
await client.ReconfigureOptionsAsync(patch);
Assert.Equal(patch.EnableListener, client.Options.EnableListener);
Assert.Equal(patch.ListenPort, client.Options.ListenPort);
Assert.Equal(patch.EnableDistributedNetwork, client.Options.EnableDistributedNetwork);
Assert.Equal(patch.AcceptDistributedChildren, client.Options.AcceptDistributedChildren);
Assert.Equal(patch.DistributedChildLimit, client.Options.DistributedChildLimit);
Assert.Equal(patch.DeduplicateSearchRequests, client.Options.DeduplicateSearchRequests);
Assert.Equal(patch.AutoAcknowledgePrivateMessages, client.Options.AutoAcknowledgePrivateMessages);
Assert.Equal(patch.AutoAcknowledgePrivilegeNotifications, client.Options.AutoAcknowledgePrivilegeNotifications);
Assert.Equal(patch.AcceptPrivateRoomInvitations, client.Options.AcceptPrivateRoomInvitations);
Assert.Equal(patch.PeerConnectionOptions, client.Options.PeerConnectionOptions);
Assert.Equal(patch.IncomingConnectionOptions, client.Options.IncomingConnectionOptions);
Assert.Equal(patch.DistributedConnectionOptions, client.Options.DistributedConnectionOptions);
Assert.Equal(patch.ServerConnectionOptions.ReadBufferSize, client.Options.ServerConnectionOptions.ReadBufferSize);
Assert.Equal(patch.TransferConnectionOptions.ReadBufferSize, client.Options.TransferConnectionOptions.ReadBufferSize);
Assert.Equal(patch.UserEndPointCache, client.Options.UserEndPointCache);
Assert.Equal(patch.SearchResponseCache, client.Options.SearchResponseCache);
Assert.Equal(patch.SearchResponseResolver, client.Options.SearchResponseResolver);
Assert.Equal(patch.BrowseResponseResolver, client.Options.BrowseResponseResolver);
Assert.Equal(patch.DirectoryContentsResolver, client.Options.DirectoryContentsResolver);
Assert.Equal(patch.UserInfoResolver, client.Options.UserInfoResolver);
Assert.Equal(patch.EnqueueDownload, client.Options.EnqueueDownload);
Assert.Equal(patch.PlaceInQueueResolver, client.Options.PlaceInQueueResolver);
}
}
