GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/teams.net

Public

mirrored from https://github.com/microsoft/teams.netAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
copilot/move-activity-implementations

Branches

Tags

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

Clone

HTTPS

Download ZIP

teams.net/Tests/Microsoft.Teams.Api.Tests/Clients

Tests/Microsoft.Teams.Api.Tests/Clients/ActivityClientTests.cs

353lines · modecode

RawDownload
Latest commit unavailable.
1using System.Net;
2using System.Text.Json;
3
4using Microsoft.Teams.Api.Clients;
5using Microsoft.Teams.Common.Http;
6
7using Moq;
8
9using static Microsoft.Teams.Api.Activities.Invokes.Configs;
10
11namespace Microsoft.Teams.Api.Tests.Clients;
12
13public class ActivityClientTests
14{
15 [Fact]
16 public async Task ActivityClient_CreateAsync()
17 {
18 Resource responseResource = new Resource() { Id = "activityId" };
19
20 var responseMessage = new HttpResponseMessage();
21 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
22 var responseBody = new Resource() { Id = "activityId" };
23 var mockHandler = new Mock<IHttpClient>();
24 mockHandler
25 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
26 .ReturnsAsync(new HttpResponse<string>()
27 {
28 Body = JsonSerializer.Serialize(responseResource, new JsonSerializerOptions { WriteIndented = true }),
29 Headers = responseMessage.Headers,
30 StatusCode = HttpStatusCode.OK
31 });
32
33 string serviceUrl = "https://serviceurl.com/";
34 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
35 string conversationId = "conversationId";
36 var value = new Cards.HeroCard()
37 {
38 Title = "test card",
39 SubTitle = "test fetch config activity"
40 };
41 var activity = new FetchActivity(value);
42 var response = await activityClient.CreateAsync(conversationId, activity);
43
44 Assert.Equal(responseResource.Id, response!.Id);
45 string expecteUrl = "https://serviceurl.com/v3/conversations/conversationId/activities";
46 HttpMethod expectedMethod = HttpMethod.Post;
47 mockHandler.Verify(x => x.SendAsync(
48 It.Is<IHttpRequest>(arg => arg.Url == expecteUrl && arg.Method == expectedMethod),
49 It.IsAny<CancellationToken>()),
50 Times.Once);
51 }
52
53
54 [Fact]
55 public async Task ActivityClient_CreateAsync_NullResponse()
56 {
57 var responseMessage = new HttpResponseMessage();
58 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
59 var responseBody = new Resource() { Id = "activityId" };
60 var mockHandler = new Mock<IHttpClient>();
61 mockHandler
62 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
63 .ReturnsAsync(new HttpResponse<string>()
64 {
65 Body = String.Empty,
66 Headers = responseMessage.Headers,
67 StatusCode = HttpStatusCode.OK
68 });
69
70 string serviceUrl = "https://serviceurl.com/";
71 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
72 string conversationId = "conversationId";
73 var value = new Cards.HeroCard()
74 {
75 Title = "test card",
76 SubTitle = "test fetch config activity"
77 };
78 var activity = new FetchActivity(value);
79 var response = await activityClient.CreateAsync(conversationId, activity);
80
81 Assert.Null(response);
82 string expecteUrl = "https://serviceurl.com/v3/conversations/conversationId/activities";
83 HttpMethod expectedMethod = HttpMethod.Post;
84 mockHandler.Verify(x => x.SendAsync(
85 It.Is<IHttpRequest>(arg => arg.Url == expecteUrl && arg.Method == expectedMethod),
86 It.IsAny<CancellationToken>()),
87 Times.Once);
88 }
89
90
91 [Fact]
92 public async Task ActivityClient_UpdateAsync()
93 {
94 Resource responseResource = new Resource() { Id = "activityId" };
95
96 var responseMessage = new HttpResponseMessage();
97 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
98 var responseBody = new Resource() { Id = "activityId" };
99 var mockHandler = new Mock<IHttpClient>();
100 mockHandler
101 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
102 .ReturnsAsync(new HttpResponse<string>()
103 {
104 Body = JsonSerializer.Serialize(responseResource, new JsonSerializerOptions { WriteIndented = true }),
105 Headers = responseMessage.Headers,
106 StatusCode = HttpStatusCode.OK
107 });
108
109 string serviceUrl = "https://serviceurl.com/";
110 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
111 string conversationId = "conversationId";
112 var value = new Cards.HeroCard()
113 {
114 Title = "test card",
115 SubTitle = "test fetch config activity"
116 };
117 var activity = new FetchActivity(value);
118 var response = await activityClient.UpdateAsync(conversationId, responseResource.Id, activity);
119
120 Assert.Equal(responseResource.Id, response!.Id);
121 string expecteUrl = "https://serviceurl.com/v3/conversations/conversationId/activities/activityId";
122 HttpMethod expectedMethod = HttpMethod.Put;
123 mockHandler.Verify(x => x.SendAsync(
124 It.Is<IHttpRequest>(arg => arg.Url == expecteUrl && arg.Method == expectedMethod),
125 It.IsAny<CancellationToken>()),
126 Times.Once);
127 }
128
129
130 [Fact]
131 public async Task ActivityClient_ReplyAsync()
132 {
133 Resource responseResource = new Resource() { Id = "activityId" };
134
135 var responseMessage = new HttpResponseMessage();
136 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
137 var responseBody = new Resource() { Id = "activityId" };
138 var mockHandler = new Mock<IHttpClient>();
139 mockHandler
140 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
141 .ReturnsAsync(new HttpResponse<string>()
142 {
143 Body = JsonSerializer.Serialize(responseResource, new JsonSerializerOptions { WriteIndented = true }),
144 Headers = responseMessage.Headers,
145 StatusCode = HttpStatusCode.OK
146 });
147
148 string serviceUrl = "https://serviceurl.com/";
149 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
150 string conversationId = "conversationId";
151 var value = new Cards.HeroCard()
152 {
153 Title = "test card",
154 SubTitle = "test fetch config activity"
155 };
156 var activity = new FetchActivity(value);
157 var response = await activityClient.ReplyAsync(conversationId, responseResource.Id, activity);
158
159 Assert.Equal(responseResource.Id, response!.Id);
160 string expecteUrl = "https://serviceurl.com/v3/conversations/conversationId/activities/activityId";
161 HttpMethod expectedMethod = HttpMethod.Post;
162 mockHandler.Verify(x => x.SendAsync(
163 It.Is<IHttpRequest>(arg => arg.Url == expecteUrl && arg.Method == expectedMethod),
164 It.IsAny<CancellationToken>()),
165 Times.Once);
166 }
167
168 [Fact]
169 public async Task ActivityClient_DeleteAsync()
170 {
171 Resource responseResource = new Resource() { Id = "activityId" };
172
173 var responseMessage = new HttpResponseMessage();
174 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
175 var responseBody = new Resource() { Id = "activityId" };
176 var mockHandler = new Mock<IHttpClient>();
177 mockHandler
178 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
179 .ReturnsAsync(new HttpResponse<string>()
180 {
181 Body = String.Empty,
182 Headers = responseMessage.Headers,
183 StatusCode = HttpStatusCode.OK
184 });
185
186 string serviceUrl = "https://serviceurl.com/";
187 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
188 string conversationId = "conversationId";
189 var value = new Cards.HeroCard()
190 {
191 Title = "test card",
192 SubTitle = "test fetch config activity"
193 };
194 var activity = new FetchActivity(value);
195 await activityClient.DeleteAsync(conversationId, responseResource.Id);
196
197 string expecteUrl = "https://serviceurl.com/v3/conversations/conversationId/activities/activityId";
198 HttpMethod expectedMethod = HttpMethod.Delete;
199 mockHandler.Verify(x => x.SendAsync(
200 It.Is<IHttpRequest>(arg => arg.Url == expecteUrl && arg.Method == expectedMethod),
201 It.IsAny<CancellationToken>()),
202 Times.Once);
203 }
204
205 [Fact]
206 public async Task ActivityClient_CreateAsync_WithTargeted()
207 {
208 Resource responseResource = new Resource() { Id = "activityId" };
209
210 using (var responseMessage = new HttpResponseMessage())
211 {
212 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
213 var mockHandler = new Mock<IHttpClient>();
214 mockHandler
215 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
216 .ReturnsAsync(new HttpResponse<string>()
217 {
218 Body = JsonSerializer.Serialize(responseResource, new JsonSerializerOptions { WriteIndented = true }),
219 Headers = responseMessage.Headers,
220 StatusCode = HttpStatusCode.OK
221 });
222
223 string serviceUrl = "https://serviceurl.com/";
224 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
225 string conversationId = "conversationId";
226 var value = new Cards.HeroCard()
227 {
228 Title = "test card",
229 SubTitle = "test targeted activity"
230 };
231 var activity = new FetchActivity(value);
232 var response = await activityClient.CreateAsync(conversationId, activity, isTargeted: true);
233
234 Assert.Equal(responseResource.Id, response!.Id);
235 string expectedUrl = "https://serviceurl.com/v3/conversations/conversationId/activities?isTargetedActivity=true";
236 HttpMethod expectedMethod = HttpMethod.Post;
237 mockHandler.Verify(x => x.SendAsync(
238 It.Is<IHttpRequest>(arg => arg.Url == expectedUrl && arg.Method == expectedMethod),
239 It.IsAny<CancellationToken>()),
240 Times.Once);
241 }
242 }
243
244 [Fact]
245 public async Task ActivityClient_UpdateAsync_WithTargeted()
246 {
247 Resource responseResource = new Resource() { Id = "activityId" };
248
249 using (var responseMessage = new HttpResponseMessage())
250 {
251 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
252 var mockHandler = new Mock<IHttpClient>();
253 mockHandler
254 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
255 .ReturnsAsync(new HttpResponse<string>()
256 {
257 Body = JsonSerializer.Serialize(responseResource, new JsonSerializerOptions { WriteIndented = true }),
258 Headers = responseMessage.Headers,
259 StatusCode = HttpStatusCode.OK
260 });
261
262 string serviceUrl = "https://serviceurl.com/";
263 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
264 string conversationId = "conversationId";
265 var value = new Cards.HeroCard()
266 {
267 Title = "test card",
268 SubTitle = "test targeted update activity"
269 };
270 var activity = new FetchActivity(value);
271 var response = await activityClient.UpdateAsync(conversationId, responseResource.Id, activity, isTargeted: true);
272
273 Assert.Equal(responseResource.Id, response!.Id);
274 string expectedUrl = "https://serviceurl.com/v3/conversations/conversationId/activities/activityId?isTargetedActivity=true";
275 HttpMethod expectedMethod = HttpMethod.Put;
276 mockHandler.Verify(x => x.SendAsync(
277 It.Is<IHttpRequest>(arg => arg.Url == expectedUrl && arg.Method == expectedMethod),
278 It.IsAny<CancellationToken>()),
279 Times.Once);
280 }
281 }
282
283 [Fact]
284 public async Task ActivityClient_ReplyAsync_WithTargeted()
285 {
286 Resource responseResource = new Resource() { Id = "activityId" };
287
288 using (var responseMessage = new HttpResponseMessage())
289 {
290 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
291 var mockHandler = new Mock<IHttpClient>();
292 mockHandler
293 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
294 .ReturnsAsync(new HttpResponse<string>()
295 {
296 Body = JsonSerializer.Serialize(responseResource, new JsonSerializerOptions { WriteIndented = true }),
297 Headers = responseMessage.Headers,
298 StatusCode = HttpStatusCode.OK
299 });
300
301 string serviceUrl = "https://serviceurl.com/";
302 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
303 string conversationId = "conversationId";
304 var value = new Cards.HeroCard()
305 {
306 Title = "test card",
307 SubTitle = "test targeted reply activity"
308 };
309 var activity = new FetchActivity(value);
310 var response = await activityClient.ReplyAsync(conversationId, responseResource.Id, activity, isTargeted: true);
311
312 Assert.Equal(responseResource.Id, response!.Id);
313 string expectedUrl = "https://serviceurl.com/v3/conversations/conversationId/activities/activityId?isTargetedActivity=true";
314 HttpMethod expectedMethod = HttpMethod.Post;
315 mockHandler.Verify(x => x.SendAsync(
316 It.Is<IHttpRequest>(arg => arg.Url == expectedUrl && arg.Method == expectedMethod),
317 It.IsAny<CancellationToken>()),
318 Times.Once);
319 }
320 }
321
322 [Fact]
323 public async Task ActivityClient_DeleteAsync_WithTargeted()
324 {
325 Resource responseResource = new Resource() { Id = "activityId" };
326
327 using (var responseMessage = new HttpResponseMessage())
328 {
329 responseMessage.Headers.Add("Custom-Header", "HeaderValue");
330 var mockHandler = new Mock<IHttpClient>();
331 mockHandler
332 .Setup(handler => handler.SendAsync(It.IsAny<IHttpRequest>(), It.IsAny<CancellationToken>()))
333 .ReturnsAsync(new HttpResponse<string>()
334 {
335 Body = String.Empty,
336 Headers = responseMessage.Headers,
337 StatusCode = HttpStatusCode.OK
338 });
339
340 string serviceUrl = "https://serviceurl.com/";
341 var activityClient = new ActivityClient(serviceUrl, mockHandler.Object);
342 string conversationId = "conversationId";
343 await activityClient.DeleteAsync(conversationId, responseResource.Id, isTargeted: true);
344
345 string expectedUrl = "https://serviceurl.com/v3/conversations/conversationId/activities/activityId?isTargetedActivity=true";
346 HttpMethod expectedMethod = HttpMethod.Delete;
347 mockHandler.Verify(x => x.SendAsync(
348 It.Is<IHttpRequest>(arg => arg.Url == expectedUrl && arg.Method == expectedMethod),
349 It.IsAny<CancellationToken>()),
350 Times.Once);
351 }
352 }
353}