public static PlaylistList FromBrowseResponse(BrowseResponse response)
{
PlaylistList list = new PlaylistList();
List <Content> contents;
if (response.ContinuationContents != null)
{
contents = response.ContinuationContents.GridContinuation.Items;
if (response.ContinuationContents.GridContinuation.Continuations != null)
{
list.Continuation = response.ContinuationContents.GridContinuation.Continuations[0].NextContinuationData.Continuation;
}
}
else
{
var renderer = response.Contents.SingleColumnBrowseResultsRenderer.Tabs[0].TabRenderer.Content.SectionListRenderer.Contents[1].ItemSectionRenderer.Contents[0].GridRenderer;
contents = renderer.Items;
list.Continuation = renderer.Continuations[0].NextContinuationData.Continuation;
}
foreach (var item in contents)
{
// the first item in the list might not be a playlist, but the "createplaylist"
// ... not sure what this is, but we want to skip it
if (item.MusicTwoRowItemRenderer.NavigationEndpoint.CreatePlaylistEndpoint == null)
{
list.Playlists.Add(Playlist.FromMusicTwoRowItemRenderer(item.MusicTwoRowItemRenderer));
}
}
return(list);
}
public async Task BrowseInternalAsync_Returns_Expected_Response_On_Success(string username, IPAddress ip, int port, string localUsername, List <Directory> directories)
{
var response = new BrowseResponse(directories.Count, directories);
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.WaitIndefinitely <BrowseResponse>(It.IsAny <WaitKey>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(response));
waiter.Setup(m => m.Wait <GetPeerAddressResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new GetPeerAddressResponse(username, ip, port)));
var conn = new Mock <IMessageConnection>();
conn.Setup(m => m.State)
.Returns(ConnectionState.Connected);
conn.Setup(m => m.WriteMessageAsync(It.IsAny <Message>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
var connManager = new Mock <IConnectionManager>();
connManager.Setup(m => m.GetOrAddUnsolicitedConnectionAsync(It.IsAny <ConnectionKey>(), localUsername, It.IsAny <EventHandler <Message> >(), It.IsAny <ConnectionOptions>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(conn.Object));
var s = new SoulseekClient("127.0.0.1", 1, waiter: waiter.Object, serverConnection: conn.Object, connectionManager: connManager.Object);
s.SetProperty("Username", localUsername);
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var result = await s.BrowseAsync(username);
Assert.Equal(response, result);
}
public BrowseResponse CreateFor(string actionXNamespace, string xml)
{
var xElement = XDocument.Parse(xml);
var browseResponseElement = xElement.Descendants(XName.Get("BrowseResponse", actionXNamespace)).First();
int.TryParse(browseResponseElement.Element("NumberReturned")?.Value, out var numberReturned);
int.TryParse(browseResponseElement.Element("TotalMatches")?.Value, out var totalMatches);
int.TryParse(browseResponseElement.Element("UpdateID")?.Value, out var updateId);
var didlElement = browseResponseElement.Element("Result")?.Value;
var browseResponse = new BrowseResponse
{
NumberReturned = numberReturned,
TotalMatches = totalMatches,
UpdateId = updateId,
DidlRaw = didlElement
};
if ((browseResponse.NumberReturned > 0) && (didlElement != null))
{
IEnumerable <XElement> itemElements = XElement.Parse(didlElement).Elements();
foreach (var itemElement in itemElements)
{
browseResponse.Items.Add(CreateItem(itemElement));
}
}
return(browseResponse);
}
public async Task <ServiceResult <BrowseResponse <CourseResponse> > > GetCourses(CourseBrowseRequest request)
{
IQueryable <Course> query;
var studentId = request.StudentId.GetValueOrDefault();
if (request.StudentId.HasValue)
{
query = _unitOfWork.EnrollmentRepository.
Get(e => e.StudentId == studentId).
Select(e => e.Course);
}
else
{
query = _unitOfWork.CourseRepository.Get();
}
var response = new BrowseResponse <CourseResponse>
{
PageInfo = request.PageInfo,
PageResult = await query.ToPageResultAsync <Course, CourseResponse>(request.PageInfo.Offset, request.PageInfo.Limit)
};
return(new ServiceResult <BrowseResponse <CourseResponse> > {
Data = response
});
}
public async Task BrowseInternalAsync_Throws_BrowseException_On_Disconnect(string username, IPAddress ip, int port, string localUsername)
{
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.Wait <GetPeerAddressResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new GetPeerAddressResponse(username, ip, port)));
waiter.Setup(m => m.WaitIndefinitely <BrowseResponse>(It.IsAny <WaitKey>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromException <BrowseResponse>(new ConnectionException("disconnected unexpectedly")));
var conn = new Mock <IMessageConnection>();
conn.Setup(m => m.WriteMessageAsync(It.IsAny <Message>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Raises(m => m.Disconnected += null, conn.Object, string.Empty);
var connManager = new Mock <IConnectionManager>();
connManager.Setup(m => m.GetOrAddUnsolicitedConnectionAsync(It.IsAny <ConnectionKey>(), localUsername, It.IsAny <EventHandler <Message> >(), It.IsAny <ConnectionOptions>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(conn.Object));
var s = new SoulseekClient("127.0.0.1", 1, waiter: waiter.Object, serverConnection: conn.Object, connectionManager: connManager.Object);
s.SetProperty("Username", localUsername);
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
BrowseResponse result = null;
var ex = await Record.ExceptionAsync(async() => result = await s.BrowseAsync(username));
Assert.NotNull(ex);
Assert.IsType <BrowseException>(ex);
Assert.IsType <ConnectionException>(ex.InnerException);
Assert.Contains("disconnected unexpectedly", ex.InnerException.Message, StringComparison.InvariantCultureIgnoreCase);
}
public void Sends_Resolved_BrowseResponse()
{
var files = new List <File>()
{
new File(1, "1", 1, "1", 1, new List <FileAttribute>()
{
new FileAttribute(FileAttributeType.BitDepth, 1)
}),
new File(2, "2", 2, "2", 1, new List <FileAttribute>()
{
new FileAttribute(FileAttributeType.BitRate, 2)
}),
};
IEnumerable <Directory> dirs = new List <Directory>()
{
new Directory("1", 2, files),
new Directory("2", 2, files),
};
var response = new BrowseResponse(dirs);
var options = new SoulseekClientOptions(browseResponseResolver: (u, i) => Task.FromResult(response));
var(handler, mocks) = GetFixture(options: options);
var msg = new BrowseRequest().ToByteArray();
handler.HandleMessageRead(mocks.PeerConnection.Object, msg);
mocks.PeerConnection.Verify(
m => m.WriteAsync(It.Is <byte[]>(b => Encoding.UTF8.GetString(b) == Encoding.UTF8.GetString(response.ToByteArray())), null), Times.Once);
}
public void Parse_Handles_Empty_Directory()
{
var name = Guid.NewGuid().ToString();
var msg = new MessageBuilder()
.Code(MessageCode.PeerBrowseResponse)
.WriteInteger(1) // directory count
.WriteString(name) // first directory name
.WriteInteger(0) // first directory file count
.Compress()
.Build();
BrowseResponse r = default(BrowseResponse);
var ex = Record.Exception(() => r = BrowseResponse.Parse(msg));
Assert.Null(ex);
Assert.Equal(1, r.DirectoryCount);
Assert.Single(r.Directories);
var d = r.Directories.ToList();
Assert.Equal(name, d[0].Directoryname);
Assert.Equal(0, d[0].FileCount);
Assert.Empty(d[0].Files);
}
public async Task BrowseInternalAsync_Throws_BrowseException_On_Write_Exception(string username, IPAddress ip, int port, string localUsername)
{
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.Wait <GetPeerAddressResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new GetPeerAddressResponse(username, ip, port)));
var conn = new Mock <IMessageConnection>();
conn.Setup(m => m.WriteMessageAsync(It.IsAny <Message>(), It.IsAny <CancellationToken>()))
.Throws(new ConnectionWriteException());
var connManager = new Mock <IConnectionManager>();
connManager.Setup(m => m.GetOrAddUnsolicitedConnectionAsync(It.IsAny <ConnectionKey>(), localUsername, It.IsAny <EventHandler <Message> >(), It.IsAny <ConnectionOptions>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(conn.Object));
var s = new SoulseekClient("127.0.0.1", 1, waiter: waiter.Object, serverConnection: conn.Object, connectionManager: connManager.Object);
s.SetProperty("Username", localUsername);
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
BrowseResponse result = null;
var ex = await Record.ExceptionAsync(async() => result = await s.BrowseAsync(username));
Assert.NotNull(ex);
Assert.IsType <BrowseException>(ex);
Assert.IsType <ConnectionWriteException>(ex.InnerException);
}
public async Task BrowseInternalAsync_Throws_BrowseException_On_Cancellation(string username, IPAddress ip, int port, string localUsername)
{
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.WaitIndefinitely <BrowseResponse>(It.IsAny <WaitKey>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromException <BrowseResponse>(new OperationCanceledException()));
waiter.Setup(m => m.Wait <GetPeerAddressResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new GetPeerAddressResponse(username, ip, port)));
var conn = new Mock <IMessageConnection>();
conn.Setup(m => m.State)
.Returns(ConnectionState.Connected);
conn.Setup(m => m.WriteAsync(It.IsAny <byte[]>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
var connManager = new Mock <IPeerConnectionManager>();
connManager.Setup(m => m.GetOrAddMessageConnectionAsync(username, ip, port, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(conn.Object));
using (var s = new SoulseekClient("127.0.0.1", 1, waiter: waiter.Object, serverConnection: conn.Object, peerConnectionManager: connManager.Object))
{
s.SetProperty("Username", localUsername);
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
BrowseResponse result = null;
var ex = await Record.ExceptionAsync(async() => result = await s.BrowseAsync(username));
Assert.NotNull(ex);
Assert.IsType <BrowseException>(ex);
Assert.IsType <OperationCanceledException>(ex.InnerException);
}
}
public void Parse_Handles_An_Overflowed_File_Size_From_Soulseek_NS(long given, long expected)
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Peer.BrowseResponse)
.WriteInteger(1) // directory count
.WriteString("dir") // first directory name
.WriteInteger(1) // first directory file count
.WriteByte(0x0) // file code
.WriteString("foo") // name
.WriteLong(given) // size
.WriteString("bar") // extension
.WriteInteger(0) // attribute count
.Compress()
.Build();
BrowseResponse r = default;
var ex = Record.Exception(() => r = BrowseResponseFactory.FromByteArray(msg));
Assert.Null(ex);
var d = r.Directories.ToList();
var f = d[0].Files.ToList();
Assert.Equal(expected, f[0].Size);
}
public void Parse_Handles_A_Complete_Response()
{
var dirs = new List <Directory>();
for (int i = 0; i < 5; i++)
{
dirs.Add(GetRandomDirectory(i));
}
var builder = new MessageBuilder()
.Code(MessageCode.PeerBrowseResponse)
.WriteInteger(dirs.Count);
foreach (var dir in dirs)
{
BuildDirectory(builder, dir);
}
var msg = builder
.Compress()
.Build();
BrowseResponse r = default(BrowseResponse);
var ex = Record.Exception(() => r = BrowseResponse.Parse(msg));
Assert.Null(ex);
Assert.Equal(dirs.Count, r.DirectoryCount);
Assert.Equal(dirs.Count, r.Directories.Count);
var msgDirs = r.Directories.ToList();
for (int i = 0; i < msgDirs.Count; i++)
{
Assert.Equal(dirs[i].Directoryname, msgDirs[i].Directoryname);
Assert.Equal(dirs[i].FileCount, msgDirs[i].FileCount);
var files = dirs[i].Files.ToList();
var msgFiles = msgDirs[i].Files.ToList();
for (int j = 0; j < msgDirs[i].FileCount; j++)
{
Assert.Equal(files[j].Code, msgFiles[j].Code);
Assert.Equal(files[j].Filename, msgFiles[j].Filename);
Assert.Equal(files[j].Size, msgFiles[j].Size);
Assert.Equal(files[j].Extension, msgFiles[j].Extension);
Assert.Equal(files[j].AttributeCount, msgFiles[j].AttributeCount);
var attr = files[j].Attributes.ToList();
var msgAttr = files[j].Attributes.ToList();
for (int k = 0; k < msgFiles[j].AttributeCount; k++)
{
Assert.Equal(attr[k].Type, msgAttr[k].Type);
Assert.Equal(attr[k].Value, msgAttr[k].Value);
}
}
}
}
public void Instantiates_With_Given_Data()
{
var num = new Random().Next();
var a = new BrowseResponse(num);
Assert.Equal(num, a.DirectoryCount);
Assert.Empty(a.Directories);
}
public void BrowseAsyncNull()
{
var response = new BrowseResponse();
var channel = new TestRequestChannel(response);
channel.Invoking(c => c.BrowseAsync(null))
.Should().Throw <ArgumentNullException>();
}
public void Instantiates_With_No_Data()
{
var a = new BrowseResponse();
Assert.Empty(a.Directories);
Assert.Equal(0, a.DirectoryCount);
Assert.Empty(a.LockedDirectories);
Assert.Equal(0, a.LockedDirectoryCount);
}
public void ToByteArray_Returns_Expected_Data_When_Only_Locked_Files_Given()
{
var list = new List <File>()
{
new File(1, "1", 1, ".1", 1, new List <FileAttribute>()
{
new FileAttribute(FileAttributeType.BitDepth, 1)
}),
new File(2, "2", 2, ".2", 1, new List <FileAttribute>()
{
new FileAttribute(FileAttributeType.BitRate, 2)
}),
};
var dirs = new List <Directory>()
{
new Directory("dir1", 2, list),
};
var r = new BrowseResponse(lockedDirectoryList: dirs);
var bytes = r.ToByteArray();
var m = new MessageReader <MessageCode.Peer>(bytes);
m.Decompress();
Assert.Equal(MessageCode.Peer.BrowseResponse, m.ReadCode());
Assert.Equal(0, m.ReadInteger());
Assert.Equal(0, m.ReadInteger()); // unknown
Assert.Equal(1, m.ReadInteger()); // locked directory count
// dir 1
Assert.Equal("dir1", m.ReadString());
Assert.Equal(2, m.ReadInteger());
// file 1
Assert.Equal(1, m.ReadByte()); // code
Assert.Equal("1", m.ReadString()); // name
Assert.Equal(1, m.ReadLong()); // length
Assert.Equal(".1", m.ReadString()); // ext
Assert.Equal(1, m.ReadInteger()); // attribute count
Assert.Equal(FileAttributeType.BitDepth, (FileAttributeType)m.ReadInteger());
Assert.Equal(1, m.ReadInteger());
// file 2
Assert.Equal(2, m.ReadByte()); // code
Assert.Equal("2", m.ReadString()); // name
Assert.Equal(2, m.ReadLong()); // length
Assert.Equal(".2", m.ReadString()); // ext
Assert.Equal(1, m.ReadInteger()); // attribute count
Assert.Equal(FileAttributeType.BitRate, (FileAttributeType)m.ReadInteger());
Assert.Equal(2, m.ReadInteger());
}
public static SearchResult FromBrowseResponse(BrowseResponse result, SearchResultType filter)
{
SearchResult ret = new SearchResult();
if (result.Contents == null)
{
// no response
return(ret);
}
SectionListRenderer renderer = result.Contents.SectionListRenderer;
if (renderer == null)
{
int indexToUse = filter == SearchResultType.Upload ? 1 : 0;
if (result.Contents.TabbedSearchResultsRenderer != null)
{
renderer = result.Contents.TabbedSearchResultsRenderer.Tabs[indexToUse].TabRenderer.Content.SectionListRenderer;
}
else if (result.Contents.SingleColumnBrowseResultsRenderer != null)
{
renderer = result.Contents.SingleColumnBrowseResultsRenderer.Tabs[indexToUse].TabRenderer.Content.SectionListRenderer;
}
if (renderer == null)
{
// TODO: error ? throw ?
return(ret);
}
}
List <Content> results = renderer.Contents;
//if (results.Count == 1)
//{
// // no results?
// return ret;
//}
foreach (var res in results)
{
if (res.MusicShelfRenderer == null)
{
continue;
}
var innerResults = res.MusicShelfRenderer.Contents;
foreach (var innerContent in innerResults)
{
ParseInnerContent(ret, innerContent, filter);
}
}
return(ret);
}
public void Instantiates_With_The_Given_Locked_Directory_List()
{
var dir = new Directory("foo", 1);
var list = new List <Directory>(new[] { dir });
var a = new BrowseResponse(lockedDirectoryList: list);
Assert.Equal(list.Count, a.LockedDirectoryCount);
Assert.Single(a.LockedDirectories);
Assert.Equal(dir, a.LockedDirectories.ToList()[0]);
}
public void Parse_Throws_MessageException_On_Code_Mismatch()
{
var msg = new MessageBuilder()
.Code(MessageCode.PeerTransferResponse)
.Build();
var ex = Record.Exception(() => BrowseResponse.Parse(msg));
Assert.NotNull(ex);
Assert.IsType <MessageException>(ex);
}
public void Completes_BrowseResponseConnection_Wait_On_Browse_Response_Receipt(string username, IPEndPoint endpoint)
{
var(handler, mocks) = GetFixture(username, endpoint);
var request = new BrowseResponse(Enumerable.Empty <Directory>());
var message = request.ToByteArray();
var args = new MessageReceivedEventArgs(message.Length, message.Skip(4).Take(4).ToArray());
handler.HandleMessageReceived(mocks.PeerConnection.Object, args);
mocks.Waiter.Verify(m => m.Complete(new WaitKey(Constants.WaitKey.BrowseResponseConnection, username), It.IsAny <(MessageReceivedEventArgs, IMessageConnection)>()), Times.Once);
}
public void Instantiates_With_The_Given_Directory_List()
{
var num = new Random().Next();
var dir = new Directory("foo", 1);
var list = new List <Directory>(new[] { dir });
var a = new BrowseResponse(num, list);
Assert.Equal(num, a.DirectoryCount);
Assert.Single(a.Directories);
Assert.Equal(dir, a.Directories.ToList()[0]);
}
public void Parse_Throws_MessageCompressionException_On_Uncompressed_Payload()
{
var msg = new MessageBuilder()
.Code(MessageCode.PeerBrowseResponse)
.WriteBytes(new byte[] { 0x0, 0x1, 0x2, 0x3 })
.Build();
var ex = Record.Exception(() => BrowseResponse.Parse(msg));
Assert.NotNull(ex);
Assert.IsType <MessageCompressionException>(ex);
Assert.IsType <ZStreamException>(ex.InnerException);
}
public async Task BrowseAsync()
{
var response = new BrowseResponse();
var request = new BrowseRequest();
var channel = new TestRequestChannel(response);
var ret = await channel.BrowseAsync(request);
ret
.Should().BeSameAs(response);
channel.Request
.Should().BeSameAs(request);
}
public static User FromBrowseResponse(BrowseResponse response)
{
User user = new User();
user.Name = response.Header.MusicVisualHeaderRenderer.Title.Runs[0].Text;
var contents = response.Contents.SingleColumnBrowseResultsRenderer.Tabs[0].TabRenderer.Content.SectionListRenderer.Contents[0].MusicCarouselShelfRenderer.Contents;
foreach (var content in contents)
{
user.Playlists.Add(Playlist.FromMusicTwoRowItemRenderer(content.MusicTwoRowItemRenderer));
}
return(user);
}
public void Creates_Diagnostic_On_Exception_Handling_BrowseResponse_Receipt(string username, IPEndPoint endpoint)
{
var(handler, mocks) = GetFixture(username, endpoint);
var request = new BrowseResponse(Enumerable.Empty <Directory>());
var message = request.ToByteArray();
var args = new MessageReceivedEventArgs(message.Length, message.Skip(4).Take(4).ToArray());
mocks.Waiter.Setup(m => m.Complete(new WaitKey(Constants.WaitKey.BrowseResponseConnection, username), It.IsAny <(MessageReceivedEventArgs, IMessageConnection)>()))
.Throws(new Exception("foo"));
handler.HandleMessageReceived(mocks.PeerConnection.Object, args);
mocks.Diagnostic.Verify(m => m.Warning(It.Is <string>(s => s.ContainsInsensitive("Error handling peer message")), It.IsAny <Exception>()), Times.Once);
}
public void Parse_Returns_Empty_Response_Given_Empty_Message()
{
var msg = new MessageBuilder()
.Code(MessageCode.PeerBrowseResponse)
.WriteInteger(0)
.Compress()
.Build();
BrowseResponse r = default(BrowseResponse);
var ex = Record.Exception(() => r = BrowseResponse.Parse(msg));
Assert.Null(ex);
Assert.Equal(0, r.DirectoryCount);
Assert.Empty(r.Directories);
}
public void Parse_Throws_MessageReadException_On_Missing_Data()
{
var name = Guid.NewGuid().ToString();
var msg = new MessageBuilder()
.WriteCode(MessageCode.Peer.BrowseResponse)
.WriteInteger(1) // directory count
.WriteString(name) // first directory name
.Compress() // count is missing
.Build();
BrowseResponse r = default;
var ex = Record.Exception(() => r = BrowseResponseFactory.FromByteArray(msg));
Assert.NotNull(ex);
Assert.IsType <MessageReadException>(ex);
}
/// <summary>
/// Search uploaded songs, artists, albums
///
/// The YTM api does not return results with mixes of uploads and non uploaded tracks, so you
/// have to search for uploads specifically
/// </summary>
/// <param name="search"></param>
/// <returns></returns>
public async Task <SearchResult> SearchUploads(string search)
{
string url = GetYTMUrl("search");
JObject data = JObject.FromObject(new
{
query = search
});
string parameters = GetSearchParamStringFromFilter(SearchResultType.Upload);
data.Add("params", parameters);
BrowseResponse response = await Post <BrowseResponse>(url, data, authRequired : true);
return(SearchResult.FromBrowseResponse(response, SearchResultType.Upload));
}
private async Task <IList <ReferenceDescription> > BrowseTree(NodeId tree)
{
if (connection == null)
{
return(new ReferenceDescription[0]);
}
var browseRequest = new BrowseRequest {
NodesToBrowse = new[] {
new BrowseDescription {
NodeId = tree,
ReferenceTypeId = NodeId.Parse(ReferenceTypeIds.HierarchicalReferences),
ResultMask = (uint)BrowseResultMask.TargetInfo,
NodeClassMask = (uint)NodeClass.Object | (int)NodeClass.Variable,
BrowseDirection = BrowseDirection.Forward,
IncludeSubtypes = true
}
},
RequestedMaxReferencesPerNode = 1000
};
var rds = new List <ReferenceDescription>();
BrowseResponse browseResponse = await connection.BrowseAsync(browseRequest);
Workstation.ServiceModel.Ua.BrowseResult[] results = CleanNulls(browseResponse.Results).ToArray();
rds.AddRange(results.SelectMany(result => CleanNulls(result.References)));
var continuationPoints = results.Select(br => br.ContinuationPoint).Where(cp => cp != null).ToArray();
while (continuationPoints.Length > 0 && connection != null)
{
var browseNextRequest = new BrowseNextRequest {
ContinuationPoints = continuationPoints, ReleaseContinuationPoints = false
};
var browseNextResponse = await connection.BrowseNextAsync(browseNextRequest);
Workstation.ServiceModel.Ua.BrowseResult[] nextResults = CleanNulls(browseNextResponse.Results).ToArray();
rds.AddRange(nextResults.SelectMany(result => CleanNulls(result.References)));
continuationPoints = nextResults.Select(br => br.ContinuationPoint).Where(cp => cp != null).ToArray();
}
return(rds);
}
public async Task BrowseAsync_Raises_BrowseProgressUpdated_Event_At_Least_Twice(string username, IPEndPoint endpoint, string localUsername, List <Directory> directories, int length)
{
var response = new BrowseResponse(directories.Count, directories);
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.WaitIndefinitely <BrowseResponse>(It.IsAny <WaitKey>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(response));
waiter.Setup(m => m.Wait <UserAddressResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new UserAddressResponse(username, endpoint.Address, endpoint.Port)));
var conn = new Mock <IMessageConnection>();
conn.Setup(m => m.State)
.Returns(ConnectionState.Connected);
conn.Setup(m => m.WriteAsync(It.IsAny <byte[]>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
var connManager = new Mock <IPeerConnectionManager>();
connManager.Setup(m => m.GetOrAddMessageConnectionAsync(username, endpoint, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(conn.Object));
waiter.Setup(m => m.Wait <(MessageReceivedEventArgs, IMessageConnection)>(It.IsAny <WaitKey>(), It.IsAny <int?>(), It.IsAny <CancellationToken?>()))
.Returns(Task.FromResult((new MessageReceivedEventArgs(length, new byte[] { 0x0 }), conn.Object)));
using (var s = new SoulseekClient("127.0.0.1", 1, waiter: waiter.Object, serverConnection: conn.Object, peerConnectionManager: connManager.Object))
{
s.SetProperty("Username", localUsername);
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var events = new List <BrowseProgressUpdatedEventArgs>();
s.BrowseProgressUpdated += (sender, args) => events.Add(args);
await s.BrowseAsync(username);
Assert.NotEmpty(events);
Assert.Equal(2, events.Count);
Assert.Equal(0, events[0].PercentComplete);
Assert.Equal(100, events[1].PercentComplete);
}
}
public void Parse_Handles_Files_With_No_Attributes()
{
var name = Guid.NewGuid().ToString();
var msg = new MessageBuilder()
.Code(MessageCode.PeerBrowseResponse)
.WriteInteger(1) // directory count
.WriteString(name) // first directory name
.WriteInteger(1) // first directory file count
.WriteByte(0x0) // file code
.WriteString("foo") // name
.WriteLong(12) // size
.WriteString("bar") // extension
.WriteInteger(0) // attribute count
.Compress()
.Build();
BrowseResponse r = default(BrowseResponse);
var ex = Record.Exception(() => r = BrowseResponse.Parse(msg));
Assert.Null(ex);
Assert.Equal(1, r.DirectoryCount);
Assert.Single(r.Directories);
var d = r.Directories.ToList();
Assert.Equal(name, d[0].Directoryname);
Assert.Equal(1, d[0].FileCount);
Assert.Single(d[0].Files);
var f = d[0].Files.ToList();
Assert.Equal(0x0, f[0].Code);
Assert.Equal("foo", f[0].Filename);
Assert.Equal(12, f[0].Size);
Assert.Equal("bar", f[0].Extension);
Assert.Equal(0, f[0].AttributeCount);
Assert.Empty(f[0].Attributes);
}
/// <summary cref="IServiceMessage.CreateResponse" />
public object CreateResponse(IServiceResponse response)
{
BrowseResponse body = response as BrowseResponse;
if (body == null)
{
body = new BrowseResponse();
body.ResponseHeader = ((ServiceFault)response).ResponseHeader;
}
return new BrowseResponseMessage(body);
}
/// <summary>
/// Initializes the message with the body.
/// </summary>
public BrowseResponseMessage(BrowseResponse BrowseResponse)
{
this.BrowseResponse = BrowseResponse;
}
/// <summary>
/// Initializes the message with a service fault.
/// </summary>
public BrowseResponseMessage(ServiceFault ServiceFault)
{
this.BrowseResponse = new BrowseResponse();
if (ServiceFault != null)
{
this.BrowseResponse.ResponseHeader = ServiceFault.ResponseHeader;
}
}
private void ParseBrowseResponse(BrowseResponse resp)
{
foreach (BrowseItem itm in resp.RootItem.Items)
foreach (string ns in itm.Namespaces)
if (ns.Equals(RegisteredJabberNamespaces.MultiUserChat) || ns.Equals(MUCDiscoFeatures.GroupChat))
{
//todo: dig into this item to search for rooms
AddChatServerMenuItem(itm.JabberID);
break;
}
}
/// <summary>
/// Invokes the Browse service.
/// </summary>
public IServiceResponse Browse(IServiceRequest incoming)
{
BrowseResponse response = null;
BrowseRequest request = (BrowseRequest)incoming;
BrowseResultCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
response = new BrowseResponse();
response.ResponseHeader = ServerInstance.Browse(
request.RequestHeader,
request.View,
request.RequestedMaxReferencesPerNode,
request.NodesToBrowse,
out results,
out diagnosticInfos);
response.Results = results;
response.DiagnosticInfos = diagnosticInfos;
return response;
}
