1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
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 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "executor_messenger_client_test.h"
17
18 #include "executor_messenger_client.h"
19 #include "iam_ptr.h"
20 #include "mock_executor_messenger_service.h"
21
22 namespace OHOS {
23 namespace UserIam {
24 namespace UserAuth {
25 using namespace testing;
26 using namespace testing::ext;
27
SetUpTestCase()28 void ExecutorMessengerClientTest::SetUpTestCase()
29 {
30 }
31
TearDownTestCase()32 void ExecutorMessengerClientTest::TearDownTestCase()
33 {
34 }
35
SetUp()36 void ExecutorMessengerClientTest::SetUp()
37 {
38 }
39
TearDown()40 void ExecutorMessengerClientTest::TearDown()
41 {
42 }
43
44 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestSendData001, TestSize.Level0)
45 {
46 uint64_t testScheduleId = 6598;
47 uint64_t testTransNum = 8784;
48 ExecutorRole testSrcRole = SCHEDULER;
49 ExecutorRole testDstRole = COLLECTOR;
50 std::vector<uint8_t> message = {1, 2, 4, 6};
51 std::shared_ptr<AuthMessage> testMsg = AuthMessage::As(message);
52 EXPECT_NE(testMsg, nullptr);
53
54 sptr<ExecutorMessengerInterface> testMessenger = nullptr;
55 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
56 EXPECT_NE(service, nullptr);
57 int32_t result = service->SendData(testScheduleId, testTransNum, testSrcRole, testDstRole, testMsg);
58 EXPECT_EQ(result, GENERAL_ERROR);
59 }
60
61 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestSendData002, TestSize.Level0)
62 {
63 uint64_t testScheduleId = 6598;
64 uint64_t testTransNum = 8784;
65 ExecutorRole testSrcRole = SCHEDULER;
66 ExecutorRole testDstRole = COLLECTOR;
67 std::shared_ptr<AuthMessage> testMsg = nullptr;
68
69 sptr<MockExecutorMessengerService> testMessenger = new MockExecutorMessengerService();
70 EXPECT_NE(testMessenger, nullptr);
71 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
72 EXPECT_NE(service, nullptr);
73 int32_t result = service->SendData(testScheduleId, testTransNum, testSrcRole, testDstRole, testMsg);
74 EXPECT_EQ(result, GENERAL_ERROR);
75 }
76
77 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestSendData003, TestSize.Level0)
78 {
79 uint64_t testScheduleId = 6598;
80 uint64_t testTransNum = 8784;
81 ExecutorRole testSrcRole = SCHEDULER;
82 ExecutorRole testDstRole = COLLECTOR;
83 std::vector<uint8_t> message = {1, 2, 4, 6};
84 std::shared_ptr<AuthMessage> testMsg = AuthMessage::As(message);
85 EXPECT_NE(testMsg, nullptr);
86
87 sptr<MockExecutorMessengerService> testMessenger = new MockExecutorMessengerService();
88 EXPECT_NE(testMessenger, nullptr);
89 EXPECT_CALL(*testMessenger, SendData(_, _, _, _, _)).Times(1);
90 ON_CALL(*testMessenger, SendData)
91 .WillByDefault(
92 [&testScheduleId, &testTransNum, &testSrcRole, &testDstRole, &message](uint64_t scheduleId,
__anon513fddc20102(uint64_t scheduleId, uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::vector<uint8_t> &msg) 93 uint64_t transNum, ExecutorRole srcRole, ExecutorRole dstRole, const std::vector<uint8_t> &msg) {
94 EXPECT_EQ(scheduleId, testScheduleId);
95 EXPECT_EQ(transNum, testTransNum);
96 EXPECT_EQ(srcRole, testSrcRole);
97 EXPECT_EQ(dstRole, testDstRole);
98 EXPECT_THAT(msg, ElementsAreArray(message));
99 return SUCCESS;
100 }
101 );
102 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
103 EXPECT_NE(service, nullptr);
104 int32_t result = service->SendData(testScheduleId, testTransNum, testSrcRole, testDstRole, testMsg);
105 EXPECT_EQ(result, SUCCESS);
106 }
107
108 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestFinish001, TestSize.Level0)
109 {
110 uint64_t testScheduleId = 6598;
111 ExecutorRole testSrcRole = SCHEDULER;
112 int32_t testResultCode = FAIL;
113 Attributes finalResult;
114
115 sptr<ExecutorMessengerInterface> testMessenger = nullptr;
116 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
117 EXPECT_NE(service, nullptr);
118 int32_t result = service->Finish(testScheduleId, testSrcRole, testResultCode, finalResult);
119 EXPECT_EQ(result, GENERAL_ERROR);
120 }
121
122 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestFinish002, TestSize.Level0)
123 {
124 uint64_t testScheduleId = 6598;
125 ExecutorRole testSrcRole = SCHEDULER;
126 int32_t testResultCode = FAIL;
127 Attributes finalResult;
128
129 sptr<MockExecutorMessengerService> testMessenger = new MockExecutorMessengerService();
130 EXPECT_NE(testMessenger, nullptr);
131 EXPECT_CALL(*testMessenger, Finish(_, _, _, _)).Times(1);
132 ON_CALL(*testMessenger, Finish)
133 .WillByDefault(
134 [&testScheduleId, &testSrcRole, &testResultCode](uint64_t scheduleId, ExecutorRole srcRole,
__anon513fddc20202(uint64_t scheduleId, ExecutorRole srcRole, ResultCode resultCode, const std::shared_ptr<Attributes> &finalResult) 135 ResultCode resultCode, const std::shared_ptr<Attributes> &finalResult) {
136 EXPECT_EQ(scheduleId, testScheduleId);
137 EXPECT_EQ(srcRole, testSrcRole);
138 EXPECT_EQ(resultCode, testResultCode);
139 return SUCCESS;
140 }
141 );
142 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
143 int32_t result = service->Finish(testScheduleId, testSrcRole, testResultCode, finalResult);
144 EXPECT_EQ(result, SUCCESS);
145 }
146 } // namespace UserAuth
147 } // namespace UserIam
148 } // namespace OHOS