public void CanParseEmptyDictionary(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(0);
}
public void InvalidFirstChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow <InvalidBencodeException <BDictionary> >();
}
/// <summary>
/// Parses a bencoded file into an <see cref="IBObject"/> of type <typeparamref name="T"/>.
/// </summary>
/// <param name="parser"></param>
/// <param name="filePath">The path to the file to parse.</param>
/// <returns>The parsed object.</returns>
public static T Parse <T>(this IBencodeParser parser, string filePath) where T : class, IBObject
{
using (var stream = File.OpenRead(filePath))
{
return(parser.Parse <T>(stream));
}
}
public void InvalidFirstChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Unexpected character*");
}
public void InvalidFirstChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow<InvalidBencodeException<BDictionary>>();
}
public void CanParseEmptyDictionary(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(0);
}
/// <summary>
/// Parses a stream into an <see cref="IBObject"/>.
/// </summary>
/// <param name="parser"></param>
/// <param name="stream">The stream to parse.</param>
/// <returns>The parsed object.</returns>
public static IBObject Parse(this IBencodeParser parser, Stream stream)
{
using (var reader = new BencodeReader(stream, leaveOpen: true))
{
return(parser.Parse(reader));
}
}
/// <summary>
/// Parses a bencoded array of bytes into an <see cref="IBObject"/> of type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBObject"/> to parse as.</typeparam>
/// <param name="parser"></param>
/// <param name="bytes">The bencoded bytes to parse.</param>
/// <returns>The parsed object.</returns>
public static T Parse <T>(this IBencodeParser parser, byte[] bytes) where T : class, IBObject
{
using (var stream = new MemoryStream(bytes))
{
return(parser.Parse <T>(stream));
}
}
/// <summary>
/// Parses a bencoded file into an <see cref="IBObject"/>.
/// </summary>
/// <param name="parser"></param>
/// <param name="filePath">The path to the file to parse.</param>
/// <returns>The parsed object.</returns>
public static IBObject Parse(this IBencodeParser parser, string filePath)
{
using (var stream = File.OpenRead(filePath))
{
return(parser.Parse(stream));
}
}
/// <summary>
/// Parses a bencoded string into an <see cref="IBObject"/> of type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBObject"/> to parse as.</typeparam>
/// <param name="parser"></param>
/// <param name="bencodedString">The bencoded string to parse.</param>
/// <returns>The parsed object.</returns>
public static T ParseString <T>(this IBencodeParser parser, string bencodedString) where T : class, IBObject
{
using (var stream = bencodedString.AsStream(parser.Encoding))
{
return(parser.Parse <T>(stream));
}
}
/// <summary>
/// Parses a bencoded array of bytes into an <see cref="IBObject"/>.
/// </summary>
/// <param name="parser"></param>
/// <param name="bytes">The bencoded bytes to parse.</param>
/// <returns>The parsed object.</returns>
public static IBObject Parse(this IBencodeParser parser, byte[] bytes)
{
using (var stream = new MemoryStream(bytes))
{
return(parser.Parse(stream));
}
}
/// <summary>
/// Parses a bencoded string into an <see cref="IBObject"/>.
/// </summary>
/// <param name="parser"></param>
/// <param name="bencodedString">The bencoded string to parse.</param>
/// <returns>The parsed object.</returns>
public static IBObject ParseString(this IBencodeParser parser, string bencodedString)
{
using (var stream = bencodedString.AsStream(parser.Encoding))
{
return(parser.Parse(stream));
}
}
/// <summary>
/// Parses a stream into an <see cref="IBObject"/> of type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type of <see cref="IBObject"/> to parse as.</typeparam>
/// <param name="parser"></param>
/// <param name="stream">The stream to parse.</param>
/// <returns>The parsed object.</returns>
public static T Parse <T>(this IBencodeParser parser, Stream stream) where T : class, IBObject
{
using (var reader = new BencodeReader(stream, leaveOpen: true))
{
return(parser.Parse <T>(reader));
}
}
public async Task CanParseEmptyDictionaryAsync(string bencode, IBencodeParser bparser)
{
var parser = new BDictionaryParser(bparser);
var bdictionary = await parser.ParseStringAsync(bencode);
bdictionary.Count.Should().Be(0);
}
public async Task CanParseEmptyListAsync(string bencode, IBencodeParser bparser)
{
var parser = new BListParser(bparser);
var blist = await parser.ParseStringAsync(bencode);
blist.Count.Should().Be(0);
await bparser.DidNotReceive().ParseAsync(Arg.Any <PipeBencodeReader>());
}
public void CanParseEmptyList(string bencode, IBencodeParser bparser)
{
var parser = new BListParser(bparser);
var blist = parser.ParseString(bencode);
blist.Count.Should().Be(0);
bparser.DidNotReceive().Parse(Arg.Any <BencodeReader>());
}
public void MissingEndChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
SetupBencodeParser(bparser, bencode, new BString("key"), new BString("value"), hasEndChar: false);
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow <InvalidBencodeException <BDictionary> >();
}
/// <summary>
/// Creates an instance using the specified <see cref="IBencodeParser"/> for parsing
/// the torrent <see cref="BDictionary"/>.
/// </summary>
/// <param name="bencodeParser">The parser used for parsing the torrent <see cref="BDictionary"/>.</param>
public TorrentParser(IBencodeParser bencodeParser)
{
if (bencodeParser == null)
{
throw new ArgumentNullException(nameof(bencodeParser));
}
BencodeParser = bencodeParser;
}
public void MissingEndChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
SetupBencodeParser(bparser, bencode, new BString("key"), new BString("value"), hasEndChar:false);
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString(bencode);
action.ShouldThrow<InvalidBencodeException<BDictionary>>();
}
/// <summary>
/// Creates an instance using the specified <see cref="IBencodeParser"/> for parsing contained objects.
/// </summary>
/// <param name="bencodeParser">The parser used for parsing contained objects.</param>
public BListParser(IBencodeParser bencodeParser)
{
if (bencodeParser == null)
{
throw new ArgumentNullException("bencodeParser");
}
BencodeParser = bencodeParser;
}
public void InvalidKey_ThrowsInvalidBencodeException(IBencodeParser bparser)
{
bparser.Parse <BString>(Arg.Any <BencodeReader>()).Throws <BencodeException>();
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Could not parse dictionary key*");
}
public void InvalidKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser)
{
bparser.ParseAsync <BString>(Arg.Any <PipeBencodeReader>()).Throws <BencodeException>();
var parser = new BDictionaryParser(bparser);
Func <Task> action = async() => await parser.ParseStringAsync("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Could not parse dictionary key*");
}
public void DuplicateKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey, BString someValue)
{
bparser.ParseAsync <BString>(Arg.Any <PipeBencodeReader>()).Returns(someKey, someKey);
bparser.ParseAsync(Arg.Any <PipeBencodeReader>()).Returns(someValue);
var parser = new BDictionaryParser(bparser);
Func <Task> action = async() => await parser.ParseStringAsync("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*The dictionary already contains the key*");
}
public void DuplicateKey_ThrowsInvalidBencodeException(IBencodeParser bparser, BString someKey, BString someValue)
{
bparser.Parse <BString>(Arg.Any <BencodeReader>()).Returns(someKey, someKey);
bparser.Parse(Arg.Any <BencodeReader>()).Returns(someValue);
var parser = new BDictionaryParser(bparser);
Action action = () => parser.ParseString("di42ee");
action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*The dictionary already contains the key*");
}
public BitTorrentDownloader(string peerId, IBencodeParser bencodeParser, IHttpClientHelper httpClientHelper, ITcpSocketHelper tcpSocketHelper,
ITorrentFactory torrentFactory, ITrackerResponseFactory trackerResponseFactory, IPeerEventDataFactory peerEventDataFactory)
{
_peerId = peerId;
_bencodeParser = bencodeParser;
_httpClientHelper = httpClientHelper;
_tcpSocketHelper = tcpSocketHelper;
_torrentFactory = torrentFactory;
_trackerResponseFactory = trackerResponseFactory;
_peerEventDataFactory = peerEventDataFactory;
}
public void CanParseSimple(string bencode, IBencodeParser bparser)
{
var key = new BString("key");
var value = new BString("value");
SetupBencodeParser(bparser, bencode, key, value, hasEndChar:true);
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(1);
bdictionary.Should().ContainKey(key);
bdictionary[key].Should().BeSameAs(value);
}
public void MissingEndChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser, IBObject something)
{
// Arrange
bparser.Parse(Arg.Any <BencodeReader>())
.Returns(something)
.AndSkipsAhead(bencode.Length - 1);
// Act
var parser = new BListParser(bparser);
Action action = () => parser.ParseString(bencode);
// Assert
action.Should().Throw <InvalidBencodeException <BList> >().WithMessage("*Missing end character of object*");
}
public void MissingEndChar_ThrowsInvalidBencodeException(string bencode, IBencodeParser bparser)
{
// Arrange
var bstring = new BString("test");
SetupBencodeParser(bparser, bencode, bstring, hasEndChar: false);
// Act
var parser = new BListParser(bparser);
Action action = () => parser.ParseString(bencode);
// Assert
action.ShouldThrow <InvalidBencodeException <BList> >();
}
public void CanParseSimple(string bencode, IBencodeParser bparser)
{
var key = new BString("key");
var value = new BString("value");
SetupBencodeParser(bparser, bencode, key, value, hasEndChar: true);
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
bdictionary.Count.Should().Be(1);
bdictionary.Should().ContainKey(key);
bdictionary[key].Should().BeSameAs(value);
}
private static void SetupBencodeParser(IBencodeParser bparser, string bencode, BString key, IBObject value, bool hasEndChar)
{
bparser.Parse<BString>(Arg.Any<BencodeStream>())
.Returns(key);
bparser.Parse(Arg.Any<BencodeStream>())
.Returns(value)
.AndDoes(x =>
{
// Set stream position to end of list, skipping all "parsed" content
var stream = x.Arg<BencodeStream>();
stream.Position += Math.Max(1, bencode.Length - 1);
if (hasEndChar) stream.Position--;
});
}
private static void SetupBencodeParser(IBencodeParser bparser, string bencode, IBObject obj, bool hasEndChar)
{
bparser.Parse(Arg.Any <BencodeStream>())
.Returns(obj)
.AndDoes(x =>
{
// Set stream position to end of list, skipping all "parsed" content
var stream = x.Arg <BencodeStream>();
stream.Position += Math.Max(1, bencode.Length - 1);
if (hasEndChar)
{
stream.Position--;
}
});
}
public void CanParseSimple(string bencode, IBencodeParser bparser)
{
// Arrange
var bstring = new BString("test");
SetupBencodeParser(bparser, bencode, bstring, hasEndChar: true);
// Act
var parser = new BListParser(bparser);
var blist = parser.ParseString(bencode);
// Assert
blist.Count.Should().Be(1);
blist[0].Should().BeOfType <BString>();
blist[0].Should().BeSameAs(bstring);
bparser.Received(1).Parse(Arg.Any <BencodeStream>());
}
public Tracker(IHttpClientHelper httpClient, IBencodeParser bencodeParser, ITrackerResponseFactory trackerResponseFactory, string peerId, int port)
{
if (peerId?.Length != Constants.PeerIdLength)
{
throw new ArgumentException($"Peer Id must be {Constants.PeerIdLength} characters");
}
if (port < Constants.MinPortNumber || port > Constants.MaxPortNumber)
{
throw new ArgumentException($"Port must be in range [{Constants.MinPortNumber}, {Constants.MaxPortNumber}]");
}
BencodeParser = bencodeParser;
HttpClient = httpClient;
TrackerResponseFactory = trackerResponseFactory;
PeerId = peerId;
Port = port;
}
public async Task CanParseSimpleAsync(string bencode, IBencodeParser bparser)
{
// Arrange
var bstring = new BString("test");
bparser.ParseAsync(Arg.Any <PipeBencodeReader>())
.Returns(bstring)
.AndSkipsAheadAsync(bencode.Length - 2);
// Act
var parser = new BListParser(bparser);
var blist = await parser.ParseStringAsync(bencode);
// Assert
blist.Count.Should().Be(1);
blist[0].Should().BeOfType <BString>();
blist[0].Should().BeSameAs(bstring);
await bparser.Received(1).ParseAsync(Arg.Any <PipeBencodeReader>());
}
public void CanParseSimple(string bencode, IBencodeParser bparser)
{
// Arange
var key = new BString("key");
var value = new BString("value");
bparser.Parse <BString>(Arg.Any <BencodeReader>())
.Returns(key);
bparser.Parse(Arg.Any <BencodeReader>())
.Returns(value)
.AndSkipsAhead(bencode.Length - 2);
// Act
var parser = new BDictionaryParser(bparser);
var bdictionary = parser.ParseString(bencode);
// Assert
bdictionary.Count.Should().Be(1);
bdictionary.Should().ContainKey(key);
bdictionary[key].Should().BeSameAs(value);
}
