GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/teams.net

Public

mirrored fromhttps://github.com/microsoft/teams.netAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
ed542af71cd064dd9674c86645c24cec4e03bec6

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

teams.net/Tests/Microsoft.Teams.Common.Tests/Http

Tests/Microsoft.Teams.Common.Tests/Http/HttpClientTests.cs

371lines · modecode

RawDownload
Latest commit unavailable.
1using System.Net;
2using System.Net.Http.Json;
3using System.Text;
4using System.Text.Json;
5
6using Microsoft.Teams.Api.SignIn;
7using Microsoft.Teams.Cards;
8using Microsoft.Teams.Common.Http;
9
10using Moq;
11using Moq.Protected;
12
13namespace Microsoft.Teams.Common.Tests.Http;
14
15public class HttpClientTests
16{
17
18
19 [Fact]
20 public async Task HttpClient_ShouldReturnExpectedResponse_WhenMocked()
21 {
22 // Arrange
23 var mockMessageHandler = new Mock<HttpMessageHandler>();
24 mockMessageHandler.Protected()
25 .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
26 .ReturnsAsync(new HttpResponseMessage
27 {
28 StatusCode = HttpStatusCode.OK,
29 Content = new StringContent("Mocked response")
30 });
31
32 var httpClient = new Common.Http.HttpClient(new System.Net.Http.HttpClient(mockMessageHandler.Object));
33 HttpRequest request = HttpRequest.Get("https://www.microsoft.com");
34
35 // Act
36 var response = await httpClient.SendAsync(request);
37
38 // Assert
39 Assert.Equal(HttpStatusCode.OK, response.StatusCode);
40 Assert.Equal("Mocked response", response.Body);
41 }
42
43 [Fact]
44 public async Task HttpClient_ShouldReturnExpectedResponseWithHeaders()
45 {
46 // Arrange
47 var responseMessage = new HttpResponseMessage();
48 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
49 var mockMessageHandler = new Mock<HttpMessageHandler>();
50 mockMessageHandler.Protected()
51 .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
52 .ReturnsAsync(new HttpResponseMessage
53 {
54 StatusCode = HttpStatusCode.OK,
55 Content = new StringContent("Mocked response"),
56 });
57
58 var httpClient = new Common.Http.HttpClient(new System.Net.Http.HttpClient(mockMessageHandler.Object));
59 HttpRequest request = HttpRequest.Get("https://www.microsoft.com");
60
61 // Act
62 var response = await httpClient.SendAsync(request);
63
64 // Assert
65 Assert.Equal(HttpStatusCode.OK, response.StatusCode);
66 Assert.Equal("Mocked response", response.Body);
67 }
68
69 [Fact]
70 public async Task HttpClient_ShouldReturnExpectedResponse_ResponseObject()
71 {
72 // Arrange
73 var urlResponse = new UrlResponse()
74 {
75 SignInLink = "valid signin dataa",
76 TokenExchangeResource = new Api.TokenExchange.Resource()
77 {
78 Id = "id",
79 ProviderId = "providerId",
80 Uri = "uri",
81 },
82 TokenPostResource = new Api.Token.PostResource()
83 {
84 SasUrl = "valid sas url",
85 }
86 };
87 var urlResponseJson = JsonSerializer.Serialize(urlResponse, new JsonSerializerOptions()
88 {
89 WriteIndented = true,
90 IndentSize = 2,
91 DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
92 });
93 var mockMessageHandler = new Mock<HttpMessageHandler>();
94 mockMessageHandler.Protected()
95 .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
96 .ReturnsAsync(new HttpResponseMessage
97 {
98 StatusCode = HttpStatusCode.OK,
99 Content = new StringContent(urlResponseJson, Encoding.UTF8, "application/json"),
100 });
101
102 var httpClient = new Common.Http.HttpClient(new System.Net.Http.HttpClient(mockMessageHandler.Object));
103 HttpRequest request = HttpRequest.Get("https://www.microsoft.com");
104
105 // Act
106 var response = await httpClient.SendAsync<UrlResponse>(request);
107
108 // Assert
109 Assert.Equal(HttpStatusCode.OK, response.StatusCode);
110 Assert.Equal(urlResponse.ToString(), response.Body.ToString());
111 }
112
113 [Fact]
114 public void HttpClient_ShouldDisposeClient()
115 {
116 // Arrange
117 var httpClient = new Common.Http.HttpClient();
118 // Act
119 httpClient.Dispose();
120 // Assert
121 Assert.True(true); // No exception should be thrown
122 Assert.NotNull(httpClient.Options);
123 }
124
125
126
127 public class MockHttpClient : Common.Http.HttpClient
128 {
129 public HttpRequestMessage ValidateCreateRequest(HttpRequest request)
130 {
131 var httpRequestMessage = CreateRequest(request);
132 return httpRequestMessage;
133 }
134
135 public async Task<IHttpResponse<string>> ValidateCreateResponse(HttpResponseMessage response, CancellationToken cancellationToken = default)
136 {
137 return await CreateResponse(response, cancellationToken);
138 }
139 }
140
141 [Fact]
142 public void HttpClient_ShouldSetRequestHeaders_CustomHeader()
143 {
144 // Arrange
145 var customRequestHeader = new List<string> { "HeaderValue", "someOther value" };
146 HttpRequest request = HttpRequest.Get("https://www.microsoft.com");
147 request.AddHeader("Custom-Header", customRequestHeader);
148
149 var mockHttpclient = new MockHttpClient();
150
151 // Act
152 var httpRequestMessage = mockHttpclient.ValidateCreateRequest(request);
153
154 // Assert
155 Assert.Equal("GET", httpRequestMessage.Method.Method);
156 var httpRequestHeaders = httpRequestMessage.Headers.GetValues("Custom-Header").ToList();
157 Assert.Equal("HeaderValue", httpRequestHeaders[0]);
158 Assert.Equal("someOther value", httpRequestHeaders[1]);
159 }
160
161 [Fact]
162 public void HttpClient_ShouldSetRequestHeaders_BodyAsDictionary()
163 {
164 // Arrange
165 var customRequestHeader = new List<string> { "HeaderValue", "someOther value" };
166 HttpRequest request = HttpRequest.Post("https://www.microsoft.com");
167 request.AddHeader("Custom-Header", customRequestHeader);
168 request.Body = new Dictionary<string, string>()
169 {
170 { "grant_type", "client_credentials" },
171 { "client_id", "ClientId" },
172 { "client_secret", "ClientSecret" },
173 { "scope", "scope" }
174 };
175
176 var mockHttpclient = new MockHttpClient();
177
178 // Act
179 var httpRequestMessage = mockHttpclient.ValidateCreateRequest(request);
180
181 // Assert
182 Assert.Equal("POST", httpRequestMessage.Method.Method);
183 var httpRequestHeaders = httpRequestMessage.Headers.GetValues("Custom-Header").ToList();
184 Assert.Equal("HeaderValue", httpRequestHeaders[0]);
185 Assert.Equal("someOther value", httpRequestHeaders[1]);
186
187 var contentTypeHeader = httpRequestMessage.Content?.Headers.GetValues("Content-Type").ToList();
188 Assert.Single(contentTypeHeader!);
189 Assert.Equal("application/x-www-form-urlencoded", httpRequestMessage.Content?.Headers.ContentType?.MediaType);
190 Assert.Equal("application/x-www-form-urlencoded", contentTypeHeader![0]);
191
192 // TODO : Check the content of the request body
193 //var requestBody = httpRequestMessage.Content?.ToString();
194 //Assert.Contains("grant_type=client_credentials", requestBody);
195
196 }
197
198 [Fact]
199 public void HttpClient_ShouldSetRequestHeaders_BodyAsString()
200 {
201 // Arrange
202 var customRequestHeader = new List<string> { "HeaderValue", "someOther value" };
203 HttpRequest request = HttpRequest.Post("https://www.microsoft.com");
204 request.AddHeader("Custom-Header", customRequestHeader);
205 request.AddHeader("Content-Type", "application/json");
206 request.Body = "post data";
207
208 var mockHttpclient = new MockHttpClient();
209
210 // Act
211 var httpRequestMessage = mockHttpclient.ValidateCreateRequest(request);
212
213 // Assert
214 Assert.Equal("POST", httpRequestMessage.Method.Method);
215 var httpRequestHeaders = httpRequestMessage.Headers.GetValues("Custom-Header").ToList();
216 Assert.Equal("HeaderValue", httpRequestHeaders[0]);
217 Assert.Equal("someOther value", httpRequestHeaders[1]);
218
219 var contentTypeHeader = httpRequestMessage.Content?.Headers.GetValues("Content-Type").ToList();
220 Assert.Single(contentTypeHeader!);
221 Assert.Equal("application/json", httpRequestMessage.Content?.Headers.ContentType?.MediaType);
222 Assert.Equal("application/json", contentTypeHeader![0]);
223
224 // TODO : Check the content of the request body
225 }
226
227 [Fact]
228 public async Task HttpClient_ShouldSetRequestHeaders_BodyAsJsonObject()
229 {
230 // Arrange
231 var tokenData = new Api.Tabs.Request()
232 {
233 Context = new Api.Tabs.Context()
234 {
235 Theme = "default",
236 },
237 State = "state",
238 TabContext = new Api.Tabs.EntityContext()
239 {
240 TabEntityId = "tabEntityId",
241 }
242 };
243
244 var customRequestHeader = new List<string> { "HeaderValue", "someOther value" };
245 HttpRequest request = HttpRequest.Post("https://www.microsoft.com");
246 request.AddHeader("Custom-Header", customRequestHeader);
247 request.AddHeader("Content-data", "valid");
248 request.Body = tokenData;
249
250 var mockHttpclient = new MockHttpClient();
251
252 // Act
253 var httpRequestMessage = mockHttpclient.ValidateCreateRequest(request);
254
255 // Assert
256 Assert.Equal("POST", httpRequestMessage.Method.Method);
257 var httpRequestHeaders = httpRequestMessage.Headers.GetValues("Custom-Header").ToList();
258 Assert.Equal("HeaderValue", httpRequestHeaders[0]);
259 Assert.Equal("someOther value", httpRequestHeaders[1]);
260
261 Assert.NotNull(httpRequestMessage.Content);
262 var contentTypeHeader = httpRequestMessage.Content.Headers.GetValues("Content-Type").ToList();
263 Assert.NotNull(contentTypeHeader);
264 Assert.Single(contentTypeHeader!);
265 Assert.Equal("application/json", httpRequestMessage.Content.Headers.ContentType?.MediaType);
266 Assert.Equal("application/json; charset=utf-8", contentTypeHeader[0]);
267
268 var deserializedContent = await httpRequestMessage.Content.ReadFromJsonAsync<Api.Tabs.Request>();
269 Assert.Equal(tokenData.ToString(), deserializedContent!.ToString());
270 }
271
272 [Fact]
273 public async Task HttpClient_ShouldThrowException_WhenResponseIsNotSuccess()
274 {
275 // Arrange
276 var errorResponse = new Dictionary<string, object>
277 {
278 { "error", "invalid_grant" },
279 { "error_description", "The provided value for the 'client_assertion' parameter is not valid." }
280 };
281 var errorResponseContent = JsonSerializer.Serialize(errorResponse, new JsonSerializerOptions()
282 {
283 WriteIndented = true,
284 IndentSize = 2,
285 DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
286 });
287
288 var mockMessageHandler = new Mock<HttpMessageHandler>();
289 mockMessageHandler.Protected()
290 .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
291 .ReturnsAsync(new HttpResponseMessage
292 {
293 StatusCode = HttpStatusCode.BadRequest,
294 Content = new StringContent(errorResponseContent, Encoding.UTF8, "application/json"),
295 });
296 var httpClient = new Common.Http.HttpClient(new System.Net.Http.HttpClient(mockMessageHandler.Object));
297 HttpRequest request = HttpRequest.Get("https://www.microsoft.com");
298
299 // Act & Assert
300 var ex = await Assert.ThrowsAsync<HttpException>(async () => await httpClient.SendAsync(request));
301
302 var expectedSubmitException = "Exception of type 'Microsoft.Teams.Common.Http.HttpException' was thrown.";
303 Assert.Equal(expectedSubmitException, ex.Message);
304 Assert.Equal(HttpStatusCode.BadRequest, ex.StatusCode);
305 Assert.NotNull(ex.Body);
306 Assert.Equal(errorResponseContent.ToString(), ex.ToString());
307 }
308
309 [Fact]
310 public async Task HttpClient_ShouldThrowException_WhenResponseIsNotSuccess_WithPlainTextContent()
311 {
312 // Arrange
313 var errorResponseContent = "Invalid request";
314
315 var mockMessageHandler = new Mock<HttpMessageHandler>();
316 mockMessageHandler.Protected()
317 .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
318 .ReturnsAsync(new HttpResponseMessage
319 {
320 StatusCode = HttpStatusCode.BadRequest,
321 Content = new StringContent(errorResponseContent, Encoding.UTF8, "text/plain"),
322 });
323 var httpClient = new Common.Http.HttpClient(new System.Net.Http.HttpClient(mockMessageHandler.Object));
324 HttpRequest request = HttpRequest.Get("https://www.microsoft.com");
325
326 // Act & Assert
327 var ex = await Assert.ThrowsAsync<HttpException>(async () => await httpClient.SendAsync(request));
328
329 var expectedSubmitException = "Exception of type 'Microsoft.Teams.Common.Http.HttpException' was thrown.";
330 Assert.Equal(expectedSubmitException, ex.Message);
331 Assert.Equal(HttpStatusCode.BadRequest, ex.StatusCode);
332 Assert.NotNull(ex.Body);
333 Assert.Equal(errorResponseContent, ex.ToString());
334 }
335
336 [Fact]
337 public async Task HttpClient_ShouldThrowException_WhenResponseObjectIsNotSuccess()
338 {
339 var errorResponse = new Dictionary<string, object>
340 {
341 { "error", "invalid_grant" },
342 { "error_description", "The provided value for the 'client_assertion' parameter is not valid." }
343 };
344 var errorResponseJson = JsonSerializer.Serialize(errorResponse, new JsonSerializerOptions()
345 {
346 WriteIndented = true,
347 IndentSize = 2,
348 DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull
349 });
350 var mockMessageHandler = new Mock<HttpMessageHandler>();
351 mockMessageHandler.Protected()
352 .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
353 .ReturnsAsync(new HttpResponseMessage
354 {
355 StatusCode = HttpStatusCode.BadRequest,
356 Content = new StringContent(errorResponseJson, Encoding.UTF8, "application/json"),
357 });
358 var httpClient = new Common.Http.HttpClient(new System.Net.Http.HttpClient(mockMessageHandler.Object));
359 HttpRequest request = HttpRequest.Get("https://www.microsoft.com");
360
361
362 // Act & Assert
363 var ex = await Assert.ThrowsAsync<HttpException>(async () => await httpClient.SendAsync<UrlResponse>(request));
364
365 var expectedSubmitException = "Exception of type 'Microsoft.Teams.Common.Http.HttpException' was thrown.";
366 Assert.Equal(expectedSubmitException, ex.Message);
367 Assert.Equal(HttpStatusCode.BadRequest, ex.StatusCode);
368 Assert.NotNull(ex.Body);
369 Assert.Equal(errorResponseJson.ToString(), ex.ToString());
370 }
371}