Merge pull request #41 from firebase/hkj-fcm-header

Setting X-Firebase-Client in FCM API calls

Author: hiranya911

FirebaseAdmin/FirebaseAdmin.Tests/FirebaseAppTest.cs

@@ -210,6 +210,17 @@ public void GetOrInitService()
             });
         }
 
+        [Fact]
+        public void GetSdkVersion()
+        {
+            var version = FirebaseApp.GetSdkVersion();
+
+            var segments = version.Split(".");
+            Assert.Equal(3, segments.Length);
+            int result;
+            Assert.All(segments, (segment) => int.TryParse(segment, out result));
+        }
+
         public void Dispose()
         {
             FirebaseApp.DeleteAll();

FirebaseAdmin/FirebaseAdmin.Tests/Messaging/FirebaseMessagingClientTest.cs

@@ -71,22 +71,44 @@ public async Task SendAsync()
             {
                 Topic = "test-topic",
             };
+
             var response = await client.SendAsync(message);
+
             Assert.Equal("test-response", response);
-            var req = JsonConvert.DeserializeObject<FirebaseMessagingClient.SendRequest>(
-                handler.Request);
+            var req = JsonConvert.DeserializeObject<FirebaseMessagingClient.SendRequest>(handler.Request);
             Assert.Equal("test-topic", req.Message.Topic);
             Assert.False(req.ValidateOnly);
             Assert.Equal(1, handler.Calls);
+            var versionHeader = handler.RequestHeaders.GetValues("X-Firebase-Client").First();
+            Assert.Equal(FirebaseMessagingClient.ClientVersion, versionHeader);
+        }
+
+        [Fact]
+        public async Task SendDryRunAsync()
+        {
+            var handler = new MockMessageHandler()
+            {
+                Response = new FirebaseMessagingClient.SingleMessageResponse()
+                {
+                    Name = "test-response",
+                },
+            };
+            var factory = new MockHttpClientFactory(handler);
+            var client = new FirebaseMessagingClient(factory, MockCredential, "test-project");
+            var message = new Message()
+            {
+                Topic = "test-topic",
+            };
+
+            var response = await client.SendAsync(message, dryRun: true);
 
-            // Send in dryRun mode.
-            response = await client.SendAsync(message, dryRun: true);
             Assert.Equal("test-response", response);
-            req = JsonConvert.DeserializeObject<FirebaseMessagingClient.SendRequest>(
-                handler.Request);
+            var req = JsonConvert.DeserializeObject<FirebaseMessagingClient.SendRequest>(handler.Request);
             Assert.Equal("test-topic", req.Message.Topic);
             Assert.True(req.ValidateOnly);
-            Assert.Equal(2, handler.Calls);
+            Assert.Equal(1, handler.Calls);
+            var versionHeader = handler.RequestHeaders.GetValues("X-Firebase-Client").First();
+            Assert.Equal(FirebaseMessagingClient.ClientVersion, versionHeader);
         }
 
         [Fact]
@@ -142,10 +164,15 @@ public async Task SendAllAsync()
             {
                 Token = "test-token2",
             };
+
             var response = await client.SendAllAsync(new[] { message1, message2 });
+
             Assert.Equal(2, response.SuccessCount);
             Assert.Equal("projects/fir-adminintegrationtests/messages/8580920590356323124", response.Responses[0].MessageId);
             Assert.Equal("projects/fir-adminintegrationtests/messages/5903525881088369386", response.Responses[1].MessageId);
+            Assert.Equal(1, handler.Calls);
+            var versionHeader = $"X-Firebase-Client: {FirebaseMessagingClient.ClientVersion}";
+            Assert.Equal(2, this.CountLinesWithPrefix(handler.Request, versionHeader));
         }
 
         [Fact]
@@ -212,11 +239,16 @@ public async Task SendAllAsyncWithError()
             {
                 Token = "test-token2",
             };
+
             var response = await client.SendAllAsync(new[] { message1, message2 });
+
             Assert.Equal(1, response.SuccessCount);
             Assert.Equal(1, response.FailureCount);
             Assert.Equal("projects/fir-adminintegrationtests/messages/8580920590356323124", response.Responses[0].MessageId);
             Assert.NotNull(response.Responses[1].Exception);
+            Assert.Equal(1, handler.Calls);
+            var versionHeader = $"X-Firebase-Client: {FirebaseMessagingClient.ClientVersion}";
+            Assert.Equal(2, this.CountLinesWithPrefix(handler.Request, versionHeader));
         }
 
         [Fact]
@@ -268,5 +300,10 @@ public async Task HttpErrorAsync()
             Assert.False(req.ValidateOnly);
             Assert.Equal(1, handler.Calls);
         }
+
+        private int CountLinesWithPrefix(string body, string linePrefix)
+        {
+            return body.Split('\n').Count((line) => line.StartsWith(linePrefix));
+        }
     }
 }

FirebaseAdmin/FirebaseAdmin.Tests/MockMessageHandler.cs

@@ -43,6 +43,8 @@ public MockMessageHandler()
 
         public string Request { get; private set; }
 
+        public HttpRequestHeaders RequestHeaders { get; private set; }
+
         public HttpStatusCode StatusCode { get; set; }
 
         public object Response { get; set; }
@@ -63,6 +65,8 @@ protected override async Task<HttpResponseMessage> SendAsyncCore(
                 this.Request = null;
             }
 
+            this.RequestHeaders = request.Headers;
+
             var resp = new HttpResponseMessage();
             string json;
             if (this.Response is byte[])

FirebaseAdmin/FirebaseAdmin/FirebaseApp.cs

@@ -15,6 +15,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Google;
@@ -261,6 +262,16 @@ internal static void DeleteAll()
             }
         }
 
+        /// <summary>
+        /// Returns the current version of the .NET assembly.
+        /// </summary>
+        /// <returns>A version string in major.minor.patch format.</returns>
+        internal static string GetSdkVersion()
+        {
+            const int majorMinorPatch = 3;
+            return typeof(FirebaseApp).GetTypeInfo().Assembly.GetName().Version.ToString(majorMinorPatch);
+        }
+
         internal T GetOrInit<T>(string id, ServiceFactory<T> initializer)
             where T : class, IFirebaseService
         {

FirebaseAdmin/FirebaseAdmin/Messaging/FirebaseMessagingClient.cs

@@ -20,6 +20,7 @@
 using System.Threading.Tasks;
 using Google.Apis.Auth.OAuth2;
 using Google.Apis.Http;
+using Google.Apis.Json;
 using Google.Apis.Requests;
 using Google.Apis.Services;
 using Google.Apis.Util;
@@ -61,6 +62,14 @@ public FirebaseMessagingClient(
             this.fcmClientService = new FCMClientService(this.httpClient);
         }
 
+        internal static string ClientVersion
+        {
+            get
+            {
+                return $"fire-admin-dotnet/{FirebaseApp.GetSdkVersion()}";
+            }
+        }
+
         /// <summary>
         /// Sends a message to the FCM service for delivery. The message gets validated both by
         /// the Admin SDK, and the remote FCM service. A successful return value indicates
@@ -92,8 +101,7 @@ public async Task<string> SendAsync(
             };
             try
             {
-                var response = await this.httpClient.PostJsonAsync(
-                    this.sendUrl, request, cancellationToken).ConfigureAwait(false);
+                var response = await this.SendRequestAsync(request, cancellationToken).ConfigureAwait(false);
                 var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
                 if (!response.IsSuccessStatusCode)
                 {
@@ -157,12 +165,32 @@ public void Dispose()
             this.httpClient.Dispose();
         }
 
+        private static void AddCommonHeaders(HttpRequestMessage request)
+        {
+            request.Headers.Add("X-Firebase-Client", ClientVersion);
+        }
+
         private static FirebaseException CreateExceptionFor(RequestError requestError)
         {
             return new FirebaseException(requestError.ToString());
         }
 
-        private async Task<BatchResponse> SendBatchRequestAsync(IEnumerable<Message> messages, bool dryRun, CancellationToken cancellationToken)
+        private async Task<HttpResponseMessage> SendRequestAsync(object body, CancellationToken cancellationToken)
+        {
+            var request = new HttpRequestMessage()
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri(this.sendUrl),
+                Content = NewtonsoftJsonSerializer.Instance.CreateJsonHttpContent(body),
+            };
+            AddCommonHeaders(request);
+            return await this.httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
+        }
+
+        private async Task<BatchResponse> SendBatchRequestAsync(
+            IEnumerable<Message> messages,
+            bool dryRun,
+            CancellationToken cancellationToken)
         {
             var responses = new List<SendResponse>();
 
@@ -181,21 +209,30 @@ private async Task<BatchResponse> SendBatchRequestAsync(IEnumerable<Message> mes
                     }
                     else
                     {
-                        responses.Add(SendResponse.FromException(new FirebaseException($"Unexpected batch response. Response status code was {message.StatusCode}.")));
+                        responses.Add(SendResponse.FromException(new FirebaseException(
+                            $"Unexpected batch response. Response status code was {message.StatusCode}.")));
                     }
                 });
 
-            await batch.ExecuteAsync(cancellationToken);
+            await batch.ExecuteAsync(cancellationToken).ConfigureAwait(false);
             return new BatchResponse(responses);
         }
 
-        private BatchRequest CreateBatchRequest(IEnumerable<Message> messages, bool dryRun, BatchRequest.OnResponse<SingleMessageResponse> callback)
+        private BatchRequest CreateBatchRequest(
+            IEnumerable<Message> messages,
+            bool dryRun,
+            BatchRequest.OnResponse<SingleMessageResponse> callback)
         {
             var batch = new BatchRequest(this.fcmClientService, FcmBatchUrl);
 
             foreach (var message in messages)
             {
-                batch.Queue(new FCMClientServiceRequest(this.fcmClientService, this.restPath, message, dryRun), callback);
+                var body = new SendRequest()
+                {
+                    Message = message,
+                    ValidateOnly = dryRun,
+                };
+                batch.Queue(new FCMClientServiceRequest(this.fcmClientService, this.restPath, body), callback);
             }
 
             return batch;
@@ -258,16 +295,17 @@ public ConfigurableHttpClient CreateHttpClient(CreateHttpClientArgs args)
         private sealed class FCMClientServiceRequest : ClientServiceRequest<string>
         {
             private readonly string restPath;
-            private readonly Message message;
-            private readonly bool dryRun;
+            private readonly SendRequest body;
 
-            public FCMClientServiceRequest(IClientService clientService, string restPath, Message message, bool dryRun)
+            public FCMClientServiceRequest(FCMClientService clientService, string restPath, SendRequest body)
                 : base(clientService)
             {
                 this.restPath = restPath;
-                this.message = message;
-                this.dryRun = dryRun;
-
+                this.body = body;
+                this.ModifyRequest = (request) =>
+                {
+                    AddCommonHeaders(request);
+                };
                 this.InitParameters();
             }
 
@@ -279,13 +317,7 @@ public FCMClientServiceRequest(IClientService clientService, string restPath, Me
 
             protected override object GetBody()
             {
-                var sendRequest = new SendRequest()
-                {
-                    Message = this.message,
-                    ValidateOnly = this.dryRun,
-                };
-
-                return sendRequest;
+                return this.body;
             }
         }
     }