flywithu/CryptoExchange.Net
1
0
Fork 0
mirror of https://github.com/JKorf/CryptoExchange.Net synced 2025-06-11 01:46:12 +00:00
Code Issues Releases Wiki Activity

Initial unit test

Browse Source
This commit is contained in:
Jan Korf 2018-11-28 21:51:39 +01:00
parent 3641293fd6
commit 6a0c7c417b
9 changed files with 595 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
CryptoExchange.Net.UnitTests/BaseClientTests.cs Normal file
View File

@ -0,0 +1,123 @@
using CryptoExchange.Net.Authentication;
using CryptoExchange.Net.Logging;
using CryptoExchange.Net.Objects;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
namespace CryptoExchange.Net.UnitTests
{
[TestFixture()]
public class BaseClientTests
{
[TestCase(null, null)]
[TestCase("", "")]
[TestCase("test", null)]
[TestCase("test", "")]
[TestCase(null, "test")]
[TestCase("", "test")]
public void SettingEmptyValuesForAPICredentials_Should_ThrowException(string key, string secret)
{
// arrange
// act
// assert
Assert.Throws(typeof(ArgumentException), () => new TestBaseClient(new ClientOptions() { ApiCredentials = new ApiCredentials(key, secret) }));
}
[TestCase]
public void SettingLogOutput_Should_RedirectLogOutput()
{
// arrange
var stringBuilder = new StringBuilder();
var client = new TestBaseClient(new ClientOptions()
{
LogWriters = new List<TextWriter> { new StringWriter(stringBuilder) }
});
// act
client.Log(LogVerbosity.Info, "Test");
// assert
Assert.IsFalse(string.IsNullOrEmpty(stringBuilder.ToString()));
}
[TestCase(LogVerbosity.None, LogVerbosity.Error, false)]
[TestCase(LogVerbosity.None, LogVerbosity.Warning, false)]
[TestCase(LogVerbosity.None, LogVerbosity.Info, false)]
[TestCase(LogVerbosity.None, LogVerbosity.Debug, false)]
[TestCase(LogVerbosity.Error, LogVerbosity.Error, true)]
[TestCase(LogVerbosity.Error, LogVerbosity.Warning, false)]
[TestCase(LogVerbosity.Error, LogVerbosity.Info, false)]
[TestCase(LogVerbosity.Error, LogVerbosity.Debug, false)]
[TestCase(LogVerbosity.Warning, LogVerbosity.Error, true)]
[TestCase(LogVerbosity.Warning, LogVerbosity.Warning, true)]
[TestCase(LogVerbosity.Warning, LogVerbosity.Info, false)]
[TestCase(LogVerbosity.Warning, LogVerbosity.Debug, false)]
[TestCase(LogVerbosity.Info, LogVerbosity.Error, true)]
[TestCase(LogVerbosity.Info, LogVerbosity.Warning, true)]
[TestCase(LogVerbosity.Info, LogVerbosity.Info, true)]
[TestCase(LogVerbosity.Info, LogVerbosity.Debug, false)]
[TestCase(LogVerbosity.Debug, LogVerbosity.Error, true)]
[TestCase(LogVerbosity.Debug, LogVerbosity.Warning, true)]
[TestCase(LogVerbosity.Debug, LogVerbosity.Info, true)]
[TestCase(LogVerbosity.Debug, LogVerbosity.Debug, true)]
public void SettingLogVerbosity_Should_RestrictLogging(LogVerbosity verbosity, LogVerbosity testVerbosity, bool expected)
{
// arrange
var stringBuilder = new StringBuilder();
var client = new TestBaseClient(new ClientOptions()
{
LogWriters = new List<TextWriter> { new StringWriter(stringBuilder) },
LogVerbosity = verbosity
});
// act
client.Log(testVerbosity, "Test");
// assert
Assert.AreEqual(!string.IsNullOrEmpty(stringBuilder.ToString()), expected);
}
[TestCase]
public void DeserializingValidJson_Should_GiveSuccessfulResult()
{
// arrange
var client = new TestBaseClient();
// act
var result = client.Deserialize<object>("{\"testProperty\": 123}");
// assert
Assert.IsTrue(result.Success);
}
[TestCase]
public void DeserializingInvalidJson_Should_GiveErrorResult()
{
// arrange
var client = new TestBaseClient();
// act
var result = client.Deserialize<object>("{\"testProperty\": 123");
// assert
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Error != null);
}
[TestCase]
public void FillingPathParameters_Should_ResultInValidUrl()
{
// arrange
var client = new TestBaseClient();
// act
var result = client.FillParameters("http://test.api/{}/path/{}", "1", "test");
// assert
Assert.IsTrue(result == "http://test.api/1/path/test");
}
}
}

336
CryptoExchange.Net.UnitTests/ExchangeClientTests.cs
View File

@ -21,207 +21,207 @@ namespace CryptoExchange.Net.UnitTests
[TestFixture()] [TestFixture()]
public class ExchangeClientTests public class ExchangeClientTests
{ {
[TestCase(null, null)] //[TestCase(null, null)]
[TestCase("", "")] //[TestCase("", "")]
[TestCase("test", null)] //[TestCase("test", null)]
[TestCase("test", "")] //[TestCase("test", "")]
[TestCase(null, "test")] //[TestCase(null, "test")]
[TestCase("", "test")] //[TestCase("", "test")]
public void SettingEmptyValuesForAPICredentials_Should_ThrowException(string key, string secret) //public void SettingEmptyValuesForAPICredentials_Should_ThrowException(string key, string secret)
{ //{
// arrange // // arrange
var client = PrepareClient(""); // var client = PrepareClient("");
// act // // act
// assert // // assert
Assert.Throws(typeof(ArgumentException), () => client.SetApiCredentails(key, secret)); // Assert.Throws(typeof(ArgumentException), () => client.SetApiCredentails(key, secret));
} //}
[TestCase()] //[TestCase()]
public void SettingLogOutput_Should_RedirectLogOutput() //public void SettingLogOutput_Should_RedirectLogOutput()
{ //{
// arrange // // arrange
var stringBuilder = new StringBuilder(); // var stringBuilder = new StringBuilder();
var client = PrepareClient("{}", true, LogVerbosity.Debug, new StringWriter(stringBuilder)); // var client = PrepareClient("{}", true, LogVerbosity.Debug, new StringWriter(stringBuilder));
// act // // act
client.TestCall(); // client.TestCall();
// assert // // assert
Assert.IsFalse(string.IsNullOrEmpty(stringBuilder.ToString())); // Assert.IsFalse(string.IsNullOrEmpty(stringBuilder.ToString()));
} //}
[TestCase()] //[TestCase()]
public void ObjectDeserializationFail_Should_GiveFailedResult() //public void ObjectDeserializationFail_Should_GiveFailedResult()
{ //{
// arrange // // arrange
var errorMessage = "TestErrorMessage"; // var errorMessage = "TestErrorMessage";
var client = PrepareClient(JsonConvert.SerializeObject(errorMessage)); // var client = PrepareClient(JsonConvert.SerializeObject(errorMessage));
// act // // act
var result = client.TestCall(); // var result = client.TestCall();
// assert // // assert
Assert.IsFalse(result.Success); // Assert.IsFalse(result.Success);
Assert.AreNotEqual(0, result.Error.Code); // Assert.AreNotEqual(0, result.Error.Code);
Assert.IsTrue(result.Error.Message.Contains(errorMessage)); // Assert.IsTrue(result.Error.Message.Contains(errorMessage));
} //}
[TestCase()] //[TestCase()]
public void InvalidJson_Should_GiveFailedResult() //public void InvalidJson_Should_GiveFailedResult()
{ //{
// arrange // // arrange
var errorMessage = "TestErrorMessage"; // var errorMessage = "TestErrorMessage";
var client = PrepareClient(JsonConvert.SerializeObject(errorMessage)); // var client = PrepareClient(JsonConvert.SerializeObject(errorMessage));
// act // // act
var result = client.TestCall(); // var result = client.TestCall();
// assert // // assert
Assert.IsFalse(result.Success); // Assert.IsFalse(result.Success);
Assert.AreNotEqual(0, result.Error.Code); // Assert.AreNotEqual(0, result.Error.Code);
Assert.IsTrue(result.Error.Message.Contains(errorMessage)); // Assert.IsTrue(result.Error.Message.Contains(errorMessage));
} //}
[TestCase()] //[TestCase()]
public void WhenUsingRateLimiterTotalRequests_Should_BeDelayed() //public void WhenUsingRateLimiterTotalRequests_Should_BeDelayed()
{ //{
// arrange // // arrange
var client = PrepareClient(JsonConvert.SerializeObject(new TestObject())); // var client = PrepareClient(JsonConvert.SerializeObject(new TestObject()));
client.AddRateLimiter(new RateLimiterTotal(1, TimeSpan.FromSeconds(5))); // client.AddRateLimiter(new RateLimiterTotal(1, TimeSpan.FromSeconds(5)));
// act // // act
var sw = Stopwatch.StartNew(); // var sw = Stopwatch.StartNew();
client.TestCall(); // client.TestCall();
client.TestCall(); // client.TestCall();
client.TestCall(); // client.TestCall();
sw.Stop(); // sw.Stop();
// assert // // assert
Assert.IsTrue(sw.ElapsedMilliseconds > 9000); // Assert.IsTrue(sw.ElapsedMilliseconds > 9000);
} //}
[TestCase()] //[TestCase()]
public void WhenUsingRateLimiterPerEndpointRequests_Should_BeDelayed() //public void WhenUsingRateLimiterPerEndpointRequests_Should_BeDelayed()
{ //{
// arrange // // arrange
var client = PrepareClient(JsonConvert.SerializeObject(new TestObject())); // var client = PrepareClient(JsonConvert.SerializeObject(new TestObject()));
client.AddRateLimiter(new RateLimiterTotal(1, TimeSpan.FromSeconds(5))); // client.AddRateLimiter(new RateLimiterTotal(1, TimeSpan.FromSeconds(5)));
// act // // act
var sw = Stopwatch.StartNew(); // var sw = Stopwatch.StartNew();
client.TestCall(); // client.TestCall();
client.TestCall(); // client.TestCall();
client.TestCall(); // client.TestCall();
sw.Stop(); // sw.Stop();
// assert // // assert
Assert.IsTrue(sw.ElapsedMilliseconds > 9000); // Assert.IsTrue(sw.ElapsedMilliseconds > 9000);
} //}
[TestCase()] //[TestCase()]
public void WhenRemovingRateLimiterRequest_Should_NoLongerBeDelayed() //public void WhenRemovingRateLimiterRequest_Should_NoLongerBeDelayed()
{ //{
// arrange // // arrange
var client = PrepareClient(JsonConvert.SerializeObject(new TestObject())); // var client = PrepareClient(JsonConvert.SerializeObject(new TestObject()));
client.AddRateLimiter(new RateLimiterTotal(1, TimeSpan.FromSeconds(5))); // client.AddRateLimiter(new RateLimiterTotal(1, TimeSpan.FromSeconds(5)));
client.RemoveRateLimiters(); // client.RemoveRateLimiters();
// act // // act
var sw = Stopwatch.StartNew(); // var sw = Stopwatch.StartNew();
client.TestCall(); // client.TestCall();
client.TestCall(); // client.TestCall();
client.TestCall(); // client.TestCall();
sw.Stop(); // sw.Stop();
// assert // // assert
Assert.IsTrue(sw.ElapsedMilliseconds < 5000); // Assert.IsTrue(sw.ElapsedMilliseconds < 5000);
} //}
[TestCase()] //[TestCase()]
public void ReceivingErrorStatusCode_Should_NotSuccess() //public void ReceivingErrorStatusCode_Should_NotSuccess()
{ //{
// arrange // // arrange
var client = PrepareExceptionClient(JsonConvert.SerializeObject(new TestObject()), "InvalidStatusCodeResponse", 203); // var client = PrepareExceptionClient(JsonConvert.SerializeObject(new TestObject()), "InvalidStatusCodeResponse", 203);
// act // // act
var result = client.TestCall(); // var result = client.TestCall();
// assert // // assert
Assert.IsFalse(result.Success); // Assert.IsFalse(result.Success);
Assert.IsNotNull(result.Error); // Assert.IsNotNull(result.Error);
Assert.IsTrue(result.Error.Message.Contains("InvalidStatusCodeResponse")); // Assert.IsTrue(result.Error.Message.Contains("InvalidStatusCodeResponse"));
} //}
private TestImplementation PrepareClient(string responseData, bool withOptions = true, LogVerbosity verbosity = LogVerbosity.Warning, TextWriter tw = null) //private TestRestClient PrepareClient(string responseData, bool withOptions = true, LogVerbosity verbosity = LogVerbosity.Warning, TextWriter tw = null)
{ //{
var expectedBytes = Encoding.UTF8.GetBytes(responseData); // var expectedBytes = Encoding.UTF8.GetBytes(responseData);
var responseStream = new MemoryStream(); // var responseStream = new MemoryStream();
responseStream.Write(expectedBytes, 0, expectedBytes.Length); // responseStream.Write(expectedBytes, 0, expectedBytes.Length);
responseStream.Seek(0, SeekOrigin.Begin); // responseStream.Seek(0, SeekOrigin.Begin);
var response = new Mock<IResponse>(); // var response = new Mock<IResponse>();
response.Setup(c => c.GetResponseStream()).Returns(responseStream); // response.Setup(c => c.GetResponseStream()).Returns(responseStream);
var request = new Mock<IRequest>(); // var request = new Mock<IRequest>();
request.Setup(c => c.Headers).Returns(new WebHeaderCollection()); // request.Setup(c => c.Headers).Returns(new WebHeaderCollection());
request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com")); // request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
request.Setup(c => c.GetResponse()).Returns(Task.FromResult(response.Object)); // request.Setup(c => c.GetResponse()).Returns(Task.FromResult(response.Object));
var factory = new Mock<IRequestFactory>(); // var factory = new Mock<IRequestFactory>();
factory.Setup(c => c.Create(It.IsAny<string>())) // factory.Setup(c => c.Create(It.IsAny<string>()))
.Returns(request.Object); // .Returns(request.Object);
TestImplementation client; // TestRestClient client;
if (withOptions) // if (withOptions)
{ // {
var options = new ClientOptions() // var options = new ClientOptions()
{ // {
ApiCredentials = new ApiCredentials("Test", "Test2"), // ApiCredentials = new ApiCredentials("Test", "Test2"),
LogVerbosity = verbosity // LogVerbosity = verbosity
}; // };
if (tw != null) // if (tw != null)
options.LogWriters = new List<TextWriter>() { tw }; // options.LogWriters = new List<TextWriter>() { tw };
client = new TestImplementation(options); // client = new TestRestClient(options);
} // }
else // else
{ // {
client = new TestImplementation(); // client = new TestRestClient();
} // }
client.RequestFactory = factory.Object; // client.RequestFactory = factory.Object;
return client; // return client;
} //}
private TestImplementation PrepareExceptionClient(string responseData, string exceptionMessage, int statusCode, bool credentials = true) //private TestRestClient PrepareExceptionClient(string responseData, string exceptionMessage, int statusCode, bool credentials = true)
{ //{
var expectedBytes = Encoding.UTF8.GetBytes(responseData); // var expectedBytes = Encoding.UTF8.GetBytes(responseData);
var responseStream = new MemoryStream(); // var responseStream = new MemoryStream();
responseStream.Write(expectedBytes, 0, expectedBytes.Length); // responseStream.Write(expectedBytes, 0, expectedBytes.Length);
responseStream.Seek(0, SeekOrigin.Begin); // responseStream.Seek(0, SeekOrigin.Begin);
var we = new WebException(); // var we = new WebException();
var r = new HttpWebResponse(); // var r = new HttpWebResponse();
var re = new HttpResponseMessage(); // var re = new HttpResponseMessage();
typeof(HttpResponseMessage).GetField("_statusCode", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(re, (HttpStatusCode)statusCode); // typeof(HttpResponseMessage).GetField("_statusCode", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(re, (HttpStatusCode)statusCode);
typeof(HttpWebResponse).GetField("_httpResponseMessage", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(r, re); // typeof(HttpWebResponse).GetField("_httpResponseMessage", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(r, re);
typeof(WebException).GetField("_message", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, exceptionMessage); // typeof(WebException).GetField("_message", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, exceptionMessage);
typeof(WebException).GetField("_response", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, r); // typeof(WebException).GetField("_response", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, r);
var response = new Mock<IResponse>(); // var response = new Mock<IResponse>();
response.Setup(c => c.GetResponseStream()).Throws(we); // response.Setup(c => c.GetResponseStream()).Throws(we);
var request = new Mock<IRequest>(); // var request = new Mock<IRequest>();
request.Setup(c => c.Headers).Returns(new WebHeaderCollection()); // request.Setup(c => c.Headers).Returns(new WebHeaderCollection());
request.Setup(c => c.GetResponse()).Returns(Task.FromResult(response.Object)); // request.Setup(c => c.GetResponse()).Returns(Task.FromResult(response.Object));
var factory = new Mock<IRequestFactory>(); // var factory = new Mock<IRequestFactory>();
factory.Setup(c => c.Create(It.IsAny<string>())) // factory.Setup(c => c.Create(It.IsAny<string>()))
.Returns(request.Object); // .Returns(request.Object);
TestImplementation client = credentials ? new TestImplementation(new ClientOptions() { ApiCredentials = new ApiCredentials("Test", "Test2") }) : new TestImplementation(); // TestRestClient client = credentials ? new TestRestClient(new ClientOptions() { ApiCredentials = new ApiCredentials("Test", "Test2") }) : new TestRestClient();
client.RequestFactory = factory.Object; // client.RequestFactory = factory.Object;
return client; // return client;
} //}
} }
} }

81
CryptoExchange.Net.UnitTests/RestClientTests.cs Normal file
View File

@ -0,0 +1,81 @@
using CryptoExchange.Net.Authentication;
using CryptoExchange.Net.Logging;
using CryptoExchange.Net.Objects;
using CryptoExchange.Net.UnitTests.TestImplementations;
using Newtonsoft.Json;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
namespace CryptoExchange.Net.UnitTests
{
[TestFixture()]
public class RestClientTests
{
[TestCase]
public void RequestingData_Should_ResultInData()
{
// arrange
var client = new TestRestClient();
var expected = new TestObject() { DecimalData = 1.23M, IntData = 10, StringData = "Some data" };
client.SetResponse(JsonConvert.SerializeObject(expected));
// act
var result = client.Request<TestObject>().Result;
// assert
Assert.IsTrue(result.Success);
Assert.IsTrue(TestHelpers.AreEqual(expected, result.Data));
}
[TestCase]
public void ReceivingInvalidData_Should_ResultInError()
{
// arrange
var client = new TestRestClient();
client.SetResponse("{\"property\": 123");
// act
var result = client.Request<TestObject>().Result;
// assert
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Error != null);
}
[TestCase]
public void ReceivingErrorCode_Should_ResultInError()
{
// arrange
var client = new TestRestClient();
client.SetErrorWithoutResponse(System.Net.HttpStatusCode.BadRequest, "Invalid request");
// act
var result = client.Request<TestObject>().Result;
// assert
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Error != null);
}
[TestCase]
public void ReceivingErrorAndParsingError_Should_ResultInParsedError()
{
// arrange
var client = new ParseErrorTestRestClient();
client.SetErrorWithResponse("{\"errorMessage\": \"Invalid request\", \"errorCode\": 123}", System.Net.HttpStatusCode.BadRequest);
// act
var result = client.Request<TestObject>().Result;
// assert
Assert.IsFalse(result.Success);
Assert.IsTrue(result.Error != null);
Assert.IsTrue(result.Error is ServerError);
Assert.IsTrue(result.Error.Code == 123);
Assert.IsTrue(result.Error.Message == "Invalid request");
}
}
}

36
CryptoExchange.Net.UnitTests/TestImplementation.cs → CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs
View File

@ -1,27 +1,33 @@
using System; using System.Collections.Generic;
using System.Collections.Generic;
using CryptoExchange.Net.Authentication; using CryptoExchange.Net.Authentication;
using CryptoExchange.Net.Interfaces; using CryptoExchange.Net.Logging;
using CryptoExchange.Net.Objects; using CryptoExchange.Net.Objects;
namespace CryptoExchange.Net.UnitTests namespace CryptoExchange.Net.UnitTests
{ {
public class TestImplementation: RestClient public class TestBaseClient: BaseClient
{ {
public TestImplementation(): base(new ClientOptions(), null) { } public TestBaseClient(): base(new ClientOptions(), null)
public TestImplementation(ClientOptions exchangeOptions) : base(exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
{ {
} }
public void SetApiCredentails(string key, string secret) public TestBaseClient(ClientOptions exchangeOptions) : base(exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
{ {
SetAuthenticationProvider(new TestAuthProvider(new ApiCredentials(key, secret)));
} }
public CallResult<TestObject> TestCall() public void Log(LogVerbosity verbosity, string data)
{ {
return ExecuteRequest<TestObject>(new Uri("http://www.test.com")).Result; log.Write(verbosity, data);
}
public CallResult<T> Deserialize<T>(string data)
{
return Deserialize<T>(data, false);
}
public string FillParameters(string path, params string[] values)
{
return FillPathParameter(path, values);
} }
} }
@ -46,10 +52,4 @@ namespace CryptoExchange.Net.UnitTests
return toSign; return toSign;
} }
} }
public class TestObject
{
public int Id { get; set; }
public List<string> Data { get; set; }
}
} }

51
CryptoExchange.Net.UnitTests/TestImplementations/TestHelpers.cs Normal file
View File

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Text;
namespace CryptoExchange.Net.UnitTests.TestImplementations
{
public class TestHelpers
{
[ExcludeFromCodeCoverage]
public static bool AreEqual<T>(T self, T to, params string[] ignore) where T : class
{
if (self != null && to != null)
{
var type = self.GetType();
var ignoreList = new List<string>(ignore);
foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (ignoreList.Contains(pi.Name))
{
continue;
}
var selfValue = type.GetProperty(pi.Name).GetValue(self, null);
var toValue = type.GetProperty(pi.Name).GetValue(to, null);
if (pi.PropertyType.IsClass && !pi.PropertyType.Module.ScopeName.Equals("System.Private.CoreLib.dll"))
{
// Check of "CommonLanguageRuntimeLibrary" is needed because string is also a class
if (AreEqual(selfValue, toValue, ignore))
{
continue;
}
return false;
}
if (selfValue != toValue && (selfValue == null || !selfValue.Equals(toValue)))
{
return false;
}
}
return true;
}
return self == to;
}
}
}

15
CryptoExchange.Net.UnitTests/TestImplementations/TestObjects.cs Normal file
View File

@ -0,0 +1,15 @@
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Text;
namespace CryptoExchange.Net.UnitTests.TestImplementations
{
public class TestObject
{
[JsonProperty("other")]
public string StringData { get; set; }
public int IntData { get; set; }
public decimal DecimalData { get; set; }
}
}

115
CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs Normal file
View File

@ -0,0 +1,115 @@
using CryptoExchange.Net.Interfaces;
using CryptoExchange.Net.Objects;
using Moq;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace CryptoExchange.Net.UnitTests.TestImplementations
{
public class TestRestClient: RestClient
{
public TestRestClient() : base(new ClientOptions(), null)
{
RequestFactory = new Mock<IRequestFactory>().Object;
}
public TestRestClient(ClientOptions exchangeOptions) : base(exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
{
}
public void SetResponse(string responseData)
{
var expectedBytes = Encoding.UTF8.GetBytes(responseData);
var responseStream = new MemoryStream();
responseStream.Write(expectedBytes, 0, expectedBytes.Length);
responseStream.Seek(0, SeekOrigin.Begin);
var response = new Mock<IResponse>();
response.Setup(c => c.GetResponseStream()).Returns(responseStream);
var request = new Mock<IRequest>();
request.Setup(c => c.Headers).Returns(new WebHeaderCollection());
request.Setup(c => c.Uri).Returns(new Uri("http://www.test.com"));
request.Setup(c => c.GetResponse()).Returns(Task.FromResult(response.Object));
var factory = Mock.Get(RequestFactory);
factory.Setup(c => c.Create(It.IsAny<string>()))
.Returns(request.Object);
}
public void SetErrorWithoutResponse(HttpStatusCode code, string message)
{
var we = new WebException();
var r = new HttpWebResponse();
var re = new HttpResponseMessage();
typeof(HttpResponseMessage).GetField("_statusCode", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(re, code);
typeof(HttpWebResponse).GetField("_httpResponseMessage", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(r, re);
typeof(WebException).GetField("_message", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, message);
typeof(WebException).GetField("_response", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, r);
var response = new Mock<IResponse>();
response.Setup(c => c.GetResponseStream()).Throws(we);
var request = new Mock<IRequest>();
request.Setup(c => c.Headers).Returns(new WebHeaderCollection());
request.Setup(c => c.GetResponse()).Returns(Task.FromResult(response.Object));
var factory = Mock.Get(RequestFactory);
factory.Setup(c => c.Create(It.IsAny<string>()))
.Returns(request.Object);
}
public void SetErrorWithResponse(string responseData, HttpStatusCode code)
{
var expectedBytes = Encoding.UTF8.GetBytes(responseData);
var responseStream = new MemoryStream();
responseStream.Write(expectedBytes, 0, expectedBytes.Length);
responseStream.Seek(0, SeekOrigin.Begin);
var we = new WebException();
var r = new HttpWebResponse();
var re = new HttpResponseMessage();
typeof(HttpResponseMessage).GetField("_statusCode", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(re, code);
typeof(HttpWebResponse).GetField("_httpResponseMessage", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(r, re);
typeof(WebException).GetField("_message", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, "");
typeof(WebException).GetField("_response", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).SetValue(we, r);
var response = new Mock<IResponse>();
response.Setup(c => c.GetResponseStream()).Returns(responseStream);
var request = new Mock<IRequest>();
request.Setup(c => c.Headers).Returns(new WebHeaderCollection());
request.Setup(c => c.GetResponse()).Returns(Task.FromResult(response.Object));
var factory = Mock.Get(RequestFactory);
factory.Setup(c => c.Create(It.IsAny<string>()))
.Returns(request.Object);
}
public async Task<CallResult<T>> Request<T>() where T:class
{
return await ExecuteRequest<T>(new Uri("http://www.test.com"));
}
}
public class ParseErrorTestRestClient: TestRestClient
{
public ParseErrorTestRestClient() { }
public ParseErrorTestRestClient(ClientOptions exchangeOptions) : base(exchangeOptions) { }
protected override Error ParseErrorResponse(string error)
{
var data = JToken.Parse(error);
return new ServerError((int)data["errorCode"], (string)data["errorMessage"]);
}
}
}

23
CryptoExchange.Net/BaseClient.cs
View File

@ -70,7 +70,28 @@ namespace CryptoExchange.Net
/// <returns></returns> /// <returns></returns>
protected CallResult<T> Deserialize<T>(string data, bool checkObject = true, JsonSerializer serializer = null) protected CallResult<T> Deserialize<T>(string data, bool checkObject = true, JsonSerializer serializer = null)
{ {
return Deserialize<T>(JToken.Parse(data), checkObject, serializer); try
{
return Deserialize<T>(JToken.Parse(data), checkObject, serializer);
}
catch (JsonReaderException jre)
{
var info = $"Deserialize JsonReaderException: {jre.Message}, Path: {jre.Path}, LineNumber: {jre.LineNumber}, LinePosition: {jre.LinePosition}. Data: {data}";
log.Write(LogVerbosity.Error, info);
return new CallResult<T>(default(T), new DeserializeError(info));
}
catch (JsonSerializationException jse)
{
var info = $"Deserialize JsonSerializationException: {jse.Message}. Data: {data}";
log.Write(LogVerbosity.Error, info);
return new CallResult<T>(default(T), new DeserializeError(info));
}
catch (Exception ex)
{
var info = $"Deserialize Unknown Exception: {ex.Message}. Data: {data}";
log.Write(LogVerbosity.Error, info);
return new CallResult<T>(default(T), new DeserializeError(info));
}
} }
/// <summary> /// <summary>

7
CryptoExchange.Net/Logging/Log.cs
View File

@ -17,11 +17,8 @@ namespace CryptoExchange.Net.Logging
get => level; get => level;
set set
{ {
if (level != value) if (level != value)
{ level = value;
Write(LogVerbosity.Info, "Loglevel set to " + value);
level = value;
}
} }
} }