Skip to content

Commit cb065f2

Browse files
WhitWaldoWhitWaldo
authored
Fixed unit tests validating actor reminder deserialization
Updated unit tests for actor reminder deserialization
1 parent 19fd403 commit cb065f2

File tree

1 file changed

+148
-140
lines changed

1 file changed

+148
-140
lines changed

‎test/Dapr.Actors.Test/Runtime/DefaultActorTimerManagerTests.cs

+148-140
Original file line numberDiff line numberDiff line change
@@ -1,173 +1,181 @@
1-
// ------------------------------------------------------------
1+
// ------------------------------------------------------------------------
2+
// Copyright 2025 The Dapr Authors
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
// http://www.apache.org/licenses/LICENSE-2.0
7+
// Unless required by applicable law or agreed to in writing, software
8+
// distributed under the License is distributed on an "AS IS" BASIS,
9+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10+
// See the License for the specific language governing permissions and
11+
// limitations under the License.
12+
// ------------------------------------------------------------------------
13+
14+
// ------------------------------------------------------------
215
// Copyright (c) Microsoft Corporation.
316
// Licensed under the MIT License.
417
// ------------------------------------------------------------
518

619
using System;
7-
using System.IO;
820
using System.Net;
921
using System.Net.Http;
10-
using System.Runtime.CompilerServices;
1122
using System.Text.Json;
1223
using System.Threading;
1324
using System.Threading.Tasks;
14-
using Dapr.Actors.Serialization;
1525
using Moq;
1626
using Xunit;
1727
using JsonSerializer = System.Text.Json.JsonSerializer;
1828

19-
namespace Dapr.Actors.Runtime
29+
namespace Dapr.Actors.Runtime;
30+
31+
public sealed class DefaultActorTimerManagerTests
2032
{
21-
public sealed class DefaultActorTimerManagerTests
33+
/// <summary>
34+
/// When register reminder is called, interactor is called with correct data.
35+
/// </summary>
36+
/// <returns></returns>
37+
[Fact]
38+
public async Task RegisterReminderAsync_CallsInteractor_WithCorrectData()
2239
{
23-
/// <summary>
24-
/// When register reminder is called, interactor is called with correct data.
25-
/// </summary>
26-
/// <returns></returns>
27-
[Fact]
28-
public async Task RegisterReminderAsync_CallsInteractor_WithCorrectData()
29-
{
30-
var actorId = "123";
31-
var actorType = "abc";
32-
var interactor = new Mock<TestDaprInteractor>();
33-
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
34-
var actorReminder = new ActorReminder(actorType, new ActorId(actorId), "remindername", new byte[] { }, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
35-
var actualData = string.Empty;
40+
var actorId = "123";
41+
var actorType = "abc";
42+
var interactor = new Mock<TestDaprInteractor>();
43+
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
44+
var actorReminder = new ActorReminder(actorType, new ActorId(actorId), "remindername", Array.Empty<byte>(), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
45+
var actualData = string.Empty;
3646

37-
interactor
38-
.Setup(d => d.RegisterReminderAsync(actorType, actorId, "remindername", It.Is<string>(data => !string.IsNullOrEmpty(data)), It.IsAny<CancellationToken>()))
39-
.Callback<string, string, string, string, CancellationToken>((actorType, actorID, reminderName, data, token) => {
40-
actualData = data;
41-
})
42-
.Returns(Task.CompletedTask);
47+
interactor
48+
.Setup(d => d.RegisterReminderAsync(actorType, actorId, "remindername", It.Is<string>(data => !string.IsNullOrEmpty(data)), It.IsAny<CancellationToken>()))
49+
.Callback<string, string, string, string, CancellationToken>((innerType, innerId, reminderName, data, token) => {
50+
actualData = data;
51+
})
52+
.Returns(Task.CompletedTask);
4353

44-
await defaultActorTimerManager.RegisterReminderAsync(actorReminder);
54+
await defaultActorTimerManager.RegisterReminderAsync(actorReminder);
4555

46-
JsonElement json = JsonSerializer.Deserialize<dynamic>(actualData);
56+
JsonElement json = JsonSerializer.Deserialize<dynamic>(actualData);
4757

48-
var isPeriodSet = json.TryGetProperty("period", out var period);
49-
var isdDueTimeSet = json.TryGetProperty("dueTime", out var dueTime);
58+
var isPeriodSet = json.TryGetProperty("period", out var period);
59+
var isdDueTimeSet = json.TryGetProperty("dueTime", out var dueTime);
5060

51-
Assert.True(isPeriodSet);
52-
Assert.True(isdDueTimeSet);
61+
Assert.True(isPeriodSet);
62+
Assert.True(isdDueTimeSet);
5363

54-
Assert.Equal("0h1m0s0ms", period.GetString());
55-
Assert.Equal("0h1m0s0ms", dueTime.GetString());
56-
}
57-
58-
/// <summary>
59-
/// When register reminder is called with repetition, interactor is called with correct data.
60-
/// </summary>
61-
/// <returns></returns>
62-
[Fact]
63-
public async Task RegisterReminderAsync_WithRepetition_CallsInteractor_WithCorrectData()
64-
{
65-
var actorId = "123";
66-
var actorType = "abc";
67-
var interactor = new Mock<TestDaprInteractor>();
68-
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
69-
var actorReminder = new ActorReminder(actorType, new ActorId(actorId), "remindername", new byte[] { }, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), 10);
70-
var actualData = string.Empty;
71-
72-
interactor
73-
.Setup(d => d.RegisterReminderAsync(actorType, actorId, "remindername", It.Is<string>(data => !string.IsNullOrEmpty(data)), It.IsAny<CancellationToken>()))
74-
.Callback<string, string, string, string, CancellationToken>((actorType, actorID, reminderName, data, token) => {
75-
actualData = data;
76-
})
77-
.Returns(Task.CompletedTask);
78-
79-
await defaultActorTimerManager.RegisterReminderAsync(actorReminder);
80-
81-
JsonElement json = JsonSerializer.Deserialize<dynamic>(actualData);
82-
83-
var isPeriodSet = json.TryGetProperty("period", out var period);
84-
var isdDueTimeSet = json.TryGetProperty("dueTime", out var dueTime);
64+
Assert.Equal("0h1m0s0ms", period.GetString());
65+
Assert.Equal("0h1m0s0ms", dueTime.GetString());
66+
}
67+
68+
/// <summary>
69+
/// When register reminder is called with repetition, interactor is called with correct data.
70+
/// </summary>
71+
/// <returns></returns>
72+
[Fact]
73+
public async Task RegisterReminderAsync_WithRepetition_CallsInteractor_WithCorrectData()
74+
{
75+
const string actorId = "123";
76+
const string actorType = "abc";
77+
var interactor = new Mock<TestDaprInteractor>();
78+
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
79+
var actorReminder = new ActorReminder(actorType, new ActorId(actorId), "remindername", new byte[] { }, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), 10);
80+
var actualData = string.Empty;
81+
82+
interactor
83+
.Setup(d => d.RegisterReminderAsync(actorType, actorId, "remindername", It.Is<string>(data => !string.IsNullOrEmpty(data)), It.IsAny<CancellationToken>()))
84+
.Callback<string, string, string, string, CancellationToken>((innerType, innerActorId, reminderName, data, token) => {
85+
actualData = data;
86+
})
87+
.Returns(Task.CompletedTask);
88+
89+
await defaultActorTimerManager.RegisterReminderAsync(actorReminder);
90+
91+
JsonElement json = JsonSerializer.Deserialize<dynamic>(actualData);
92+
93+
var isPeriodSet = json.TryGetProperty("period", out var period);
94+
var isdDueTimeSet = json.TryGetProperty("dueTime", out var dueTime);
8595

86-
Assert.True(isPeriodSet);
87-
Assert.True(isdDueTimeSet);
96+
Assert.True(isPeriodSet);
97+
Assert.True(isdDueTimeSet);
8898

89-
Assert.Equal("R10/PT1M", period.GetString());
90-
Assert.Equal("0h1m0s0ms", dueTime.GetString());
91-
}
92-
93-
/// <summary>
94-
/// Get the GetReminder method is called without a registered reminder, it should return null.
95-
/// </summary>
96-
[Fact]
97-
public async Task GetReminderAsync_ReturnsNullWhenUnavailable()
98-
{
99-
const string actorId = "123";
100-
const string actorType = "abc";
101-
const string reminderName = "reminderName";
102-
var interactor = new Mock<TestDaprInteractor>();
103-
interactor
104-
.Setup(d => d.GetReminderAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
105-
It.IsAny<CancellationToken>()))
106-
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.InternalServerError));
107-
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
108-
109-
var reminderResult = await defaultActorTimerManager.GetReminderAsync(new ActorReminderToken(actorType, new ActorId(actorId), reminderName));
110-
Assert.Null(reminderResult);
111-
}
99+
Assert.Equal("R10/PT1M", period.GetString());
100+
Assert.Equal("0h1m0s0ms", dueTime.GetString());
101+
}
102+
103+
/// <summary>
104+
/// Get the GetReminder method is called without a registered reminder, it should return null.
105+
/// </summary>
106+
[Fact]
107+
public async Task GetReminderAsync_ReturnsNullWhenUnavailable()
108+
{
109+
const string actorId = "123";
110+
const string actorType = "abc";
111+
const string reminderName = "reminderName";
112+
var interactor = new Mock<TestDaprInteractor>();
113+
interactor
114+
.Setup(d => d.GetReminderAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
115+
It.IsAny<CancellationToken>()))
116+
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.InternalServerError));
117+
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
118+
119+
var reminderResult = await defaultActorTimerManager.GetReminderAsync(new ActorReminderToken(actorType, new ActorId(actorId), reminderName));
120+
Assert.Null(reminderResult);
121+
}
112122

113-
[Fact]
114-
public async Task GetReminderAsync_ReturnsNullWhenDeserialziationFails()
115-
{
116-
const string actorId = "123";
117-
const string actorType = "abc";
118-
const string reminderName = "reminderName";
119-
var interactor = new Mock<TestDaprInteractor>();
120-
var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}") };
123+
[Fact]
124+
public async Task GetReminderAsync_ReturnsNullWhenDeserialziationFails()
125+
{
126+
const string actorId = "123";
127+
const string actorType = "abc";
128+
const string reminderName = "reminderName";
129+
var interactor = new Mock<TestDaprInteractor>();
130+
var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("{}") };
121131

122-
interactor
123-
.Setup(d => d.GetReminderAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
124-
It.IsAny<CancellationToken>()))
125-
.ReturnsAsync(response);
126-
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
127-
128-
var reminderResult = await defaultActorTimerManager.GetReminderAsync(new ActorReminderToken(actorType, new ActorId(actorId), reminderName));
129-
Assert.Null(reminderResult);
130-
}
131-
132-
[Fact]
133-
public async Task GetReminderAsync_ReturnsResultWhenAvailable()
134-
{
135-
const string actorId = "123";
136-
const string actorType = "abc";
137-
const string reminderName = "reminderName";
138-
var interactor = new Mock<TestDaprInteractor>();
132+
interactor
133+
.Setup(d => d.GetReminderAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(),
134+
It.IsAny<CancellationToken>()))
135+
.ReturnsAsync(response);
136+
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
137+
138+
var reminderResult = await defaultActorTimerManager.GetReminderAsync(new ActorReminderToken(actorType, new ActorId(actorId), reminderName));
139+
Assert.Null(reminderResult);
140+
}
141+
142+
[Fact]
143+
public async Task GetReminderAsync_ReturnsResultWhenAvailable()
144+
{
145+
const string actorId = "123";
146+
const string actorType = "abc";
147+
const string reminderName = "reminderName";
148+
var interactor = new Mock<TestDaprInteractor>();
139149

140-
//Create the reminder we'll return
141-
var state = Array.Empty<byte>();
142-
var dueTime = TimeSpan.FromMinutes(1);
143-
var period = TimeSpan.FromMinutes(1);
144-
var actorReminder = new ActorReminder(actorType, new ActorId(actorId), "remindername", state, dueTime, period, 10);
150+
//Create the reminder we'll return
151+
var state = Array.Empty<byte>();
152+
var dueTime = TimeSpan.FromMinutes(1);
153+
var period = TimeSpan.FromMinutes(1);
154+
var actorReminder = new ActorReminder(actorType, new ActorId(actorId), "remindername", state, dueTime, period, 10);
145155

146-
//Serialize and create the response value
147-
var actorReminderInfo = new ReminderInfo(actorReminder.State, actorReminder.DueTime, actorReminder.Period,
148-
actorReminder.Repetitions, actorReminder.Ttl);
149-
var serializedActorReminderInfo = await actorReminderInfo.SerializeAsync();
150-
var reminderResponse = new HttpResponseMessage(HttpStatusCode.OK)
151-
{
152-
Content = new StringContent(serializedActorReminderInfo)
153-
};
156+
//Serialize and create the response value
157+
var actorReminderInfo = new ReminderInfo(actorReminder.State, actorReminder.DueTime, actorReminder.Period,
158+
actorReminder.Repetitions, actorReminder.Ttl);
159+
var serializedActorReminderInfo = await actorReminderInfo.SerializeAsync();
160+
var reminderResponse = new HttpResponseMessage(HttpStatusCode.OK)
161+
{
162+
Content = new StringContent(serializedActorReminderInfo)
163+
};
154164

155-
//Register the response
156-
var actualData = string.Empty;
157-
interactor
158-
.Setup(d => d.GetReminderAsync(actorType, actorId, reminderName, It.IsAny<CancellationToken>()))
159-
.Callback<string, string, string, CancellationToken>((type, id, name, token) => {
160-
})
161-
.Returns(Task.FromResult(reminderResponse));
162-
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
165+
//Register the response
166+
interactor
167+
.Setup(d => d.GetReminderAsync(actorType, actorId, reminderName, It.IsAny<CancellationToken>()))
168+
.Callback<string, string, string, CancellationToken>((type, id, name, token) => {
169+
})
170+
.Returns(Task.FromResult(reminderResponse));
171+
var defaultActorTimerManager = new DefaultActorTimerManager(interactor.Object);
163172

164-
var reminderResult = await defaultActorTimerManager.GetReminderAsync(new ActorReminderToken(actorType, new ActorId(actorId), reminderName));
165-
Assert.NotNull(reminderResult);
173+
var reminderResult = await defaultActorTimerManager.GetReminderAsync(new ActorReminderToken(actorType, new ActorId(actorId), reminderName));
174+
Assert.NotNull(reminderResult);
166175

167-
Assert.Equal(period, reminderResult.Period);
168-
Assert.Equal(state, reminderResult.State);
169-
Assert.Equal(period, reminderResult.Period);
170-
Assert.Equal(reminderName, reminderResult.Name);
171-
}
176+
Assert.Equal(dueTime, reminderResult.DueTime);
177+
Assert.Equal(state, reminderResult.State);
178+
Assert.Equal(period, reminderResult.Period);
179+
Assert.Equal(reminderName, reminderResult.Name);
172180
}
173181
}

0 commit comments

Comments
 (0)