Skip to content

Commit 3247b03

Browse files
wptestyyhwptestyyh
authored
Implement RfAttenuator gRPC tests based on software simulated attenuator (#340)
1 parent 6b249c6 commit 3247b03

File tree

2 files changed

+302
-0
lines changed

2 files changed

+302
-0
lines changed

‎tests/unit/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ add_executable(${PROJECT_NAME}-test-unit)
1010
target_sources(${PROJECT_NAME}-test-unit
1111
PRIVATE
1212
${CMAKE_CURRENT_LIST_DIR}/Main.cxx
13+
${CMAKE_CURRENT_LIST_DIR}/NetRemoteRfAttenuatorServiceClient.cxx
1314
${CMAKE_CURRENT_LIST_DIR}/TestNetRemoteCommon.cxx
1415
${CMAKE_CURRENT_LIST_DIR}/TestNetRemoteServer.cxx
1516
${CMAKE_CURRENT_LIST_DIR}/TestNetRemoteServiceClient.cxx

‎tests/unit/NetRemoteRfAttenuatorServiceClient.cxx‎

Lines changed: 301 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,301 @@
1+
#include <plog/Log.h>
2+
3+
#include <catch2/catch_test_macros.hpp>
4+
#include <grpcpp/client_context.h>
5+
#include <grpcpp/create_channel.h>
6+
#include <grpcpp/impl/codegen/status.h>
7+
#include <grpcpp/security/credentials.h>
8+
9+
#include <microsoft/net/remote/protocol/NetRemoteRfAttenuator.grpc.pb.h>
10+
#include <microsoft/net/remote/protocol/NetRemoteRfAttenuatorService.grpc.pb.h>
11+
#include <microsoft/net/remote/service/NetRemoteServer.hxx>
12+
13+
#include "TestNetRemoteCommon.hxx"
14+
15+
using namespace Microsoft::Net::Remote::Test;
16+
using namespace Microsoft::Net::Remote::Service;
17+
using namespace Microsoft::Net::Remote;
18+
using namespace Microsoft::Net::Remote::RfAttenuator;
19+
20+
TEST_CASE("RfAttenuator IsEnabled API", "[basic][rpc][client][remote][rfAttenuator]")
21+
{
22+
SECTION("IsEnabled is true")
23+
{
24+
auto serverConfiguration = CreateServerConfiguration();
25+
serverConfiguration.RfAttenuatorConfiguration.Type = RfAttenuatorType::Software;
26+
NetRemoteServer server{ serverConfiguration };
27+
server.Run();
28+
29+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
30+
auto client = NetRemoteRfAttenuator::NewStub(channel);
31+
32+
LOGI << "gRPC initialized";
33+
34+
const google::protobuf::Empty request{};
35+
google::protobuf::BoolValue result{};
36+
grpc::ClientContext clientContext{};
37+
38+
auto status = client->IsEnabled(&clientContext, request, &result);
39+
REQUIRE(status.ok());
40+
REQUIRE(result.value());
41+
}
42+
43+
SECTION("IsEnabled is false")
44+
{
45+
// serverConfiguration.RfAttenuatorConfiguration.Type is RfAttenuatorType::None by default
46+
auto serverConfiguration = CreateServerConfiguration();
47+
NetRemoteServer server{ serverConfiguration };
48+
server.Run();
49+
50+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
51+
auto client = NetRemoteRfAttenuator::NewStub(channel);
52+
53+
LOGI << "gRPC initialized";
54+
55+
const google::protobuf::Empty request{};
56+
google::protobuf::BoolValue result{};
57+
grpc::ClientContext clientContext{};
58+
59+
auto status = client->IsEnabled(&clientContext, request, &result);
60+
REQUIRE(!status.ok());
61+
REQUIRE(status.error_code() == grpc::StatusCode::UNIMPLEMENTED);
62+
REQUIRE(!result.value());
63+
}
64+
}
65+
66+
TEST_CASE("RfAttenuator Reset API", "[basic][rpc][client][remote][rfAttenuator]")
67+
{
68+
SECTION("Reset succeeds when RfAttenuatorType is Software")
69+
{
70+
auto serverConfiguration = CreateServerConfiguration();
71+
serverConfiguration.RfAttenuatorConfiguration.Type = RfAttenuatorType::Software;
72+
NetRemoteServer server{ serverConfiguration };
73+
server.Run();
74+
75+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
76+
auto client = NetRemoteRfAttenuator::NewStub(channel);
77+
78+
LOGI << "gRPC initialized";
79+
80+
const google::protobuf::Empty request{};
81+
ResetResult result{};
82+
grpc::ClientContext clientContext{};
83+
84+
auto status = client->Reset(&clientContext, request, &result);
85+
REQUIRE(status.ok());
86+
REQUIRE(result.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeSucceeded);
87+
}
88+
89+
SECTION("Reset fails when RfAttenuatorType is None")
90+
{
91+
// serverConfiguration.RfAttenuatorConfiguration.Type is RfAttenuatorType::None by default
92+
auto serverConfiguration = CreateServerConfiguration();
93+
NetRemoteServer server{ serverConfiguration };
94+
server.Run();
95+
96+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
97+
auto client = NetRemoteRfAttenuator::NewStub(channel);
98+
99+
LOGI << "gRPC initialized";
100+
101+
const google::protobuf::Empty request{};
102+
ResetResult result{};
103+
grpc::ClientContext clientContext{};
104+
105+
auto status = client->Reset(&clientContext, request, &result);
106+
REQUIRE(!status.ok());
107+
REQUIRE(status.error_code() == grpc::StatusCode::UNIMPLEMENTED);
108+
REQUIRE(result.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeUnknown);
109+
}
110+
}
111+
112+
TEST_CASE("RfAttenuator GetProperties API", "[basic][rpc][client][remote][rfAttenuator]")
113+
{
114+
SECTION("GetProperties succeeds when RfAttenuatorType is Software")
115+
{
116+
auto serverConfiguration = CreateServerConfiguration();
117+
serverConfiguration.RfAttenuatorConfiguration.Type = RfAttenuatorType::Software;
118+
NetRemoteServer server{ serverConfiguration };
119+
server.Run();
120+
121+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
122+
auto client = NetRemoteRfAttenuator::NewStub(channel);
123+
124+
LOGI << "gRPC initialized";
125+
126+
const google::protobuf::Empty request{};
127+
GetPropertiesResult result{};
128+
grpc::ClientContext clientContext{};
129+
130+
auto status = client->GetProperties(&clientContext, request, &result);
131+
REQUIRE(status.ok());
132+
REQUIRE(result.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeSucceeded);
133+
REQUIRE(!result.identification().empty());
134+
}
135+
136+
SECTION("GetProperties fails when RfAttenuatorType is None")
137+
{
138+
// serverConfiguration.RfAttenuatorConfiguration.Type is RfAttenuatorType::None by default
139+
auto serverConfiguration = CreateServerConfiguration();
140+
NetRemoteServer server{ serverConfiguration };
141+
server.Run();
142+
143+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
144+
auto client = NetRemoteRfAttenuator::NewStub(channel);
145+
146+
LOGI << "gRPC initialized";
147+
148+
const google::protobuf::Empty request{};
149+
GetPropertiesResult result{};
150+
grpc::ClientContext clientContext{};
151+
152+
auto status = client->GetProperties(&clientContext, request, &result);
153+
REQUIRE(!status.ok());
154+
REQUIRE(status.error_code() == grpc::StatusCode::UNIMPLEMENTED);
155+
REQUIRE(result.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeUnknown);
156+
}
157+
}
158+
159+
TEST_CASE("RfAttenuator GetAttenuationForChannel and SetAttenuationForChannel API", "[basic][rpc][client][remote][rfAttenuator]")
160+
{
161+
SECTION("Get and Set attenuation succeeds when RfAttenuatorType is Software")
162+
{
163+
auto serverConfiguration = CreateServerConfiguration();
164+
serverConfiguration.RfAttenuatorConfiguration.Type = RfAttenuatorType::Software;
165+
NetRemoteServer server{ serverConfiguration };
166+
server.Run();
167+
168+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
169+
auto client = NetRemoteRfAttenuator::NewStub(channel);
170+
171+
LOGI << "gRPC initialized";
172+
173+
uint32_t attenuatorChannel = 1;
174+
auto attenuationDbm = 10.0;
175+
SetAttenuationRequest setAttenuationRequest{};
176+
setAttenuationRequest.set_channel(attenuatorChannel);
177+
setAttenuationRequest.set_attenuationdbm(attenuationDbm);
178+
SetAttenuationResult setAttenuationResult{};
179+
grpc::ClientContext setClientContext{};
180+
181+
GetAttenuationRequest getAttenuationRequest{};
182+
getAttenuationRequest.set_channel(attenuatorChannel);
183+
GetAttenuationResult getAttenuationResult{};
184+
grpc::ClientContext getClientContext{};
185+
186+
auto status = client->SetAttenuationForChannel(&setClientContext, setAttenuationRequest, &setAttenuationResult);
187+
REQUIRE(status.ok());
188+
REQUIRE(setAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeSucceeded);
189+
190+
status = client->GetAttenuationForChannel(&getClientContext, getAttenuationRequest, &getAttenuationResult);
191+
REQUIRE(status.ok());
192+
REQUIRE(getAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeSucceeded);
193+
REQUIRE(getAttenuationResult.attenuationdbm() == attenuationDbm);
194+
}
195+
196+
SECTION("Get and Set attenuation fails when RfAttenuatorType is None")
197+
{
198+
// serverConfiguration.RfAttenuatorConfiguration.Type is RfAttenuatorType::None by default
199+
auto serverConfiguration = CreateServerConfiguration();
200+
NetRemoteServer server{ serverConfiguration };
201+
server.Run();
202+
203+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
204+
auto client = NetRemoteRfAttenuator::NewStub(channel);
205+
206+
LOGI << "gRPC initialized";
207+
208+
uint32_t attenuatorChannel = 1;
209+
auto attenuationDbm = 10.0;
210+
SetAttenuationRequest setAttenuationRequest{};
211+
setAttenuationRequest.set_channel(attenuatorChannel);
212+
setAttenuationRequest.set_attenuationdbm(attenuationDbm);
213+
SetAttenuationResult setAttenuationResult{};
214+
grpc::ClientContext setClientContext{};
215+
216+
GetAttenuationRequest getAttenuationRequest{};
217+
getAttenuationRequest.set_channel(attenuatorChannel);
218+
GetAttenuationResult getAttenuationResult{};
219+
grpc::ClientContext getClientContext{};
220+
221+
auto status = client->SetAttenuationForChannel(&setClientContext, setAttenuationRequest, &setAttenuationResult);
222+
REQUIRE(!status.ok());
223+
REQUIRE(status.error_code() == grpc::StatusCode::UNIMPLEMENTED);
224+
REQUIRE(setAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeUnknown);
225+
226+
status = client->GetAttenuationForChannel(&getClientContext, getAttenuationRequest, &getAttenuationResult);
227+
REQUIRE(!status.ok());
228+
REQUIRE(status.error_code() == grpc::StatusCode::UNIMPLEMENTED);
229+
REQUIRE(getAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeUnknown);
230+
}
231+
232+
SECTION("Get and Set attenuation fails when attenuation channel is wrong")
233+
{
234+
auto serverConfiguration = CreateServerConfiguration();
235+
serverConfiguration.RfAttenuatorConfiguration.Type = RfAttenuatorType::Software;
236+
NetRemoteServer server{ serverConfiguration };
237+
server.Run();
238+
239+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
240+
auto client = NetRemoteRfAttenuator::NewStub(channel);
241+
242+
LOGI << "gRPC initialized";
243+
244+
uint32_t attenuatorChannel = UINT32_MAX;
245+
auto attenuationDbm = 10.0;
246+
SetAttenuationRequest setAttenuationRequest{};
247+
setAttenuationRequest.set_channel(attenuatorChannel);
248+
setAttenuationRequest.set_attenuationdbm(attenuationDbm);
249+
SetAttenuationResult setAttenuationResult{};
250+
grpc::ClientContext setClientContext{};
251+
252+
GetAttenuationRequest getAttenuationRequest{};
253+
getAttenuationRequest.set_channel(attenuatorChannel);
254+
GetAttenuationResult getAttenuationResult{};
255+
grpc::ClientContext getClientContext{};
256+
257+
auto status = client->SetAttenuationForChannel(&setClientContext, setAttenuationRequest, &setAttenuationResult);
258+
REQUIRE(status.ok());
259+
REQUIRE(setAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeFailed);
260+
261+
status = client->GetAttenuationForChannel(&getClientContext, getAttenuationRequest, &getAttenuationResult);
262+
REQUIRE(status.ok());
263+
REQUIRE(getAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeFailed);
264+
}
265+
266+
SECTION("Get and Set attenuation fails when attenuation dbm is wrong")
267+
{
268+
auto serverConfiguration = CreateServerConfiguration();
269+
serverConfiguration.RfAttenuatorConfiguration.Type = RfAttenuatorType::Software;
270+
NetRemoteServer server{ serverConfiguration };
271+
server.Run();
272+
273+
auto channel = grpc::CreateChannel(RemoteServiceAddressHttp, grpc::InsecureChannelCredentials());
274+
auto client = NetRemoteRfAttenuator::NewStub(channel);
275+
276+
LOGI << "gRPC initialized";
277+
278+
uint32_t attenuatorChannel = 1;
279+
auto attenuationDbm = UINT32_MAX;
280+
SetAttenuationRequest setAttenuationRequest{};
281+
setAttenuationRequest.set_channel(attenuatorChannel);
282+
setAttenuationRequest.set_attenuationdbm(attenuationDbm);
283+
SetAttenuationResult setAttenuationResult{};
284+
grpc::ClientContext setClientContext{};
285+
286+
GetAttenuationRequest getAttenuationRequest{};
287+
getAttenuationRequest.set_channel(attenuatorChannel);
288+
GetAttenuationResult getAttenuationResult{};
289+
grpc::ClientContext getClientContext{};
290+
291+
auto status = client->SetAttenuationForChannel(&setClientContext, setAttenuationRequest, &setAttenuationResult);
292+
REQUIRE(status.ok());
293+
REQUIRE(setAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeFailed);
294+
295+
status = client->GetAttenuationForChannel(&getClientContext, getAttenuationRequest, &getAttenuationResult);
296+
REQUIRE(status.ok());
297+
REQUIRE(getAttenuationResult.status().code() == RfAttenuatorOperationStatusCode::RfAttenuatorOperationStatusCodeSucceeded);
298+
// SetAttenuationForChannel failed, so attenuationdbm should be the default 0.0
299+
REQUIRE(getAttenuationResult.attenuationdbm() == 0.0);
300+
}
301+
}

0 commit comments

Comments
 (0)