Disposable changes, fixed tests

CryptoExchange.Net.UnitTests/BaseClientTests.cs

@@ -22,7 +22,8 @@ namespace CryptoExchange.Net.UnitTests
             // arrange
             // act
             // assert
-            Assert.Throws(typeof(ArgumentException), () => new TestBaseClient(new RestClientOptions() { ApiCredentials = new ApiCredentials(key, secret) }));
+            Assert.Throws(typeof(ArgumentException),
+                () => new RestSubClientOptions() { ApiCredentials = new ApiCredentials(key, secret) });
         }
 
         [TestCase]
@@ -112,19 +113,6 @@ namespace CryptoExchange.Net.UnitTests
             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");
-        }
-
         [TestCase("https://api.test.com/api", new[] { "path1", "path2" }, "https://api.test.com/api/path1/path2")]
         [TestCase("https://api.test.com/api", new[] { "path1", "/path2" }, "https://api.test.com/api/path1/path2")]
         [TestCase("https://api.test.com/api", new[] { "path1/", "path2" }, "https://api.test.com/api/path1/path2")]

CryptoExchange.Net.UnitTests/ConverterTests.cs

@@ -46,6 +46,64 @@ namespace CryptoExchange.Net.UnitTests
             Assert.AreEqual(output.Time, expectNull ? null : new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
         }
 
+        [TestCase(1620777600)]
+        [TestCase(1620777600.000)]
+        public void TestDateTimeConverterFromSeconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromSeconds(input);
+            Assert.AreEqual(output, new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToSeconds()
+        {
+            var output = DateTimeConverter.ConvertToSeconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.AreEqual(output, 1620777600);
+        }
+
+        [TestCase(1620777600000)]
+        [TestCase(1620777600000.000)]
+        public void TestDateTimeConverterFromMilliseconds(double input)
+        {
+            var output = DateTimeConverter.ConvertFromMilliseconds(input);
+            Assert.AreEqual(output, new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMilliseconds()
+        {
+            var output = DateTimeConverter.ConvertToMilliseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.AreEqual(output, 1620777600000);
+        }
+
+        [TestCase(1620777600000000)]
+        public void TestDateTimeConverterFromMicroseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromMicroseconds(input);
+            Assert.AreEqual(output, new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToMicroseconds()
+        {
+            var output = DateTimeConverter.ConvertToMicroseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.AreEqual(output, 1620777600000000);
+        }
+
+        [TestCase(1620777600000000000)]
+        public void TestDateTimeConverterFromNanoseconds(long input)
+        {
+            var output = DateTimeConverter.ConvertFromNanoseconds(input);
+            Assert.AreEqual(output, new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+        }
+
+        [Test]
+        public void TestDateTimeConverterToNanoseconds()
+        {
+            var output = DateTimeConverter.ConvertToNanoseconds(new DateTime(2021, 05, 12, 0, 0, 0, DateTimeKind.Utc));
+            Assert.AreEqual(output, 1620777600000000000);
+        }
+
         [TestCase()]
         public void TestDateTimeConverterNull()
         {
@@ -53,8 +111,6 @@ namespace CryptoExchange.Net.UnitTests
             Assert.AreEqual(output.Time, null);
         }
 
-        // TODO add tests for ToMilliseconds static methods
-
         [TestCase(TestEnum.One, "1")]
         [TestCase(TestEnum.Two, "2")]
         [TestCase(TestEnum.Three, "three")]

CryptoExchange.Net.UnitTests/RestClientTests.cs

@@ -106,19 +106,22 @@ namespace CryptoExchange.Net.UnitTests
         {
             // arrange
             // act
-            var client = new TestRestClient(new RestClientOptions()
+            var client = new TestRestClient(new TestRestClientOptions()
             {
-                BaseAddress = "http://test.address.com",
+                SubOptions = new RestSubClientOptions
-                RateLimiters = new List<IRateLimiter>{new RateLimiter()},
+                {
-                RateLimitingBehaviour = RateLimitingBehaviour.Fail,
+                    BaseAddress = "http://test.address.com",
+                    RateLimiters = new List<IRateLimiter> { new RateLimiter() },
+                    RateLimitingBehaviour = RateLimitingBehaviour.Fail
+                },
                 RequestTimeout = TimeSpan.FromMinutes(1)
             });
 
 
             // assert
-            Assert.IsTrue(client.ClientOptions.BaseAddress == "http://test.address.com");
+            Assert.IsTrue(((TestRestClientOptions)client.ClientOptions).SubOptions.BaseAddress == "http://test.address.com");
-            Assert.IsTrue(client.ClientOptions.RateLimiters.Count == 1);
+            Assert.IsTrue(((TestRestClientOptions)client.ClientOptions).SubOptions.RateLimiters.Count == 1);
-            Assert.IsTrue(client.ClientOptions.RateLimitingBehaviour == RateLimitingBehaviour.Fail);
+            Assert.IsTrue(((TestRestClientOptions)client.ClientOptions).SubOptions.RateLimitingBehaviour == RateLimitingBehaviour.Fail);
             Assert.IsTrue(client.ClientOptions.RequestTimeout == TimeSpan.FromMinutes(1));
         }
 
@@ -133,9 +136,12 @@ namespace CryptoExchange.Net.UnitTests
         {
             // arrange
             // act
-            var client = new TestRestClient(new RestClientOptions()
+            var client = new TestRestClient(new TestRestClientOptions()
             {
-                BaseAddress = "http://test.address.com",
+                SubOptions = new RestSubClientOptions
+                {
+                    BaseAddress = "http://test.address.com"
+                }
             });
 
             client.SetParameterPosition(new HttpMethod(method), pos);

CryptoExchange.Net.UnitTests/SocketClientTests.cs

@@ -17,15 +17,18 @@ namespace CryptoExchange.Net.UnitTests
         {
             //arrange
             //act
-            var client = new TestSocketClient(new SocketClientOptions()
+            var client = new TestSocketClient(new TestOptions()
             {
-                BaseAddress = "http://test.address.com",
+                SubOptions = new SubClientOptions
+                {
+                    BaseAddress = "http://test.address.com"
+                },
                 ReconnectInterval = TimeSpan.FromSeconds(6)
             });
 
 
             //assert
-            Assert.IsTrue(client.ClientOptions.BaseAddress == "http://test.address.com");
+            Assert.IsTrue(client.SubClient.Options.BaseAddress == "http://test.address.com");
             Assert.IsTrue(client.ClientOptions.ReconnectInterval.TotalSeconds == 6);
         }
 
@@ -39,7 +42,7 @@ namespace CryptoExchange.Net.UnitTests
             socket.CanConnect = canConnect;
 
             //act
-            var connectResult = client.ConnectSocketSub(new SocketConnection(client, socket));
+            var connectResult = client.ConnectSocketSub(new SocketConnection(client, null, socket));
 
             //assert
             Assert.IsTrue(connectResult.Success == canConnect);
@@ -49,12 +52,12 @@ namespace CryptoExchange.Net.UnitTests
         public void SocketMessages_Should_BeProcessedInDataHandlers()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket = client.CreateSocket();
             socket.ShouldReconnect = true;
             socket.CanConnect = true;
             socket.DisconnectTime = DateTime.UtcNow;
-            var sub = new SocketConnection(client, socket);
+            var sub = new SocketConnection(client, null, socket);
             var rstEvent = new ManualResetEvent(false);
             JToken result = null;
             sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, (messageEvent) =>
@@ -77,12 +80,12 @@ namespace CryptoExchange.Net.UnitTests
         public void SocketMessages_Should_ContainOriginalDataIfEnabled(bool enabled)
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug, OutputOriginalData = enabled });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug, OutputOriginalData = enabled });
             var socket = client.CreateSocket();
             socket.ShouldReconnect = true;
             socket.CanConnect = true;
             socket.DisconnectTime = DateTime.UtcNow;
-            var sub = new SocketConnection(client, socket);
+            var sub = new SocketConnection(client, null, socket);
             var rstEvent = new ManualResetEvent(false);
             string original = null;
             sub.AddSubscription(SocketSubscription.CreateForIdentifier(10, "TestHandler", true, (messageEvent) =>
@@ -105,12 +108,12 @@ namespace CryptoExchange.Net.UnitTests
         {
             // arrange
             bool reconnected = false;
-            var client = new TestSocketClient(new SocketClientOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket = client.CreateSocket();
             socket.ShouldReconnect = true;
             socket.CanConnect = true;
             socket.DisconnectTime = DateTime.UtcNow;
-            var sub = new SocketConnection(client, socket);
+            var sub = new SocketConnection(client, null, socket);
             sub.ShouldReconnect = true;
             client.ConnectSocketSub(sub);
             var rstEvent = new ManualResetEvent(false);
@@ -132,10 +135,10 @@ namespace CryptoExchange.Net.UnitTests
         public void UnsubscribingStream_Should_CloseTheSocket()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket = client.CreateSocket();
             socket.CanConnect = true;
-            var sub = new SocketConnection(client, socket);
+            var sub = new SocketConnection(client, null, socket);
             client.ConnectSocketSub(sub);
             var ups = new UpdateSubscription(sub, SocketSubscription.CreateForIdentifier(10, "Test", true, (e) => {}));
 
@@ -150,13 +153,13 @@ namespace CryptoExchange.Net.UnitTests
         public void UnsubscribingAll_Should_CloseAllSockets()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket1 = client.CreateSocket();
             var socket2 = client.CreateSocket();
             socket1.CanConnect = true;
             socket2.CanConnect = true;
-            var sub1 = new SocketConnection(client, socket1);
+            var sub1 = new SocketConnection(client, null, socket1);
-            var sub2 = new SocketConnection(client, socket2);
+            var sub2 = new SocketConnection(client, null, socket2);
             client.ConnectSocketSub(sub1);
             client.ConnectSocketSub(sub2);
 
@@ -172,10 +175,10 @@ namespace CryptoExchange.Net.UnitTests
         public void FailingToConnectSocket_Should_ReturnError()
         {
             // arrange
-            var client = new TestSocketClient(new SocketClientOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
+            var client = new TestSocketClient(new TestOptions() { ReconnectInterval = TimeSpan.Zero, LogLevel = LogLevel.Debug });
             var socket = client.CreateSocket();
             socket.CanConnect = false;
-            var sub = new SocketConnection(client, socket);
+            var sub = new SocketConnection(client, null, socket);
 
             // act
             var connectResult = client.ConnectSocketSub(sub);

CryptoExchange.Net.UnitTests/TestImplementations/TestBaseClient.cs

@@ -8,11 +8,11 @@ namespace CryptoExchange.Net.UnitTests
 {
     public class TestBaseClient: BaseClient
     {       
-        public TestBaseClient(): base("Test", new RestClientOptions(), null)
+        public TestBaseClient(): base("Test", new RestClientOptions())
         {
         }
 
-        public TestBaseClient(RestClientOptions exchangeOptions) : base("Test", exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
+        public TestBaseClient(RestClientOptions exchangeOptions) : base("Test", exchangeOptions)
         {
         }
 
@@ -25,11 +25,6 @@ namespace CryptoExchange.Net.UnitTests
         {
             return Deserialize<T>(data, null, null);
         }
-
-        public string FillParameters(string path, params string[] values)
-        {
-            return FillPathParameter(path, values);
-        }
     }
 
     public class TestAuthProvider : AuthenticationProvider

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -17,13 +17,15 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
     public class TestRestClient: RestClient
     {
-        public TestRestClient() : base("Test", new RestClientOptions(), null)
+        public TestRestSubClient SubClient { get; }
+
+        public TestRestClient() : this(new TestRestClientOptions())
         {
-            RequestFactory = new Mock<IRequestFactory>().Object;
         }
 
-        public TestRestClient(RestClientOptions exchangeOptions) : base("Test", exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
+        public TestRestClient(TestRestClientOptions exchangeOptions) : base("Test", exchangeOptions)
         {
+            SubClient = new TestRestSubClient(exchangeOptions);
             RequestFactory = new Mock<IRequestFactory>().Object;
         }
 
@@ -32,11 +34,6 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             ParameterPositions[method] = position;
         }
 
-        public void SetKey(string key, string secret)
-        {
-            SetAuthenticationProvider(new UnitTests.TestAuthProvider(new ApiCredentials(key, secret)));
-        }
-
         public void SetResponse(string responseData, out IRequest requestObj)
         {
             var expectedBytes = Encoding.UTF8.GetBytes(responseData);
@@ -106,15 +103,28 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 
         public async Task<CallResult<T>> Request<T>(CancellationToken ct = default) where T:class
         {
-            return await SendRequestAsync<T>(new Uri("http://www.test.com"), HttpMethod.Get, ct);
+            return await SendRequestAsync<T>(SubClient, new Uri("http://www.test.com"), HttpMethod.Get, ct);
         }
 
         public async Task<CallResult<T>> RequestWithParams<T>(HttpMethod method, Dictionary<string, object> parameters, Dictionary<string, string> headers) where T : class
         {
-            return await SendRequestAsync<T>(new Uri("http://www.test.com"), method, default, parameters, additionalHeaders: headers);
+            return await SendRequestAsync<T>(SubClient, new Uri("http://www.test.com"), method, default, parameters, additionalHeaders: headers);
         }
     }
 
+    public class TestRestSubClient: RestSubClient
+    {
+        public TestRestSubClient(TestRestClientOptions options): base(options.SubOptions, null)
+        {
+
+        }
+    }
+
+    public class TestRestClientOptions: RestClientOptions
+    {
+        public RestSubClientOptions SubOptions { get; set; } = new RestSubClientOptions();
+    }
+
     public class TestAuthProvider : AuthenticationProvider
     {
         public TestAuthProvider(ApiCredentials credentials) : base(credentials)
@@ -125,7 +135,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
     public class ParseErrorTestRestClient: TestRestClient
     {
         public ParseErrorTestRestClient() { }
-        public ParseErrorTestRestClient(RestClientOptions exchangeOptions) : base(exchangeOptions) { }
+        public ParseErrorTestRestClient(TestRestClientOptions exchangeOptions) : base(exchangeOptions) { }
 
         protected override Error ParseErrorResponse(JToken error)
         {

CryptoExchange.Net.UnitTests/TestImplementations/TestSocketClient.cs

@@ -11,12 +11,15 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
 {
     public class TestSocketClient: SocketClient
     {
-        public TestSocketClient() : this(new SocketClientOptions())
+        public TestSubSocketClient SubClient { get; }
+
+        public TestSocketClient() : this(new TestOptions())
         {
         }
 
-        public TestSocketClient(SocketClientOptions exchangeOptions) : base("test", exchangeOptions, exchangeOptions.ApiCredentials == null ? null : new TestAuthProvider(exchangeOptions.ApiCredentials))
+        public TestSocketClient(TestOptions exchangeOptions) : base("test", exchangeOptions)
         {
+            SubClient = new TestSubSocketClient(exchangeOptions.SubOptions);
             SocketFactory = new Mock<IWebsocketFactory>().Object;
             Mock.Get(SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<Log>(), It.IsAny<string>())).Returns(new TestSocket());
         }
@@ -24,7 +27,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
         public TestSocket CreateSocket()
         {
             Mock.Get(SocketFactory).Setup(f => f.CreateWebsocket(It.IsAny<Log>(), It.IsAny<string>())).Returns(new TestSocket());
-            return (TestSocket)CreateSocket(ClientOptions.BaseAddress);
+            return (TestSocket)CreateSocket("123");
         }
 
         public CallResult<bool> ConnectSocketSub(SocketConnection sub)
@@ -63,4 +66,18 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             throw new NotImplementedException();
         }
     }
+
+    public class TestOptions: SocketClientOptions
+    {
+        public SubClientOptions SubOptions { get; set; } = new SubClientOptions();
+    }
+
+    public class TestSubSocketClient : SocketSubClient
+    {
+
+        public TestSubSocketClient(SubClientOptions options): base(options, options.ApiCredentials == null ? null: new TestAuthProvider(options.ApiCredentials))
+        {
+
+        }
+    }
 }

CryptoExchange.Net/BaseClient.cs

@@ -262,8 +262,6 @@ namespace CryptoExchange.Net
         /// </summary>
         public virtual void Dispose()
         {
-            // TODO
-            //authProvider?.Credentials?.Dispose();
             log.Write(LogLevel.Debug, "Disposing exchange client");
         }
     }

CryptoExchange.Net/Objects/Options.cs

@@ -190,11 +190,6 @@ namespace CryptoExchange.Net.Objects
         }
     }
 
-    public class SocketSubClientOptions: SubClientOptions
-    {
-        // TODO do we need this?
-    }
-
     /// <summary>
     /// Base for socket client options
     /// </summary>

CryptoExchange.Net/RestClient.cs

@@ -365,5 +365,11 @@ namespace CryptoExchange.Net
         {
             return new ServerError(error.ToString());
         }
+
+        /// <inheritdoc />
+        public override void Dispose()
+        {
+            base.Dispose();
+        }
     }
 }

CryptoExchange.Net/SocketSubClient.cs

@@ -23,9 +23,9 @@ namespace CryptoExchange.Net
     /// </summary>
     public abstract class SocketSubClient : SubClient
     {
-        internal SocketSubClientOptions Options { get; }
+        internal SubClientOptions Options { get; }
 
-        public SocketSubClient(SocketSubClientOptions options, AuthenticationProvider? authProvider): base(options,authProvider)
+        public SocketSubClient(SubClientOptions options, AuthenticationProvider? authProvider): base(options,authProvider)
         {
             Options = options;
         }

CryptoExchange.Net/SubClient.cs

@@ -21,7 +21,7 @@ namespace CryptoExchange.Net
     /// <summary>
     /// Base rest client
     /// </summary>
-    public abstract class SubClient
+    public abstract class SubClient: IDisposable
     {
         public AuthenticationProvider? AuthenticationProvider { get; }
         protected string BaseAddress { get; }
@@ -32,5 +32,12 @@ namespace CryptoExchange.Net
             BaseAddress = options.BaseAddress;
         }
 
+        /// <summary>
+        /// Dispose
+        /// </summary>
+        public void Dispose()
+        {
+            AuthenticationProvider?.Credentials?.Dispose();
+        }
     }
 }