public void WhenClientConnectsToServer_AddsFiles_ClientShouldFireFilesUpdateEvent()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings))
{
client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
client.Connect();
client.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
}
}
}
public void WhenFileModificationMessages_ModeNew_AreSentByClient_TheyShouldBeFullyReceivedByServer()
{
_serverMessage = null;
FileDescriptor[] descriptors = null;
string originId = "Not Set";
using (ServerInstance server = new ServerInstance(_settings))
{
server.MessageReceived += new EventHandler<ObviousCode.Interlace.BitTunnelLibrary.Events.MessageEventArgs>(server_MessageReceived);
server.Connect();
while (!server.IsConnected) ;
using (ClientInstance client = new ClientInstance(_settings))
{
client.Connect();
originId = client.ConnectionDetails.InstanceId;
descriptors = new List<FileDescriptor>()
{
FileDescriptor.Create(_existingFile1, true),
FileDescriptor.Create(_existingFile2, true),
FileDescriptor.Create(_existingFile3, true)
}.ToArray();
_serverModificationMessage = null;
client.AddFiles(descriptors);
DateTime then = DateTime.Now;
while (_serverModificationMessage == null && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsNotNull(_serverModificationMessage);
Assert.AreEqual(descriptors[0].FileFullName, _serverModificationMessage.Modifications[0].FileFullName);
Assert.AreEqual(descriptors[1].FileFullName, _serverModificationMessage.Modifications[1].FileFullName);
Assert.AreEqual(descriptors[2].FileFullName, _serverModificationMessage.Modifications[2].FileFullName);
//Assert.AreEqual(descriptors[0].FileId, _serverModificationMessage.Modifications[0].FileId);
//Assert.AreEqual(descriptors[1].FileId, _serverModificationMessage.Modifications[1].FileId);
//Assert.AreEqual(descriptors[2].FileId, _serverModificationMessage.Modifications[2].FileId);
Assert.AreEqual(originId, _serverModificationMessage.Modifications[0].OriginId);
Assert.AreEqual(originId, _serverModificationMessage.Modifications[1].OriginId);
Assert.AreEqual(originId, _serverModificationMessage.Modifications[2].OriginId);
Assert.AreEqual(FileModificationMode.New, _serverModificationMessage.Modifications[0].Mode);
Assert.AreEqual(FileModificationMode.New, _serverModificationMessage.Modifications[1].Mode);
Assert.AreEqual(FileModificationMode.New, _serverModificationMessage.Modifications[2].Mode);
}
}
}
public void WhenFileOwnedByTwoClients_ClientTwoRefusesRequest_FileShouldBeAvailableFromClientOne()
{
//Test intended to show that order of client connection not contributing factor in download rather that testing which client file was retrieved from
bool fileListUpdateReceived = false;
bool requestedFileAvailable = false;
bool fileRequestResponseReceived = false;
string expectedHash = _existingFiles[1].Hash;
bool allowRequest = true;
_fileRequestReceivedCallback = new Action<FileRequestEventArgs>(delegate(FileRequestEventArgs e)
{
if (e.File.Hash == expectedHash)
{
e.Allow = allowRequest;
allowRequest = !allowRequest;
}
});
_fileListUpdateCallback = new Action(delegate()
{
fileListUpdateReceived = true;
});
_fileRequestResponseCallback = new Action<FileRequestResponseEventArgs>(delegate(FileRequestResponseEventArgs e)
{
if (e.File.Hash == expectedHash)
{
if (!requestedFileAvailable)
{
requestedFileAvailable = e.Response == FileRequestMode.Available;
}
fileRequestResponseReceived = true;
}
});
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client1 = new ClientInstance(_settings, "Client 1"))
{
client1.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived);
client1.FileRequestReceived += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived);
client1.Connect();
client1.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fileListUpdateReceived);
fileListUpdateReceived = false;
using (ClientInstance client2 = new ClientInstance(_settings, "Client 2"))
{
client2.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived);
client2.FileRequestReceived += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived);
client2.Connect();
client2.AddFiles(_existingFiles);
then = DateTime.Now;
while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fileListUpdateReceived);
fileListUpdateReceived = false;
using (ClientInstance client3 = new ClientInstance(_settings, "Client 3"))
{
client3.FileRequestResponseReceived += new EventHandler<FileRequestResponseEventArgs>(client_FileRequestResponseReceived);
client3.Connect();
client3.RequestFile(_existingFiles[1]);
then = DateTime.Now;
while (!fileRequestResponseReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fileRequestResponseReceived);
Assert.IsTrue(requestedFileAvailable);
}
}
}
}
}
public void WhenFileIsRequestedFromClientThatContainsFile_FileShouldBeServedInstantlyWithoutCallingServer()
{
bool fileListUpdateReceived = false;
bool fileRequestReceived = false;
FileInfo requestedFile = null;
string expectedHash = _existingFiles[2].Hash;
_fileRequestReceivedCallback = new Action<FileRequestEventArgs>(delegate(FileRequestEventArgs e)
{
fileRequestReceived = true;
});
_fileTransferCompletedCallback = new Action<FileTransferCompletedEventArgs>(delegate (FileTransferCompletedEventArgs e)
{
if (expectedHash == e.Hash)
{
requestedFile = new FileInfo(e.Location);
}
}
);
_fileListUpdateCallback = new Action(delegate()
{
fileListUpdateReceived = true;
}
);
using (ServerInstance server = new ServerInstance(_settings))
{
server.FileRequested += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived);
server.Connect();
using (ClientInstance client = new ClientInstance(_settings))
{
client.FileTransferCompleted +=new EventHandler<FileTransferCompletedEventArgs>(client_FileTransferCompleted);
client.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived);
client.Connect();
client.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fileListUpdateReceived);
client.RequestFile(_existingFiles[2]);
then = DateTime.Now;
while (requestedFile == null && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsNotNull(requestedFile);
Assert.IsFalse(fileRequestReceived);
Assert.AreEqual(_existingFiles[2].FileFullName, requestedFile.FullName);
FilesIsEqualToRequestedFile(_existingFiles[2], requestedFile);
}
}
}
public void WhenFileIsRequested_FileProgressTransferEventsShouldFire()
{
int progressCalls = 0;
bool fullFileListReceived = false;
bool fileListUpdateReceived = false;
bool fileTransferCompleted = false;
string expectedHash = _existingFiles[2].Hash;
int backup = _settings.FileChunkSize;
_settings.FileChunkSize = 1024;
_transferProgressCallback = new Action(delegate()
{
progressCalls++;
}
);
_fullFileListReceivedCallback = new Action(delegate()
{
fullFileListReceived = true;
});
_fileListUpdateCallback = new Action(delegate()
{
fileListUpdateReceived = true;
});
_fileTransferCompletedCallback = new Action<FileTransferCompletedEventArgs>(delegate(FileTransferCompletedEventArgs e)
{
if (e.Hash == expectedHash)
{
fileTransferCompleted = true;
}
});
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance owningClient = new ClientInstance(_settings, "Owning"))
{
owningClient.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived);
owningClient.Connect();
owningClient.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 60) ;
Assert.IsTrue(fileListUpdateReceived);
using (ClientInstance requestingClient = new ClientInstance(_settings, "Requesting"))
{
progressCalls = 0;
fullFileListReceived = false;
requestingClient.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived);
requestingClient.FileTransferProgressed += new EventHandler<FileTransferEventArgs>(client_FileTransferProgressed);
requestingClient.FileTransferCompleted +=new EventHandler<FileTransferCompletedEventArgs>(client_FileTransferCompleted);
requestingClient.Connect();
then = DateTime.Now;
while (!fullFileListReceived && (DateTime.Now - then).TotalSeconds < 60) ;
Assert.IsTrue(fullFileListReceived);
then = DateTime.Now;
requestingClient.RequestFile(_existingFiles[2]);
while (!fileTransferCompleted && (DateTime.Now - then).TotalMinutes < 10) ;
Assert.IsTrue(fileTransferCompleted);
Assert.AreEqual(Math.Ceiling((double)FILESIZE / _settings.FileChunkSize), progressCalls);
}
}
}
_settings.FileChunkSize = backup;
}
public void WhenFileIsRequestedFromClient_ServerBlocksRequest_FailResponseIsReceived()
{
bool fileListUpdateReceived = false;
bool fileRequestResponseReceived = false;
bool fileRequestFailed = false;
string expectedHash = _existingFiles[0].Hash;
_fileListUpdateCallback = new Action(delegate()
{
fileListUpdateReceived = true;
});
_fileRequestReceivedCallback = new Action<FileRequestEventArgs>(delegate(FileRequestEventArgs e)
{
if (e.File.Hash == expectedHash)
{
e.Allow = false;
}
});
_fileRequestResponseCallback = new Action<FileRequestResponseEventArgs>(delegate(FileRequestResponseEventArgs e)
{
if (e.File.Hash == expectedHash)
{
if (e.Response == FileRequestMode.NotAvailable)
{
fileRequestFailed = true;
fileRequestResponseReceived = true;
}
}
});
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
server.FileRequested += new EventHandler<FileRequestEventArgs>(event_FileRequestReceived);
using (ClientInstance client = new ClientInstance(_settings))
{
fileListUpdateReceived = false;
client.Connect();
client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived);
client.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fileListUpdateReceived);
using (ClientInstance client2 = new ClientInstance(_settings, "Client2"))
{
client2.FileRequestResponseReceived +=new EventHandler<FileRequestResponseEventArgs>(client_FileRequestResponseReceived);
client2.Connect();
client2.RequestFile(_existingFiles[0]);
then = DateTime.Now;
while (!fileRequestFailed && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fileRequestResponseReceived);
Assert.IsTrue(fileRequestFailed);
}
}
}
}
public void WhenFileIsRequestedFromClient_FileExists_RequestingClientConnectsSecond_FileShouldBeServedInFull()
{
bool fileListUpdateReceived = false;
bool fullFileListReceived = false;
bool requestedFileReceived = false;
FileInfo requestedFile = null;
_fullFileListReceivedCallback = new Action(delegate()
{
fullFileListReceived = true;
});
_fileListUpdateCallback = new Action(delegate()
{
fileListUpdateReceived = true;
});
_fileTransferCompletedCallback = new Action<FileTransferCompletedEventArgs>(delegate(FileTransferCompletedEventArgs args)
{
requestedFile = new FileInfo(args.Location);
requestedFileReceived = true;
});
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance clientOwning = new ClientInstance(_settings, "Owning Client"))
{
clientOwning.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived);
clientOwning.Connect();
clientOwning.AddFiles(_existingFiles);
using (ClientInstance clientRequesting = new ClientInstance(_settings, "Requesting Client"))
{
clientRequesting.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived);
clientRequesting.FileTransferCompleted += new EventHandler<FileTransferCompletedEventArgs>(client_FileTransferCompleted);
clientRequesting.Connect();
DateTime then = DateTime.Now;
while (!fullFileListReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fullFileListReceived);
clientRequesting.RequestFile(_existingFiles[1]);
then = DateTime.Now;
while (!requestedFileReceived && (DateTime.Now - then).TotalMinutes < 10) ;
Assert.IsTrue(fileListUpdateReceived);
Assert.IsTrue(requestedFileReceived);
Assert.IsNotNull(requestedFile);
Assert.IsTrue(FilesIsEqualToRequestedFile(_existingFiles[1], requestedFile));
}
}
}
}
public void WhenFilesAddedLocally_Twice_ShouldOnlyBeReflectedOnceInLocalFiles()
{
using(ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings))
{
client.Connect();
client.AddFiles(_existingFiles);
client.AddFiles(_existingFiles);
Assert.AreEqual(3, client.LocalFiles.UniqueFileCount);
Assert.AreEqual(3, client.LocalFiles.FileInstanceCount);
}
}
}
public void WhenFilesAddedLocally_AndRemovedLocally_ShouldBeRemovedFromLocalFiles()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings))
{
client.Connect();
client.AddFiles(_existingFiles);
client.RemoveFiles(_existingFiles);
Assert.AreEqual(0, client.LocalFiles.UniqueFileCount);
Assert.AreEqual(0, client.LocalFiles.FileInstanceCount);
}
}
}
public void WhenSecondClientConnectsToServer_SecondClientAddsFile_FirstClientFilesShouldReflectServerFiles()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings))
{
client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
client.Connect();
using(ClientInstance client2 = new ClientInstance(_settings))
{
client2.Connect();
client2.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
Assert.IsTrue(client.AvailableFiles.Contains(_existingFiles));
}
}
}
}
public void WhenSecondClientTriesToRemoveFirstClientFiles_ShouldHaveNoEffect()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings, "Test Client 1"))
{
client.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
client.Connect();
client.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount);
_fileListUpdateReceived = false;
client.FileListUpdateReceived -= new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
using (ClientInstance client2 = new ClientInstance(_settings, "Test Client 2"))
{
client2.FullFileListReceived +=new EventHandler<FileListEventArgs>(client_FullFileListReceived);
client2.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
client2.Connect();
then = DateTime.Now;
while (!_fileListReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListReceived);
Assert.AreEqual(3, client2.AvailableFiles.UniqueFileCount);
_fileListReceived = false;
client2.RemoveFiles(_existingFiles);
then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
Assert.AreEqual(3, client2.AvailableFiles.UniqueFileCount);
Assert.IsTrue(client2.AvailableFiles.Contains(_existingFiles));
}
}
}
}
public void WhenSecondClientConnectsToServerWithFiles_SecondClientAddsSomeOfTheSameFiles_FirstClientFilesShouldBeASingleInstanceOfAllThree()
{
using(ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using(ClientInstance client = new ClientInstance(_settings))
{
client.FileListUpdateReceived +=new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
client.Connect();
client.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount);
Assert.AreEqual(3, client.AvailableFiles.FileInstanceCount);
Assert.IsTrue(client.AvailableFiles.Contains(_existingFiles));
_fileListUpdateReceived = false;
using (ClientInstance client2 = new ClientInstance(_settings))
{
client2.Connect();
client2.AddFiles(new FileDescriptor[] {
FileDescriptor.Create(_existingFile1),
FileDescriptor.Create(_existingFile3)}
);
then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount);
Assert.AreEqual(3, client.AvailableFiles.FileInstanceCount);
Assert.IsTrue(client.AvailableFiles.Contains(_existingFiles));
Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile1).Hash));
Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile2)));
Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile3)));
}
}
}
}
public void WhenSecondClientConnectsToServerWithFiles_ClientFileCountShouldReflectFirstClientFiles()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client1 = new ClientInstance(_settings))
{
client1.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived);
client1.Connect();
client1.AddFiles(_existingFiles);
DateTime start = DateTime.Now;
while (!_fileListReceived && (DateTime.Now - start).TotalMilliseconds < 1000) ;
_fileListReceived = false;
using (ClientInstance client2 = new ClientInstance(_settings))
{
client2.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived);
client2.Connect();
while (!_fileListReceived && (DateTime.Now - start).TotalMilliseconds < 1000) ;
Assert.IsTrue(_fileListReceived);
Assert.IsTrue(client2.AvailableFiles.Contains(_existingFiles));
Assert.IsTrue(client2.AvailableFiles.Contains(client1.AvailableFiles.GetCurrentUniqueFileList().ToArray()));
}
}
}
}
public void WhenFirstClientConnectsToServer_AddsFiles_SecondClientAddsSameFiles_FirstClientRemovesOneFile_ClientsShouldHaveOneInstanceOfAllFiles()
{
using(ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using(ClientInstance client = new ClientInstance(_settings, "Client 1"))
{
client.Connect();
client.FileListUpdateReceived+=new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
client.AddFiles(_existingFiles);
DateTime then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
client.FileListUpdateReceived -= new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
_fileListUpdateReceived = false;
using (ClientInstance client2 = new ClientInstance(_settings, "Client 2"))
{
client2.Connect();
client2.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdated);
client2.AddFiles(_existingFiles);
then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
_fileListUpdateReceived = false;
client.RemoveFiles(
new FileDescriptor[]
{
_existingFiles[1]
}
);
then = DateTime.Now;
while (!_fileListUpdateReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(_fileListUpdateReceived);
Assert.AreEqual(3, client2.AvailableFiles.UniqueFileCount);
Assert.AreEqual(3, client2.AvailableFiles.FileInstanceCount);
Assert.AreEqual(1, client2.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile1)));
Assert.AreEqual(1, client2.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile2)));
Assert.AreEqual(1, client2.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile3)));
//These should have been set by now, as client2 is sent file updates after client, however if race conditions still exist
//add a second event handler for the file received on the first client and a second boolean to check
Assert.AreEqual(3, client.AvailableFiles.UniqueFileCount);
Assert.AreEqual(3, client.AvailableFiles.FileInstanceCount);
Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile1)));
Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile2)));
Assert.AreEqual(1, client.AvailableFiles.CountOf(FileDescriptor.Create(_existingFile3)));
}
}
}
}
public void WhenFirstClientConnectsToServer_SendsNew_Existing_Files_SecondClientConnects_SecondClientShouldReceiveCorrectFileListMessage()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings, "Test Client 1"))
{
_clientMessage = null;
client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived);
client.Connect();
DateTime start = DateTime.Now;
while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileList) && (DateTime.Now - start).TotalMilliseconds < 1000) ;
Assert.IsNotNull(_clientMessage);
Assert.AreEqual(MessageKeys.FileList, _clientMessage.Key);
Assert.AreEqual(0, (_clientMessage as FileListMessage).FileList.Count);
client.MessageReceived -= new EventHandler<MessageEventArgs>(client_MessageReceived);
_clientMessage = null;
using (ClientInstance client2 = new ClientInstance(_settings, "Test Client 2"))
{
client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived);
client2.Connect();
FileDescriptor[] descriptors = new List<FileDescriptor>()
{
FileDescriptor.Create(_existingFile1.FullName, true),
FileDescriptor.Create(_existingFile2.FullName, true),
FileDescriptor.Create(_existingFile3.FullName, true)
}.ToArray();
client2.AddFiles(descriptors);
start = DateTime.Now;
//Wait a second for the network activity
while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileListModifications) && (DateTime.Now - start).TotalMilliseconds < 1000) ;
Assert.IsNotNull(_clientMessage as FileModificationMessage);
Assert.AreEqual(MessageKeys.FileListModifications, _clientMessage.Key);
Assert.AreEqual(3, (_clientMessage as FileModificationMessage).Modifications.Count);
//Side effect of both being on same server?
Assert.IsTrue((_clientMessage as FileModificationMessage).Modifications[0].Exists);
Assert.IsTrue((_clientMessage as FileModificationMessage).Modifications[1].Exists);
Assert.IsTrue((_clientMessage as FileModificationMessage).Modifications[2].Exists);
Assert.AreEqual(_existingFile1.FullName, (_clientMessage as FileModificationMessage).Modifications[0].FileFullName);
Assert.AreEqual(_existingFile2.FullName, (_clientMessage as FileModificationMessage).Modifications[1].FileFullName);
Assert.AreEqual(_existingFile3.FullName, (_clientMessage as FileModificationMessage).Modifications[2].FileFullName);
//Assert.AreEqual(descriptors[0].FileId, (_clientMessage as FileModificationMessage).Modifications[0].FileId);
//Assert.AreEqual(descriptors[1].FileId, (_clientMessage as FileModificationMessage).Modifications[1].FileId);
//Assert.AreEqual(descriptors[2].FileId, (_clientMessage as FileModificationMessage).Modifications[2].FileId);
Assert.AreEqual(descriptors[0].Hash, (_clientMessage as FileModificationMessage).Modifications[0].Hash);
Assert.AreEqual(descriptors[1].Hash, (_clientMessage as FileModificationMessage).Modifications[1].Hash);
Assert.AreEqual(descriptors[2].Hash, (_clientMessage as FileModificationMessage).Modifications[2].Hash);
Assert.AreEqual(FileModificationMode.New, (_clientMessage as FileModificationMessage).Modifications[0].Mode);
Assert.AreEqual(FileModificationMode.New, (_clientMessage as FileModificationMessage).Modifications[1].Mode);
Assert.AreEqual(FileModificationMode.New, (_clientMessage as FileModificationMessage).Modifications[2].Mode);
Assert.AreEqual(descriptors[0].OriginId, (_clientMessage as FileModificationMessage).Modifications[0].OriginId);
Assert.AreEqual(descriptors[1].OriginId, (_clientMessage as FileModificationMessage).Modifications[1].OriginId);
Assert.AreEqual(descriptors[2].OriginId, (_clientMessage as FileModificationMessage).Modifications[2].OriginId);
}
}
}
}
public void WhenFileIsRequestedFromClient_FileExists_FileInitiatedEventShouldFire()
{
bool fileListUpdateReceived = false;
bool fullFileListReceived = false;
bool fileTransferInitiatedEventReceived = false;
_fileListUpdateCallback = new Action(delegate()
{
fileListUpdateReceived = true;
});
_fullFileListReceivedCallback = new Action(delegate()
{
fullFileListReceived = true;
});
_fileTransferInitiatedCallback = new Action(delegate()
{
fileTransferInitiatedEventReceived = true;
});
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance clientOwning = new ClientInstance(_settings, "Owning Client"))
{
clientOwning.FileListUpdateReceived += new EventHandler<FileListModificationEventArgs>(client_FileListUpdateReceived);
clientOwning.Connect();
clientOwning.AddFiles(_existingFiles);
using (ClientInstance clientRequesting = new ClientInstance(_settings, "Requesting Client"))
{
clientRequesting.FullFileListReceived += new EventHandler<FileListEventArgs>(client_FullFileListReceived);
clientRequesting.FileTransferInitiated += new EventHandler<FileTransferEventArgs>(client_FileTransferInitiated);
clientRequesting.Connect();
DateTime then = DateTime.Now;
while (!fullFileListReceived && (DateTime.Now - then).TotalSeconds < 1) ;
Assert.IsTrue(fullFileListReceived);
clientRequesting.RequestFile(_existingFiles[1]);
then = DateTime.Now;
while (!fileTransferInitiatedEventReceived && (DateTime.Now - then).TotalSeconds < 60) ;
Assert.IsTrue(fileTransferInitiatedEventReceived);
}
}
}
}
public void WhenFirstClientConnectsToServer_SendsNew_NonExisting_Files_SecondClientConnects_SecondClientShouldReceiveEmptytFileListMessage()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings, "Test Client 1"))
{
client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived);
client.Connect();
DateTime start = DateTime.Now;
while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileList) && (DateTime.Now - start).TotalMilliseconds < 1000) ;
Assert.IsNotNull(_clientMessage);
Assert.AreEqual(MessageKeys.FileList, _clientMessage.Key);
Assert.AreEqual(0, (_clientMessage as FileListMessage).FileList.Count);
_clientMessage = null;
using (ClientInstance client2 = new ClientInstance(_settings, "Test Client 2"))
{
client2.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived);
client2.Connect();
FileDescriptor[] descriptors = new List<FileDescriptor>()
{
FileDescriptor.Create(@"C:\DoesNotExist.txt", true),
FileDescriptor.Create(@"C:\CompletelyFake.txt", true),
FileDescriptor.Create(@"C:\PureHumbug.txt", true)
}.ToArray();
client.AddFiles(descriptors);
start = DateTime.Now;
while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileListModifications) && (DateTime.Now - start).TotalMilliseconds < 1000) ;
Assert.IsNotNull(_clientMessage as FileModificationMessage);
Assert.AreEqual(MessageKeys.FileListModifications, _clientMessage.Key);
Assert.AreEqual(0, (_clientMessage as FileModificationMessage).Modifications.Count);
_clientMessage = null;
client2.MessageReceived -= new EventHandler<MessageEventArgs>(client_MessageReceived);
client.MessageReceived += new EventHandler<MessageEventArgs>(client_MessageReceived);
descriptors = new List<FileDescriptor>()
{
FileDescriptor.Create(@"C:\DoesNotExist.txt", true),
FileDescriptor.Create(@"C:\CompletelyFake.txt", true),
FileDescriptor.Create(@"C:\PureHumbug.txt", true)
}.ToArray();
client.AddFiles(descriptors);
start = DateTime.Now;
while ((_clientMessage == null || _clientMessage.Key != MessageKeys.FileListModifications) && (DateTime.Now - start).TotalMilliseconds < 1000) ;
Assert.IsNotNull(_clientMessage as FileModificationMessage);
Assert.AreEqual(MessageKeys.FileListModifications, _clientMessage.Key);
Assert.AreEqual(0, (_clientMessage as FileModificationMessage).Modifications.Count);
}
}
}
}
public void WhenFilesAddedLocally_AndSomeRemovedLocally_OnlyRemovedFilesShouldBeRemovedFromLocalFiles()
{
using (ServerInstance server = new ServerInstance(_settings))
{
server.Connect();
using (ClientInstance client = new ClientInstance(_settings))
{
client.Connect();
client.AddFiles(_existingFiles);
client.RemoveFiles(new FileDescriptor[]{_existingFiles[0], _existingFiles[2]} );
Assert.AreEqual(1, client.LocalFiles.UniqueFileCount);
Assert.AreEqual(1, client.LocalFiles.FileInstanceCount);
Assert.IsTrue(client.LocalFiles.Contains(_existingFiles[1]));
}
}
}
