Adding possibility to change Kinvey api version.

eugengoroluov · eugengoroluov · commit 71ecf17d69cc · 2019-05-20T12:06:43.000+03:00
diff --git a/Kinvey.Core/Auth/KinveyAuthRequest.cs b/Kinvey.Core/Auth/KinveyAuthRequest.cs
@@ -190,7 +190,14 @@ private HttpRequestMessage BuildRestRequest()
 
             foreach (var header in kinveyHeaders)
             {
-                request.Headers.Add(header.Key, header.Value.FirstOrDefault());
+                var key = header.Key;
+                var value = header.Value.FirstOrDefault();
+
+                if (key.Equals(Constants.STR_REQUEST_HEADER_API_VERSION) && !string.IsNullOrEmpty(client.ApiVersion) && !value.Equals(client.ApiVersion))
+                {
+                    value = client.ApiVersion;
+                }
+                request.Headers.Add(key, value);
             }
 
             appKeyAuthentication.Authenticate(request);
diff --git a/Kinvey.Core/Client/AbstractKinveyClient.cs b/Kinvey.Core/Client/AbstractKinveyClient.cs
@@ -41,6 +41,8 @@ public abstract class AbstractKinveyClient
 		/// </summary>
 		private HttpClient httpClient;
 
+        private string apiVersion;
+
 		private string clientAppVersion = null;
 
 		private JObject customRequestProperties = new JObject();
@@ -208,11 +210,21 @@ public HttpClient HttpClient
             get { return this.httpClient; }
         }
 
-		/// <summary>
-		/// Initializes the request.
+        /// <summary>
+		/// Gets Kinvey api version.
 		/// </summary>
-		/// <param name="request">Request.</param>
-		/// <typeparam name="T">The Type of the response</typeparam>
+		/// <value>Kinvey api version.</value>
+        public string ApiVersion
+        {
+            get { return string.IsNullOrEmpty(apiVersion) ? KinveyHeaders.kinveyApiVersion: apiVersion; }
+            internal set { this.apiVersion = value; }
+        }
+
+        /// <summary>
+        /// Initializes the request.
+        /// </summary>
+        /// <param name="request">Request.</param>
+        /// <typeparam name="T">The Type of the response</typeparam>
         public void InitializeRequest<T>(AbstractKinveyClientRequest<T> request, string clientID = null)
         {
             if (RequestInitializer != null) 
diff --git a/Kinvey.Core/Client/Client.cs b/Kinvey.Core/Client/Client.cs
@@ -167,6 +167,8 @@ private string filePath
 
             private Constants.DevicePlatform devicePlatform;
 
+            private string apiVersion;
+
 			/// <summary>
 			/// Initializes a new instance of the <see cref="T:KinveyXamarin.Client.Builder"/> class.
 			/// </summary>
@@ -211,6 +213,7 @@ public virtual Client Build()
 				c.logger = this.log;
 				c.senderID = this.senderID;
 				c.SSOGroupKey = this.ssoGroupKey;
+                c.ApiVersion = apiVersion;
                 if (!string.IsNullOrEmpty(this.MICHostName)) c.MICHostName = this.MICHostName;
                 if (!string.IsNullOrEmpty(instanceID))
                 {
@@ -335,6 +338,17 @@ public Builder SetInstanceID(string instanceID)
                 this.setBaseURL(url);
                 return this;
             }
+
+            /// <summary>
+            /// Sets Kinvey api version.
+            /// </summary>
+            /// <returns>The current builder.</returns>
+            /// <param name="version">Kinvey api version.</param>
+            public Builder SetApiVersion(string version)
+            {
+                apiVersion = version;
+                return this;
+            }
         }
 	}
 }
diff --git a/Kinvey.Core/Core/AbstractKinveyClientRequest.cs b/Kinvey.Core/Core/AbstractKinveyClientRequest.cs
@@ -288,6 +288,12 @@ public HttpRequestMessage BuildRestRequest()
 
             foreach (var header in requestHeaders)
             {
+                if (header.Key.Equals(Constants.STR_REQUEST_HEADER_API_VERSION) && !string.IsNullOrEmpty(client.ApiVersion) && !header.Value.FirstOrDefault().Equals(client.ApiVersion))
+                {
+                    request.Headers.Add(header.Key, client.ApiVersion);
+                    continue;
+                }
+
                 if (header.Value.Count() > 1)
                 {
                     request.Headers.Add(header.Key, header.Value);
diff --git a/Kinvey.Core/Core/KinveyHeaders.cs b/Kinvey.Core/Core/KinveyHeaders.cs
@@ -29,8 +29,7 @@ public class KinveyHeaders : List<KeyValuePair<string, IEnumerable<string>>>
 		public static string VERSION = "4.0.1";
 
 		// The kinvey API version.
-        static string kinveyApiVersionKey = "X-Kinvey-API-Version";
-        static string kinveyApiVersion = "4";
+        internal static readonly string kinveyApiVersion = "4";
 
 		// The user agent.
         static string userAgentKey = "user-agent";
@@ -72,7 +71,7 @@ public KinveyHeaders(Constants.DevicePlatform devicePlatform)
                 userAgentKey, new List<string> { userAgent }
             ));
             Add(new KeyValuePair<string, IEnumerable<string>>(
-                kinveyApiVersionKey, new List<string> { kinveyApiVersion }
+                Constants.STR_REQUEST_HEADER_API_VERSION, new List<string> { kinveyApiVersion }
             ));
 
             JObject deviceInfo = new JObject();
diff --git a/Kinvey.Core/Utils/KinveyConstants.cs b/Kinvey.Core/Utils/KinveyConstants.cs
@@ -72,6 +72,7 @@ public static partial class Constants
 
         // Request Headers
         internal const string STR_REQUEST_HEADER_DEVICE_INFO = "X-Kinvey-Device-Info";
+        internal const string STR_REQUEST_HEADER_API_VERSION = "X-Kinvey-API-Version";
 
         // X-Kinvey-Device-Info Strings
         internal const string STR_DEVICE_INFO_HEADER_KEY = "hv";
diff --git a/Kinvey.Tests/BaseTestClass.cs b/Kinvey.Tests/BaseTestClass.cs
@@ -68,6 +68,8 @@ public static class EnvironmentVariable
         private static readonly string REQUEST_START_HEADER = "X-Kinvey-Request-Start";
         private static readonly string DATE_FORMAT = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffK";
 
+        private static readonly int MaxApiVersion = 5;
+
         protected static HttpListener httpListener;
 
         public void Delete(string fileName)
@@ -917,6 +919,17 @@ protected static void MockResponses(uint? expectedRequests = null, Client client
                         count++;
                         Console.WriteLine($"{count}");
 
+                        var apiVersion = context.Request.Headers[Constants.STR_REQUEST_HEADER_API_VERSION];
+                        var version = 0;
+                        var isParsed = int.TryParse(apiVersion, out version);
+
+                        if (!isParsed || (isParsed && version > MaxApiVersion))
+                        {
+                            context.Response.StatusCode = (int)HttpStatusCode.NotImplemented;
+                            Write(context, "Not implemented");
+                            continue;
+                        }
+
                         var authorization = context.Request.Headers["Authorization"];
                         if (!context.Request.Url.LocalPath.StartsWith("/_uploadURL/", StringComparison.Ordinal) && !context.Request.Url.LocalPath.StartsWith("/_downloadURL/", StringComparison.Ordinal))
                         {
diff --git a/Kinvey.Tests/ClientTests/ClientIntegrationTests.cs b/Kinvey.Tests/ClientTests/ClientIntegrationTests.cs
@@ -270,5 +270,117 @@ public async Task TestCustomEndpointBad()
 			KinveyException ke = e as KinveyException;
 			Assert.AreEqual(404, ke.StatusCode);
 		}
-	}
+
+        [TestMethod]
+        public async Task TestSetApiVersionAuthRequests()
+        {
+            // Arrange
+            var notSupportingApiVersion = int.MaxValue.ToString();
+
+            var builder = new Client.Builder(AppKey, AppSecret);
+            builder.SetFilePath(TestSetup.db_dir);
+           
+            if (MockData)
+            {
+                builder.setBaseURL("http://localhost:8080");
+                builder.setMICHostName("http://localhost:8081");
+            }
+
+            var client1 = builder.Build();
+
+            builder.SetApiVersion(notSupportingApiVersion);
+            var client2 = builder.Build();
+
+            builder.SetApiVersion(KinveyHeaders.kinveyApiVersion);
+            var client3 = builder.Build();
+
+            if (MockData)
+            {
+                MockResponses(3);
+            }
+          
+            // Act
+            var userForClient1 = await User.LoginAsync(client1);
+
+            var exception = await Assert.ThrowsExceptionAsync<KinveyException>(async delegate
+            {
+                await User.LoginAsync(client2);
+            });
+
+            var userForClient3 = await User.LoginAsync(client3);
+           
+            // Assert
+            Assert.AreEqual(typeof(KinveyException), exception.GetType());
+            var kinveyException = exception as KinveyException;
+            Assert.IsTrue(kinveyException.ErrorCategory == EnumErrorCategory.ERROR_BACKEND);
+            Assert.IsTrue(kinveyException.ErrorCode == EnumErrorCode.ERROR_JSON_RESPONSE);
+
+            Assert.IsNotNull(client1.ActiveUser);
+            Assert.IsTrue(userForClient1.Active);
+
+            Assert.IsNotNull(client3.ActiveUser);
+            Assert.IsTrue(userForClient3.Active);
+
+            Assert.AreEqual(KinveyHeaders.kinveyApiVersion, client1.ApiVersion);
+            Assert.AreEqual(notSupportingApiVersion, client2.ApiVersion);
+            Assert.AreEqual(KinveyHeaders.kinveyApiVersion, client3.ApiVersion);
+        }
+
+        [TestMethod]
+        public async Task TestSetApiVersionKinveyClientRequests()
+        {
+            // Arrange
+            var notSupportingApiVersion = int.MaxValue.ToString();
+
+            var builder = new Client.Builder(AppKey, AppSecret);
+            builder.SetFilePath(TestSetup.db_dir);
+
+            if (MockData)
+            {
+                builder.setBaseURL("http://localhost:8080");
+                builder.setMICHostName("http://localhost:8081");
+            }
+
+            var client1 = builder.Build();
+
+            builder.SetApiVersion(notSupportingApiVersion);
+            var client2 = builder.Build();
+
+            builder.SetApiVersion(KinveyHeaders.kinveyApiVersion);
+            var client3 = builder.Build();
+
+            if (MockData)
+            {
+                MockResponses(3);
+            }
+
+            // Act
+            var pingResponse1 = await client1.PingAsync();
+
+            var exception = await Assert.ThrowsExceptionAsync<KinveyException>(async delegate
+            {
+                await client2.PingAsync();
+            });
+
+            var pingResponse3 = await client3.PingAsync();
+
+            // Assert
+            Assert.AreEqual(typeof(KinveyException), exception.GetType());
+            var kinveyException = exception as KinveyException;
+            Assert.IsTrue(kinveyException.ErrorCategory == EnumErrorCategory.ERROR_BACKEND);
+            Assert.IsTrue(kinveyException.ErrorCode == EnumErrorCode.ERROR_JSON_RESPONSE);
+
+            Assert.IsNotNull(pingResponse1.kinvey);
+            Assert.IsTrue(pingResponse1.kinvey.StartsWith("hello", StringComparison.Ordinal));
+            Assert.IsNotNull(pingResponse1.version);
+
+            Assert.IsNotNull(pingResponse3.kinvey);
+            Assert.IsTrue(pingResponse3.kinvey.StartsWith("hello", StringComparison.Ordinal));
+            Assert.IsNotNull(pingResponse3.version);
+
+            Assert.AreEqual(KinveyHeaders.kinveyApiVersion, client1.ApiVersion);
+            Assert.AreEqual(notSupportingApiVersion, client2.ApiVersion);
+            Assert.AreEqual(KinveyHeaders.kinveyApiVersion, client3.ApiVersion);
+        }
+    }
 }
diff --git a/sqlite-net b/sqlite-net
@@ -1 +1 @@
-Subproject commit 7fc4a958004ae61f8784ea0f71ae71799f2791ee
+Subproject commit f8fb24b007b301160d64ceb0e30b870da0c32bdc

Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,14 @@ private HttpRequestMessage BuildRestRequest()`
`190`	`190`
`191`	`191`	`foreach (var header in kinveyHeaders)`
`192`	`192`	`{`
`193`		`- request.Headers.Add(header.Key, header.Value.FirstOrDefault());`
	`193`	`+ var key = header.Key;`
	`194`	`+ var value = header.Value.FirstOrDefault();`
	`195`	`+`
	`196`	`+ if (key.Equals(Constants.STR_REQUEST_HEADER_API_VERSION) && !string.IsNullOrEmpty(client.ApiVersion) && !value.Equals(client.ApiVersion))`
	`197`	`+ {`
	`198`	`+ value = client.ApiVersion;`
	`199`	`+ }`
	`200`	`+ request.Headers.Add(key, value);`
`194`	`201`	`}`
`195`	`202`
`196`	`203`	`appKeyAuthentication.Authenticate(request);`
Original file line number	Diff line number	Diff line change
`@@ -288,6 +288,12 @@ public HttpRequestMessage BuildRestRequest()`
`288`	`288`
`289`	`289`	`foreach (var header in requestHeaders)`
`290`	`290`	`{`
	`291`	`+ if (header.Key.Equals(Constants.STR_REQUEST_HEADER_API_VERSION) && !string.IsNullOrEmpty(client.ApiVersion) && !header.Value.FirstOrDefault().Equals(client.ApiVersion))`
	`292`	`+ {`
	`293`	`+ request.Headers.Add(header.Key, client.ApiVersion);`
	`294`	`+ continue;`
	`295`	`+ }`
	`296`	`+`
`291`	`297`	`if (header.Value.Count() > 1)`
`292`	`298`	`{`
`293`	`299`	`request.Headers.Add(header.Key, header.Value);`