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 ExecutorRole testDstRole = COLLECTOR;
48 std::vector<uint8_t> message = {1, 2, 4, 6};
49 std::shared_ptr<AuthMessage> testMsg = AuthMessage::As(message);
50 EXPECT_NE(testMsg, nullptr);
51
52 sptr<ExecutorMessengerInterface> testMessenger(nullptr);
53 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
54 EXPECT_NE(service, nullptr);
55 int32_t result = service->SendData(testScheduleId, testDstRole, testMsg);
56 EXPECT_EQ(result, GENERAL_ERROR);
57 }
58
59 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestSendData002, TestSize.Level0)
60 {
61 uint64_t testScheduleId = 6598;
62 ExecutorRole testDstRole = COLLECTOR;
63 std::shared_ptr<AuthMessage> testMsg = nullptr;
64
65 sptr<MockExecutorMessengerService> testMessenger(new (std::nothrow) MockExecutorMessengerService());
66 EXPECT_NE(testMessenger, nullptr);
67 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
68 EXPECT_NE(service, nullptr);
69 int32_t result = service->SendData(testScheduleId, testDstRole, testMsg);
70 EXPECT_EQ(result, GENERAL_ERROR);
71 }
72
73 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestSendData003, TestSize.Level0)
74 {
75 uint64_t testScheduleId = 6598;
76 ExecutorRole testDstRole = COLLECTOR;
77 std::vector<uint8_t> message = {1, 2, 4, 6};
78 std::shared_ptr<AuthMessage> testMsg = AuthMessage::As(message);
79 EXPECT_NE(testMsg, nullptr);
80
81 sptr<MockExecutorMessengerService> testMessenger(new (std::nothrow) MockExecutorMessengerService());
82 EXPECT_NE(testMessenger, nullptr);
83 EXPECT_CALL(*testMessenger, SendData(_, _, _)).Times(1);
84 ON_CALL(*testMessenger, SendData)
85 .WillByDefault(
86 [&testScheduleId, &testDstRole, &message](uint64_t scheduleId, ExecutorRole dstRole,
__anonce557f7a0102(uint64_t scheduleId, ExecutorRole dstRole, const std::vector<uint8_t> &msg) 87 const std::vector<uint8_t> &msg) {
88 EXPECT_EQ(scheduleId, testScheduleId);
89 EXPECT_THAT(msg, ElementsAreArray(message));
90 return SUCCESS;
91 }
92 );
93 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
94 EXPECT_NE(service, nullptr);
95 int32_t result = service->SendData(testScheduleId, testDstRole, testMsg);
96 EXPECT_EQ(result, SUCCESS);
97 }
98
99 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestFinish001, TestSize.Level0)
100 {
101 uint64_t testScheduleId = 6598;
102 int32_t testResultCode = FAIL;
103 Attributes finalResult;
104
105 sptr<ExecutorMessengerInterface> testMessenger(nullptr);
106 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
107 EXPECT_NE(service, nullptr);
108 int32_t result = service->Finish(testScheduleId, testResultCode, finalResult);
109 EXPECT_EQ(result, GENERAL_ERROR);
110 }
111
112 HWTEST_F(ExecutorMessengerClientTest, ExecutorMessengerClientTestFinish002, TestSize.Level0)
113 {
114 uint64_t testScheduleId = 6598;
115 int32_t testResultCode = FAIL;
116 Attributes finalResult;
117
118 sptr<MockExecutorMessengerService> testMessenger(new (std::nothrow) MockExecutorMessengerService());
119 EXPECT_NE(testMessenger, nullptr);
120 EXPECT_CALL(*testMessenger, Finish(_, _, _)).Times(1);
121 ON_CALL(*testMessenger, Finish)
122 .WillByDefault(
123 [&testScheduleId, &testResultCode](uint64_t scheduleId, ResultCode resultCode,
__anonce557f7a0202(uint64_t scheduleId, ResultCode resultCode, const std::shared_ptr<Attributes> &finalResult) 124 const std::shared_ptr<Attributes> &finalResult) {
125 EXPECT_EQ(scheduleId, testScheduleId);
126 EXPECT_EQ(resultCode, testResultCode);
127 return SUCCESS;
128 }
129 );
130 auto service = Common::MakeShared<ExecutorMessengerClient>(testMessenger);
131 int32_t result = service->Finish(testScheduleId, testResultCode, finalResult);
132 EXPECT_EQ(result, SUCCESS);
133 }
134 } // namespace UserAuth
135 } // namespace UserIam
136 } // namespace OHOS