Implement unit tests and new constructors

Author: Cem Yılmaz

CHANGELOG.md

@@ -12,7 +12,12 @@
     string myHostAndPort = "127.0.0.1:27015";
     // or
     string myHostAndPort = "localhost:27015";
+    // or
+    string myHostAndPort = "steam://connect/127.0.0.1:27015";
+    // or
+    string myHostAndPort = "steam://connect/localhost:27015";
     ```
+* Implemented new tests for ip, hostname and port validation.
 
 * Added a CHANGELOG. LUL :)
 

README.md

@@ -16,17 +16,87 @@ SteamQueryNet comes with a single object that gives you access to all API's of t
 
 * Server information (server name, capacity etc).
 * Concurrent players.
-* Server rules (friendlyfire, roundttime etc). **Warning: currently does not work due to a protocol issue on server source server.**
+* Server rules (friendlyfire, roundttime etc). **Warning: currently does not work due to a protocol issue on steam server query API. Use could make use of ServerInfo.tags if the server admins are kind enough to put rules as tags in the field.**
 
 ## Creating an instance
-To make us of the API's listed above, an instance of `ServerQuery` should be created.
+To make use of the API's listed above, an instance of `ServerQuery` should be created.
 
 ```csharp
 string serverIp = "127.0.0.1";
 int serverPort = 27015;
 IServerQuery serverQuery = new ServerQuery(serverIp, serverPort);
 ```
 
+or you can use string resolvers like below:
+
+```csharp
+    string myHostAndPort = "127.0.0.1:27015";
+    // or
+    myHostAndPort = "127.0.0.1,27015";
+    // or
+    myHostAndPort = "localhost:27015";
+    // or
+    myHostAndPort = "localhost,27015";
+    // or
+    myHostAndPort = "steam://connect/127.0.0.1:27015";
+    // or
+    myHostAndPort = "steam://connect/localhost:27015";
+
+    IServerQuery serverQuery = new ServerQuery(myHostAndPort);
+```
+
+Also, it is possible to create `ServerQuery` object without connecting like below:
+
+```csharp
+IServerQuery serverQuery = new ServerQuery();
+serverQuery.Connect(host, port);
+```
+
+*Note*: `Connect` function overloads are similar to `ServerQuery` non-empty constructors.
+
+## Providing Custom UDPClient
+
+You can provide custom UDP clients by implementing `IUdpClient` in `SteamQueryNet.Interfaces` namespace.
+
+See the example below:
+```csharp
+public class MyAmazingUdpClient : IUdpClient
+    {
+        public bool IsConnected { get; }
+
+        public void Close()
+        {
+            // client implementation
+        }
+
+        public void Connect(IPEndPoint remoteIpEndpoint)
+        {
+            // client implementation
+        }
+
+        public void Dispose()
+        {
+            // client implementation
+        }
+
+        public Task<UdpReceiveResult> ReceiveAsync()
+        {
+            // client implementation
+        }
+
+        public Task<int> SendAsync(byte[] datagram, int bytes)
+        {
+            // client implementation
+        }
+    }
+
+    // Usage
+    IPEndpoint remoteIpEndpoint = new IPEndPoint(IPAddress.Parse(remoteServerIp), remoteServerPort);
+
+    IUdpClient myUdpClient = new MyAmazingUdpClient();
+    IServerQuery serverQuery = new ServerQuery(myUdpClient, remoteIpEndpoint);
+```
+
 once its created functions below returns informations desired,
 
 [ServerInfo](https://github.com/cyilcode/SteamQueryNet/blob/master/SteamQueryNet/SteamQueryNet/Models/ServerInfo.cs)
@@ -36,18 +106,21 @@ ServerInfo serverInfo = serverQuery.GetServerInfo();
 
 [Players](https://github.com/cyilcode/SteamQueryNet/blob/master/SteamQueryNet/SteamQueryNet/Models/Player.cs)
 ```csharp
-// Concurrent Players
 List<Player> players = serverQuery.GetPlayers();
 ```
 
 [Rules](https://github.com/cyilcode/SteamQueryNet/blob/master/SteamQueryNet/SteamQueryNet/Models/Rule.cs)
 ```csharp
-// Rules
 List<Rules> rules = serverQuery.GetRules();
 ```
 
-and thats it.
+While **it is not encouraged**, you can chain `Connect` function or Non-empty Constructors to get information in a single line.
+
+```csharp
+ServerInfo serverInfo = new ServerQuery()
+.Connect(host, port)
+.GetServerInfo();
+```
 
 # Todos
-* Write MOAR TESTS !
 * Enable CI

SteamQueryNet/SteamQueryNet.Tests/Responses/GetPlayersValidResponse.txt

@@ -0,0 +1 @@
+255,255,255,255,68,4,0,62,58,40,32,217,160,32,77,114,46,80,111,103,111,77,111,103,111,70,111,103,111,78,111,103,111,32,48,49,58,51,0,0,0,0,0,86,189,203,70,0,70,117,77,101,32,74,70,0,0,0,0,0,63,18,10,69,0,51,48,83,97,110,99,104,101,122,90,0,0,0,0,0,0,30,255,68,0,107,122,122,45,45,0,0,0,0,0,253,167,52,68

SteamQueryNet/SteamQueryNet.Tests/Responses/ResponseHelper.cs

@@ -0,0 +1,93 @@
+using SteamQueryNet.Enums;
+using SteamQueryNet.Models;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace SteamQueryNet.Tests.Responses
+{
+    internal sealed class ResponseHelper
+    {
+        internal const string ServerInfo = "/Responses/ServerInfoValidResponse.txt";
+        internal const string GetPlayers = "/Responses/GetPlayersValidResponse.txt";
+
+        // Decided to use a response from SurfHeaven servers and cache them. Got administrators approval.
+        private static readonly Dictionary<string, object> _responses = new Dictionary<string, object>()
+        {
+            {
+                ServerInfo, new ServerInfo
+                {
+                    Bots = 3,
+                    EDF = 177,
+                    Environment = ServerEnvironment.Linux,
+                    Folder = "csgo",
+                    Game = "Counter-Strike: Global Offensive",
+                    GameID = 730,
+                    ID = 730,
+                    Keywords = "!knife,!ws,64tick,SurfHeaven,autobhop,cs20,knife,rank,skins,stats,surf,surfing,surftimer,timer,ws,secure",
+                    Map = "surf_sinister_evil",
+                    MaxPlayers = 40,
+                    Name = " SurfHeaven #5 Top 250/VIP",
+                    Ping = 0,
+                    Players = 4,
+                    Port = 27015,
+                    Protocol = 17,
+                    ServerType = ServerType.Dedicated,
+                    ShipGameInfo = null,
+                    SourceTVPort = 0,
+                    SourceTVServerName = null,
+                    SteamID = 85568392920053114,
+                    VAC = VAC.Secured,
+                    Version = "1.37.3.6",
+                    Visibility = Visibility.Public
+                }
+            },
+            { 
+                GetPlayers, new List<Player>()
+                { 
+                    new Player 
+                    {
+                        Duration = 26078.668f,
+                        Index = 0,
+                        Name = ">:( ٠ Mr.PogoMogoFogoNogo 01:3",
+                        Score = 0
+                    },
+                    new Player
+                    {
+                        Duration = 2209.14038f,
+                        Index = 0,
+                        Name = "FuMe JF",
+                        Score = 0
+                    },
+                    new Player
+                    {
+                        Duration = 2040.9375f,
+                        Index = 0,
+                        Name = "30SanchezZ",
+                        Score = 0
+                    },
+                    new Player
+                    {
+                        Duration = 722.6248f,
+                        Index = 0,
+                        Name = "kzz--",
+                        Score = 0
+                    }
+                } 
+            }
+        };
+
+        public static (byte[], object) GetValidResponse(string responseType)
+        {
+            string validResponseString = File.ReadAllText(Environment.CurrentDirectory + responseType);
+            if (!_responses.TryGetValue(responseType, out object responseObject))
+            {
+                throw new ArgumentException($"Invalid response type received: {responseType}." +
+                    $"Consider registering {responseType} into ResponseHelpers dictionary.", nameof(responseType));
+            }
+
+            return (validResponseString.Split(',').Select(x => byte.Parse(x)).ToArray(), responseObject);
+        }
+    }
+}

SteamQueryNet/SteamQueryNet.Tests/Responses/ServerInfoValidResponse.txt

@@ -0,0 +1 @@
+255,255,255,255,73,17,32,83,117,114,102,72,101,97,118,101,110,32,35,53,32,84,111,112,32,50,53,48,47,86,73,80,0,115,117,114,102,95,115,105,110,105,115,116,101,114,95,101,118,105,108,0,99,115,103,111,0,67,111,117,110,116,101,114,45,83,116,114,105,107,101,58,32,71,108,111,98,97,108,32,79,102,102,101,110,115,105,118,101,0,218,2,4,40,3,100,108,0,1,49,46,51,55,46,51,46,54,0,177,135,105,122,53,0,0,0,0,48,1,33,107,110,105,102,101,44,33,119,115,44,54,52,116,105,99,107,44,83,117,114,102,72,101,97,118,101,110,44,97,117,116,111,98,104,111,112,44,99,115,50,48,44,107,110,105,102,101,44,114,97,110,107,44,115,107,105,110,115,44,115,116,97,116,115,44,115,117,114,102,44,115,117,114,102,105,110,103,44,115,117,114,102,116,105,109,101,114,44,116,105,109,101,114,44,119,115,44,115,101,99,117,114,101,0,218,2,0,0,0,0,0,0

SteamQueryNet/SteamQueryNet.Tests/ServerQueryTests.cs

@@ -1,5 +1,13 @@
 using Moq;
+
+using SteamQueryNet.Interfaces;
+using SteamQueryNet.Models;
+using SteamQueryNet.Tests.Responses;
+using SteamQueryNet.Utils;
 using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Net;
 using System.Net.Sockets;
 using Xunit;
@@ -11,34 +19,35 @@ public class ServerQueryTests
         private const string IP_ADDRESS = "127.0.0.1";
         private const string HOST_NAME = "localhost";
         private const ushort PORT = 27015;
-        private readonly string IP_AND_PORT_COLON = $"{IP_ADDRESS}:{PORT}";
-        private readonly string IP_AND_PORT_COMMA = $"{IP_ADDRESS},{PORT}";
-        private readonly string HOST_NAME_AND_PORT_COLON = $"{HOST_NAME}:{PORT}";
-        private readonly string HOST_NAME_AND_PORT_COMMA = $"{HOST_NAME},{PORT}";
+        private readonly IPEndPoint _localIpEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0);
 
         [Theory]
         [InlineData(IP_ADDRESS)]
         [InlineData(HOST_NAME)]
         public void ShouldInitializeWithProperHost(string host)
         {
-            var client = new Mock<UdpClient>();
-            client.Setup(x => x.Connect(It.IsAny<IPEndPoint>()));
-            new ServerQuery(client.Object, It.IsAny<IPEndPoint>()).Connect(host, PORT);
+            using (var sq = new ServerQuery(new Mock<IUdpClient>().Object, It.IsAny<IPEndPoint>()))
+            {
+                sq.Connect(host, PORT);
+            }
         }
 
-        // Please don't hate me but i think ClassDataAttribute sucks for many reasons.
-        [Fact]
-        public void ShouldInitializeWithProperHostAndPort()
+        [Theory]
+        [InlineData("127.0.0.1:27015")]
+        [InlineData("127.0.0.1,27015")]
+        [InlineData("localhost:27015")]
+        [InlineData("localhost,27015")]
+        [InlineData("steam://connect/localhost:27015")]
+        [InlineData("steam://connect/127.0.0.1:27015")]
+        public void ShouldInitializeWithProperHostAndPort(string ipAndHost)
         {
-            new ServerQuery(IP_AND_PORT_COLON);
-            new ServerQuery(IP_AND_PORT_COMMA);
-            new ServerQuery(HOST_NAME_AND_PORT_COLON);
-            new ServerQuery(HOST_NAME_AND_PORT_COMMA);
+            using (var sq = new ServerQuery(new Mock<IUdpClient>().Object, It.IsAny<IPEndPoint>()))
+            {
+                sq.Connect(ipAndHost);
+            }
         }
 
         [Theory]
-        [InlineData("256.256.256.256")]
-        [InlineData("invalidHost")]
         [InlineData("invalidHost:-1")]
         [InlineData("invalidHost,-1")]
         [InlineData("invalidHost:65536")]
@@ -47,12 +56,91 @@ public void ShouldInitializeWithProperHostAndPort()
         [InlineData("256.256.256.256,-1")]
         [InlineData("256.256.256.256:65536")]
         [InlineData("256.256.256.256,65536")]
-        public void ShouldNotInitializeWithAnInvalidHost(string invalidHost)
+        public void ShouldNotInitializeWithAnInvalidHostAndPort(string invalidHost)
         {
             Assert.Throws<ArgumentException>(() =>
             {
-                var squery = new ServerQuery(invalidHost, PORT);
+                using (var sq = new ServerQuery(new Mock<IUdpClient>().Object, It.IsAny<IPEndPoint>()))
+                {
+                    sq.Connect(invalidHost);
+                }
             });
         }
+
+        [Fact]
+        public void GetServerInfo_ShouldPopulateCorrectServerInfo()
+        {
+            (byte[] udpPacket, object responseObject) = ResponseHelper.GetValidResponse(ResponseHelper.ServerInfo);
+            var expectedObject = (ServerInfo)responseObject;
+
+            byte[] requestPacket = RequestHelpers.PrepareAS2_INFO_Request();
+            Mock<IUdpClient> udpClientMock = SetupReceiveResponse(udpPacket);
+            SetupRequestCompare(requestPacket, udpClientMock);
+
+            // Ayylmao it looks ugly as hell but we will improve it later on.
+            using (var sq = new ServerQuery(udpClientMock.Object, _localIpEndpoint))
+            {
+                ServerInfo result = sq.GetServerInfo();
+                Assert.Equal(expectedObject.Bots, result.Bots);
+                Assert.Equal(expectedObject.EDF, result.EDF);
+                Assert.Equal(expectedObject.Environment, result.Environment);
+                Assert.Equal(expectedObject.Folder, result.Folder);
+                Assert.Equal(expectedObject.Game, result.Game);
+                Assert.Equal(expectedObject.GameID, result.GameID);
+                Assert.Equal(expectedObject.ID, result.ID);
+                Assert.Equal(expectedObject.Keywords, result.Keywords);
+                Assert.Equal(expectedObject.Map, result.Map);
+                Assert.Equal(expectedObject.MaxPlayers, result.MaxPlayers);
+                Assert.Equal(expectedObject.Name, result.Name);
+                Assert.Equal(expectedObject.Ping, result.Ping);
+                Assert.Equal(expectedObject.Players, result.Players);
+                Assert.Equal(expectedObject.Port, result.Port);
+                Assert.Equal(expectedObject.Protocol, result.Protocol);
+                Assert.Equal(expectedObject.ServerType, result.ServerType);
+                Assert.Equal(expectedObject.ShipGameInfo, result.ShipGameInfo);
+                Assert.Equal(expectedObject.SourceTVPort, result.SourceTVPort);
+                Assert.Equal(expectedObject.SourceTVServerName, result.SourceTVServerName);
+                Assert.Equal(expectedObject.SteamID, result.SteamID);
+                Assert.Equal(expectedObject.VAC, result.VAC);
+                Assert.Equal(expectedObject.Version, result.Version);
+                Assert.Equal(expectedObject.Visibility, result.Visibility);
+            }
+        }
+
+        [Fact(Skip = "Not Completed Yet")]
+        public void GetPlayers_ShouldPopulateCorrectPlayers()
+        {
+            (byte[] udpPacket, object responseObject) = ResponseHelper.GetValidResponse(ResponseHelper.GetPlayers);
+            var expectedObject = (List<Player>)responseObject;
+
+            byte[] requestPacket = RequestHelpers.PrepareAS2_RENEW_CHALLENGE_Request();
+            Mock<IUdpClient> udpClientMock = SetupReceiveResponse(udpPacket);
+            SetupRequestCompare(requestPacket, udpClientMock);
+
+            // Ayylmao it looks ugly as hell but we will improve it later on.
+            using (var sq = new ServerQuery(udpClientMock.Object, _localIpEndpoint))
+            {
+                List<Player> result = sq.GetPlayers();
+
+            }
+        }
+
+        private void SetupRequestCompare(byte[] requestPacket, Mock<IUdpClient> udpClientMock)
+        {
+            udpClientMock
+                .Setup(x => x.SendAsync(It.IsAny<byte[]>(), requestPacket.Length))
+                .Callback<byte[], int>((request, length) =>
+                {
+                    Assert.True(TestValidators.CompareBytes(requestPacket, request));
+                });
+        }
+
+        private Mock<IUdpClient> SetupReceiveResponse(byte[] udpPacket)
+        {
+            Mock<IUdpClient> udpClientMock = new Mock<IUdpClient>();
+            UdpReceiveResult result = new UdpReceiveResult(udpPacket, _localIpEndpoint);
+            udpClientMock.Setup(x => x.ReceiveAsync()).ReturnsAsync(result);
+            return udpClientMock;
+        }
     }
 }