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
copilot/sub-pr-338

Branches

Tags

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

Clone

HTTPS

Download ZIP

teams.net/core/test/Microsoft.Teams.Bot.Core.UnitTests

core/test/Microsoft.Teams.Bot.Core.UnitTests/ConversationClientTests.cs

345lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4using System.Net;
5using Microsoft.Extensions.Logging;
6using Microsoft.Extensions.Logging.Abstractions;
7using Microsoft.Teams.Bot.Core.Schema;
8using Moq;
9using Moq.Protected;
10
11namespace Microsoft.Teams.Bot.Core.UnitTests;
12
13public class ConversationClientTests
14{
15 [Fact]
16 public async Task SendActivityAsync_WithValidActivity_SendsSuccessfully()
17 {
18 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
19 mockHttpMessageHandler
20 .Protected()
21 .Setup<Task<HttpResponseMessage>>(
22 "SendAsync",
23 ItExpr.IsAny<HttpRequestMessage>(),
24 ItExpr.IsAny<CancellationToken>())
25 .ReturnsAsync(new HttpResponseMessage
26 {
27 StatusCode = HttpStatusCode.OK,
28 Content = new StringContent("{\"id\":\"activity123\"}")
29 });
30
31 HttpClient httpClient = new(mockHttpMessageHandler.Object);
32 ConversationClient conversationClient = new(httpClient);
33
34 CoreActivity activity = new()
35 {
36 Type = ActivityType.Message,
37 Conversation = new Conversation { Id = "conv123" },
38 ServiceUrl = new Uri("https://test.service.url/")
39 };
40
41 var result = await conversationClient.SendActivityAsync(activity);
42
43 Assert.NotNull(result);
44 Assert.Contains("activity123", result.Id);
45 }
46
47 [Fact]
48 public async Task SendActivityAsync_WithNullActivity_ThrowsArgumentNullException()
49 {
50 HttpClient httpClient = new();
51 ConversationClient conversationClient = new(httpClient);
52
53 await Assert.ThrowsAsync<ArgumentNullException>(() =>
54 conversationClient.SendActivityAsync(null!));
55 }
56
57 [Fact]
58 public async Task SendActivityAsync_WithNullConversation_ThrowsArgumentNullException()
59 {
60 HttpClient httpClient = new();
61 ConversationClient conversationClient = new(httpClient);
62
63 CoreActivity activity = new()
64 {
65 Type = ActivityType.Message,
66 ServiceUrl = new Uri("https://test.service.url/")
67 };
68
69 await Assert.ThrowsAsync<ArgumentException>(() =>
70 conversationClient.SendActivityAsync(activity));
71 }
72
73 [Fact]
74 public async Task SendActivityAsync_WithNullConversationId_ThrowsArgumentNullException()
75 {
76 HttpClient httpClient = new();
77 ConversationClient conversationClient = new(httpClient);
78
79 CoreActivity activity = new()
80 {
81 Type = ActivityType.Message,
82 Conversation = new Conversation() { Id = null! },
83 ServiceUrl = new Uri("https://test.service.url/")
84 }; ;
85
86 await Assert.ThrowsAsync<ArgumentNullException>(() =>
87 conversationClient.SendActivityAsync(activity));
88 }
89
90 [Fact]
91 public async Task SendActivityAsync_WithNullServiceUrl_ThrowsArgumentNullException()
92 {
93 HttpClient httpClient = new();
94 ConversationClient conversationClient = new(httpClient);
95
96 CoreActivity activity = new()
97 {
98 Type = ActivityType.Message,
99 Conversation = new Conversation { Id = "conv123" }
100 };
101
102 await Assert.ThrowsAsync<ArgumentNullException>(() =>
103 conversationClient.SendActivityAsync(activity));
104 }
105
106 [Fact]
107 public async Task SendActivityAsync_WithHttpError_ThrowsHttpRequestException()
108 {
109 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
110 mockHttpMessageHandler
111 .Protected()
112 .Setup<Task<HttpResponseMessage>>(
113 "SendAsync",
114 ItExpr.IsAny<HttpRequestMessage>(),
115 ItExpr.IsAny<CancellationToken>())
116 .ReturnsAsync(new HttpResponseMessage
117 {
118 StatusCode = HttpStatusCode.BadRequest,
119 Content = new StringContent("Bad request error")
120 });
121
122 HttpClient httpClient = new(mockHttpMessageHandler.Object);
123 ConversationClient conversationClient = new(httpClient);
124
125 CoreActivity activity = new()
126 {
127 Type = ActivityType.Message,
128 Conversation = new Conversation { Id = "conv123" },
129 ServiceUrl = new Uri("https://test.service.url/")
130 };
131
132 HttpRequestException exception = await Assert.ThrowsAsync<HttpRequestException>(() =>
133 conversationClient.SendActivityAsync(activity));
134
135 Assert.Contains("Error sending activity", exception.Message);
136 Assert.Contains("BadRequest", exception.Message);
137 }
138
139 [Fact]
140 public async Task SendActivityAsync_ConstructsCorrectUrl()
141 {
142 HttpRequestMessage? capturedRequest = null;
143 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
144 mockHttpMessageHandler
145 .Protected()
146 .Setup<Task<HttpResponseMessage>>(
147 "SendAsync",
148 ItExpr.IsAny<HttpRequestMessage>(),
149 ItExpr.IsAny<CancellationToken>())
150 .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
151 .ReturnsAsync(new HttpResponseMessage
152 {
153 StatusCode = HttpStatusCode.OK,
154 Content = new StringContent("{\"id\":\"activity123\"}")
155 });
156
157 HttpClient httpClient = new(mockHttpMessageHandler.Object);
158 ConversationClient conversationClient = new(httpClient);
159
160 CoreActivity activity = new()
161 {
162 Type = ActivityType.Message,
163 Conversation = new Conversation { Id = "conv123" },
164 ServiceUrl = new Uri("https://test.service.url/")
165 };
166
167 await conversationClient.SendActivityAsync(activity);
168
169 Assert.NotNull(capturedRequest);
170 Assert.Equal("https://test.service.url/v3/conversations/conv123/activities/", capturedRequest.RequestUri?.ToString());
171 Assert.Equal(HttpMethod.Post, capturedRequest.Method);
172 }
173
174 [Fact]
175 public async Task SendActivityAsync_WithIsTargeted_AppendsQueryString()
176 {
177 HttpRequestMessage? capturedRequest = null;
178 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
179 mockHttpMessageHandler
180 .Protected()
181 .Setup<Task<HttpResponseMessage>>(
182 "SendAsync",
183 ItExpr.IsAny<HttpRequestMessage>(),
184 ItExpr.IsAny<CancellationToken>())
185 .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
186 .ReturnsAsync(new HttpResponseMessage
187 {
188 StatusCode = HttpStatusCode.OK,
189 Content = new StringContent("{\"id\":\"activity123\"}")
190 });
191
192 HttpClient httpClient = new(mockHttpMessageHandler.Object);
193 ConversationClient conversationClient = new(httpClient);
194
195 CoreActivity activity = new()
196 {
197 Type = ActivityType.Message,
198 Conversation = new Conversation { Id = "conv123" },
199 ServiceUrl = new Uri("https://test.service.url/"),
200 IsTargeted = true
201 };
202
203 await conversationClient.SendActivityAsync(activity);
204
205 Assert.NotNull(capturedRequest);
206 Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
207 }
208
209 [Fact]
210 public async Task SendActivityAsync_WithIsTargetedFalse_DoesNotAppendQueryString()
211 {
212 HttpRequestMessage? capturedRequest = null;
213 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
214 mockHttpMessageHandler
215 .Protected()
216 .Setup<Task<HttpResponseMessage>>(
217 "SendAsync",
218 ItExpr.IsAny<HttpRequestMessage>(),
219 ItExpr.IsAny<CancellationToken>())
220 .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
221 .ReturnsAsync(new HttpResponseMessage
222 {
223 StatusCode = HttpStatusCode.OK,
224 Content = new StringContent("{\"id\":\"activity123\"}")
225 });
226
227 HttpClient httpClient = new(mockHttpMessageHandler.Object);
228 ConversationClient conversationClient = new(httpClient);
229
230 CoreActivity activity = new()
231 {
232 Type = ActivityType.Message,
233 Conversation = new Conversation { Id = "conv123" },
234 ServiceUrl = new Uri("https://test.service.url/"),
235 IsTargeted = false
236 };
237
238 await conversationClient.SendActivityAsync(activity);
239
240 Assert.NotNull(capturedRequest);
241 Assert.DoesNotContain("isTargetedActivity", capturedRequest.RequestUri?.ToString());
242 }
243
244 [Fact]
245 public async Task UpdateActivityAsync_WithIsTargeted_AppendsQueryString()
246 {
247 HttpRequestMessage? capturedRequest = null;
248 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
249 mockHttpMessageHandler
250 .Protected()
251 .Setup<Task<HttpResponseMessage>>(
252 "SendAsync",
253 ItExpr.IsAny<HttpRequestMessage>(),
254 ItExpr.IsAny<CancellationToken>())
255 .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
256 .ReturnsAsync(new HttpResponseMessage
257 {
258 StatusCode = HttpStatusCode.OK,
259 Content = new StringContent("{\"id\":\"activity123\"}")
260 });
261
262 HttpClient httpClient = new(mockHttpMessageHandler.Object);
263 ConversationClient conversationClient = new(httpClient, NullLogger<ConversationClient>.Instance);
264
265 CoreActivity activity = new()
266 {
267 Type = ActivityType.Message,
268 ServiceUrl = new Uri("https://test.service.url/"),
269 IsTargeted = true
270 };
271
272 await conversationClient.UpdateActivityAsync("conv123", "activity123", activity);
273
274 Assert.NotNull(capturedRequest);
275 Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
276 Assert.Equal(HttpMethod.Put, capturedRequest.Method);
277 }
278
279 [Fact]
280 public async Task DeleteActivityAsync_WithIsTargeted_AppendsQueryString()
281 {
282 HttpRequestMessage? capturedRequest = null;
283 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
284 mockHttpMessageHandler
285 .Protected()
286 .Setup<Task<HttpResponseMessage>>(
287 "SendAsync",
288 ItExpr.IsAny<HttpRequestMessage>(),
289 ItExpr.IsAny<CancellationToken>())
290 .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
291 .ReturnsAsync(new HttpResponseMessage
292 {
293 StatusCode = HttpStatusCode.OK
294 });
295
296 HttpClient httpClient = new(mockHttpMessageHandler.Object);
297 ConversationClient conversationClient = new(httpClient, NullLogger<ConversationClient>.Instance);
298
299 await conversationClient.DeleteActivityAsync(
300 "conv123",
301 "activity123",
302 new Uri("https://test.service.url/"),
303 isTargeted: true);
304
305 Assert.NotNull(capturedRequest);
306 Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
307 Assert.Equal(HttpMethod.Delete, capturedRequest.Method);
308 }
309
310 [Fact]
311 public async Task DeleteActivityAsync_WithActivity_UsesIsTargetedProperty()
312 {
313 HttpRequestMessage? capturedRequest = null;
314 Mock<HttpMessageHandler> mockHttpMessageHandler = new();
315 mockHttpMessageHandler
316 .Protected()
317 .Setup<Task<HttpResponseMessage>>(
318 "SendAsync",
319 ItExpr.IsAny<HttpRequestMessage>(),
320 ItExpr.IsAny<CancellationToken>())
321 .Callback<HttpRequestMessage, CancellationToken>((req, ct) => capturedRequest = req)
322 .ReturnsAsync(new HttpResponseMessage
323 {
324 StatusCode = HttpStatusCode.OK
325 });
326
327 HttpClient httpClient = new(mockHttpMessageHandler.Object);
328 ConversationClient conversationClient = new(httpClient, NullLogger<ConversationClient>.Instance);
329
330 CoreActivity activity = new()
331 {
332 Id = "activity123",
333 Type = ActivityType.Message,
334 Conversation = new Conversation { Id = "conv123" },
335 ServiceUrl = new Uri("https://test.service.url/"),
336 IsTargeted = true
337 };
338
339 await conversationClient.DeleteActivityAsync(activity);
340
341 Assert.NotNull(capturedRequest);
342 Assert.Contains("isTargetedActivity=true", capturedRequest.RequestUri?.ToString());
343 Assert.Equal(HttpMethod.Delete, capturedRequest.Method);
344 }
345}
346