From 0d4479e1294b6d5717c5b15e53aa8bd7f5c1e175 Mon Sep 17 00:00:00 2001 From: "Zhangyao(Maggie)" Date: Fri, 3 Jan 2025 14:42:44 +0800 Subject: [PATCH] UT for session conflict Signed-off-by: Zhangyao(Maggie) --- .../backup_kit_inner/impl/b_session_restore.h | 10 ++ .../b_session_backup_mock.cpp | 12 ++ .../b_session_restore_mock.cpp | 12 ++ .../backup_impl/service_proxy_test.cpp | 86 +++++++++ .../module_ipc/service_incremental_test.cpp | 31 ++++ .../module_ipc/service_stub_test.cpp | 141 +++++++++++++++ .../backup_sa/module_ipc/service_test.cpp | 2 + .../module_ipc/service_throw_test.cpp | 169 ++++++++++++++++++ .../session/b_incremental_session_test.cpp | 70 +++++++- .../backup_sa/session/service_proxy_mock.h | 2 + 10 files changed, 534 insertions(+), 1 deletion(-) diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h index c831dead3..55c4a1906 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h +++ b/interfaces/inner_api/native/backup_kit_inner/impl/b_session_restore.h @@ -47,6 +47,16 @@ public: */ static std::unique_ptr Init(Callbacks callbacks); + /** + * @brief 获取一个用于控制恢复流程的会话 + * + * @param callbacks 注册的回调函数 + * @param errMsg 失败信息 + * @param errCode 错误码 + * @return std::unique_ptr 指向BRestoreSession的智能指针。失败时为空指针 + */ + static std::unique_ptr Init(Callbacks callbacks, std::string &errMsg, ErrCode &errCode); + /** * @brief 通知备份服务文件内容已就绪 * diff --git a/tests/mock/backup_kit_inner/b_session_backup_mock.cpp b/tests/mock/backup_kit_inner/b_session_backup_mock.cpp index 0fe6a3e7c..4747e383f 100644 --- a/tests/mock/backup_kit_inner/b_session_backup_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_backup_mock.cpp @@ -46,6 +46,18 @@ unique_ptr BSessionBackup::Init(Callbacks callbacks) return nullptr; } +unique_ptr BSessionBackup::Init(Callbacks callbacks, std::string &errMsg, ErrCode &errCode) +{ + try { + callbacks_ = callbacks; + auto backup = make_unique(); + return backup; + } catch (const exception &e) { + return nullptr; + } + return nullptr; +} + void BSessionBackup::RegisterBackupServiceDied(function functor) {} ErrCode BSessionBackup::Start() diff --git a/tests/mock/backup_kit_inner/b_session_restore_mock.cpp b/tests/mock/backup_kit_inner/b_session_restore_mock.cpp index 164500fe3..268190807 100644 --- a/tests/mock/backup_kit_inner/b_session_restore_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_restore_mock.cpp @@ -47,6 +47,18 @@ unique_ptr BSessionRestore::Init(Callbacks callbacks) return nullptr; } +unique_ptr BSessionRestore::Init(Callbacks callbacks, std::string &errMsg, ErrCode &errCode) +{ + try { + callbacks_ = move(callbacks); + auto restore = make_unique(); + return restore; + } catch (const exception &e) { + return nullptr; + } + return nullptr; +} + ErrCode BSessionRestore::PublishFile(BFileInfo fileInfo) { return BError(BError::Codes::OK); diff --git a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp index d1fb27bb8..ee2de7234 100644 --- a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp @@ -90,6 +90,34 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitRestoreSession_0100, testing::e GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitRestoreSession_0100"; } +/** + * @tc.number: SUB_Service_proxy_InitRestoreSession_0200 + * @tc.name: SUB_Service_proxy_InitRestoreSession_0200 + * @tc.desc: 测试 InitRestoreSession 注册restore Session with errMsg接口调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitRestoreSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitRestoreSession_0200"; + std::string errMsg; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_InitRestoreSession_0200 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(1) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeMsgSendRequest)); + int32_t result = proxy_->InitRestoreSession(remote_, errMsg); + EXPECT_EQ(result, BError(BError::Codes::OK)); + + result = proxy_->InitRestoreSession(nullptr, errMsg); + EXPECT_NE(result, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitRestoreSession_0200"; +} + /** * @tc.number: SUB_Service_proxy_InitBackupSession_0100 * @tc.name: SUB_Service_proxy_InitBackupSession_0100 @@ -118,6 +146,35 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitBackupSession_0100, testing::ex GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitBackupSession_0100"; } +/** + * @tc.number: SUB_Service_proxy_InitBackupSession_0200 + * @tc.name: SUB_Service_proxy_InitBackupSession_0200 + * @tc.desc: 测试 InitBackupSession 注册backup Session with errMsg接口调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitBackupSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitBackupSession_0200"; + std::string errMsg; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_InitBackupSession_0200 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(1) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeMsgSendRequest)); + + int32_t result = proxy_->InitBackupSession(remote_, errMsg); + EXPECT_EQ(result, BError(BError::Codes::OK)); + + result = proxy_->InitBackupSession(nullptr, errMsg); + EXPECT_NE(result, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitBackupSession_0100"; +} + /** * @tc.number: SUB_Service_proxy_Start_0100 * @tc.name: SUB_Service_proxy_Start_0100 @@ -597,6 +654,35 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitIncrementalBackupSession_0100, GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitIncrementalBackupSession_0100"; } +/** + * @tc.number: SUB_Service_proxy_InitIncrementalBackupSession_0200 + * @tc.name: SUB_Service_proxy_InitIncrementalBackupSession_0200 + * @tc.desc: 测试 InitIncrementalBackupSession with errMsg接口调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I90ZV5 + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_InitIncrementalBackupSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_InitIncrementalBackupSession_0200"; + std::string errMsg; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_InitIncrementalBackupSession_0200 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(1) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeMsgSendRequest)); + + int32_t result = proxy_->InitIncrementalBackupSession(remote_, errMsg); + EXPECT_EQ(result, BError(BError::Codes::OK)); + + result = proxy_->InitIncrementalBackupSession(nullptr, errMsg); + EXPECT_NE(result, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_InitIncrementalBackupSession_0200"; +} + /** * @tc.number: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100 * @tc.name: SUB_Service_proxy_AppendBundlesIncrementalBackupSession_0100 diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp index b087868c1..534a8fbf6 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -522,6 +522,37 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSes GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_InitIncrementalBackupSession_0000"; } +/** + * @tc.number: SUB_ServiceIncremental_InitIncrementalBackupSession_0100 + * @tc.name: SUB_ServiceIncremental_InitIncrementalBackupSession_0100 + * @tc.desc: 测试 InitIncrementalBackupSession with errMsg的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_InitIncrementalBackupSession_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_InitIncrementalBackupSession_0100"; + try { + std::string errMsg; + auto session_ = service->session_; + service->session_ = nullptr; + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), + BError(BError::Codes::SA_INVAL_ARG).GetCode()); + service->session_ = session_; + + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()).WillOnce(Return(make_pair(false, 0))); + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*session, Active(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_EQ(service->InitIncrementalBackupSession(nullptr, errMsg), BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by InitIncrementalBackupSession."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_InitIncrementalBackupSession_0100"; +} + /** * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000 * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000 diff --git a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp index ce27e56c4..a6821679d 100644 --- a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp @@ -207,6 +207,53 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitRestoreSession_0100, tes GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitRestoreSession_0100"; } +/** + * @tc.number: SUB_backup_sa_ServiceStub_InitRestoreSession_0200 + * @tc.name: SUB_backup_sa_ServiceStub_InitRestoreSession_0200 + * @tc.desc: Test function of InitRestoreSession with errMsg interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitRestoreSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitRestoreSession_0200"; + try { + MessageParcel data; + MessageParcel reply; + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr)); + EXPECT_TRUE(service != nullptr); + auto err = service->CmdInitRestoreSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr)); + err = service->CmdInitRestoreSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitRestoreSession(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + err = service->CmdInitRestoreSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitRestoreSession(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdInitRestoreSessionMsg(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitRestoreSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitRestoreSession_0200"; +} + /** * @tc.number: SUB_backup_sa_ServiceStub_InitBackupSession_0100 * @tc.name: SUB_backup_sa_ServiceStub_InitBackupSession_0100 @@ -252,6 +299,53 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitBackupSession_0100, test GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitBackupSession_0100"; } +/** + * @tc.number: SUB_backup_sa_ServiceStub_InitBackupSession_0200 + * @tc.name: SUB_backup_sa_ServiceStub_InitBackupSession_0200 + * @tc.desc: Test function of InitBackupSession with errMsg interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitBackupSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitBackupSession_0200"; + try { + MessageParcel data; + MessageParcel reply; + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr)); + EXPECT_TRUE(service != nullptr); + auto err = service->CmdInitBackupSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr)); + err = service->CmdInitBackupSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitBackupSession(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + err = service->CmdInitBackupSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitBackupSession(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdInitBackupSessionMsg(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitBackupSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitBackupSession_0200"; +} + /** * @tc.number: SUB_backup_sa_ServiceStub_Start_0100 * @tc.name: SUB_backup_sa_ServiceStub_Start_0100 @@ -1058,6 +1152,53 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitIncrementalBackupSession GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100"; } +/** + * @tc.number: SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0200 + * @tc.name: SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0200 + * @tc.desc: Test function of InitIncrementalBackupSession with errMsg interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0200"; + try { + MessageParcel data; + MessageParcel reply; + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr)); + EXPECT_TRUE(service != nullptr); + auto err = service->CmdInitIncrementalBackupSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr)); + err = service->CmdInitIncrementalBackupSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitIncrementalBackupSession(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + err = service->CmdInitIncrementalBackupSessionMsg(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC)); + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitIncrementalBackupSession(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdInitIncrementalBackupSessionMsg(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitIncrementalBackupSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0200"; +} + /** * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100 * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100 diff --git a/tests/unittests/backup_sa/module_ipc/service_test.cpp b/tests/unittests/backup_sa/module_ipc/service_test.cpp index 1ca6f3daa..f334db579 100644 --- a/tests/unittests/backup_sa/module_ipc/service_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_test.cpp @@ -98,6 +98,8 @@ ErrCode ServiceTest::Init(IServiceReverse::Scenario scenario) } else if (scenario == IServiceReverse::Scenario::BACKUP) { ret = servicePtr_->InitBackupSession(remote_); EXPECT_EQ(ret, BError(BError::Codes::OK)); + ret = servicePtr_->InitBackupSession(remote_, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::OK)); ret = servicePtr_->AppendBundlesBackupSession(bundleNames); EXPECT_EQ(ret, BError(BError::Codes::OK)); ret = servicePtr_->Finish(); diff --git a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp index da38c049c..0dd449a16 100644 --- a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp @@ -162,6 +162,61 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitRestoreSession_0100, testing::e GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitRestoreSession_0100"; } +/** + * @tc.number: SUB_Service_throw_InitRestoreSession_0200 + * @tc.name: SUB_Service_throw_InitRestoreSession_0200 + * @tc.desc: 测试 InitRestoreSession 接口的 catch 分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesIAC04T + */ +HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitRestoreSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_InitRestoreSession_0200"; + std::string errMsg; + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::DEFAULT_USER_ID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + auto ret = service->InitRestoreSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitRestoreSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitRestoreSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_SESSION_CONFLICT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::OK))); + ret = service->InitRestoreSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitRestoreSession_0200"; +} + /** * @tc.number: SUB_Service_throw_InitBackupSession_0100 * @tc.name: SUB_Service_throw_InitBackupSession_0100 @@ -205,6 +260,61 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitBackupSession_0100, testing::ex GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitBackupSession_0100"; } +/** + * @tc.number: SUB_Service_throw_InitBackupSession_0200 + * @tc.name: SUB_Service_throw_InitBackupSession_0200 + * @tc.desc: 测试 InitBackupSession 接口的 catch 分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesIAC04T + */ +HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitBackupSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_InitBackupSession_0200"; + std::string errMsg; + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::DEFAULT_USER_ID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + auto ret = service->InitBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_SESSION_CONFLICT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::OK))); + ret = service->InitBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitBackupSession_0200"; +} + /** * @tc.number: SUB_Service_throw_AppendBundlesRestoreSession_0100 * @tc.name: SUB_Service_throw_AppendBundlesRestoreSession_0100 @@ -944,6 +1054,65 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitIncrementalBackupSession_0100, GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitIncrementalBackupSession_0100"; } +/** + * @tc.number: SUB_Service_throw_InitIncrementalBackupSession_0200 + * @tc.name: SUB_Service_throw_InitIncrementalBackupSession_0200 + * @tc.desc: 测试 InitIncrementalBackupSession 接口的 catch 分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesIAC04T + */ +HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitIncrementalBackupSession_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceThrowTest-begin SUB_Service_throw_InitIncrementalBackupSession_0200"; + std::string errMsg; + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::DEFAULT_USER_ID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + auto ret = service->InitIncrementalBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitIncrementalBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_SESSION_CONFLICT))); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->InitIncrementalBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::SA_SESSION_CONFLICT).GetCode()); + + EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)) + .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::OK))); + ret = service->InitIncrementalBackupSession(nullptr, errMsg); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + GTEST_LOG_(INFO) << "ServiceThrowTest-end SUB_Service_throw_InitIncrementalBackupSession_0200"; +} + /** * @tc.number: SUB_Service_throw_AppendBundlesIncrementalBackupSession_0100 * @tc.name: SUB_Service_throw_AppendBundlesIncrementalBackupSession_0100 diff --git a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp index 17779f0b8..d78d91c2a 100644 --- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp +++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp @@ -60,7 +60,7 @@ void IncrementalSessionTest::TearDownTestCase() /** * @tc.number: SUB_b_incremental_session_test_0100 * @tc.name: SUB_b_incremental_session_test_0100 - * @tc.desc: 测试 InitRestoreSession 接口 + * @tc.desc: 测试 InitIncrementalBackupSession 接口 * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 @@ -763,4 +763,72 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2300, testing::e } GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2300"; } + +/** + * @tc.number: SUB_b_incremental_session_test_2400 + * @tc.name: SUB_b_incremental_session_test_2400 + * @tc.desc: 测试 InitIncrementalBackupSession 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2400, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2400"; + try { + std::string errMsg; + ErrCode errCode; + ServiceProxy::serviceProxy_ = nullptr; + BIncrementalBackupSession::Callbacks callbacks; + EXPECT_TRUE(backupSession != nullptr); + auto err = backupSession->Init(callbacks, errMsg, errCode); + EXPECT_EQ(err, nullptr); + + EXPECT_CALL(*proxy, InitIncrementalBackupSession(_, _)).WillOnce(Return(-1)).WillOnce(Return(0)); + ServiceProxy::serviceProxy_ = proxy; + err = backupSession->Init(callbacks, errMsg, errCode); + EXPECT_EQ(err, nullptr); + err = backupSession->Init(callbacks, errMsg, errCode); + EXPECT_NE(err, nullptr); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by RemoveExtConn."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2400"; +} + +/** + * @tc.number: SUB_b_incremental_session_test_2500 + * @tc.name: SUB_b_incremental_session_test_2500 + * @tc.desc: 测试 Init 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2500, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2500"; + try { + std::string errMsg; + ErrCode errCode; + ServiceProxy::serviceProxy_ = nullptr; + BIncrementalRestoreSession::Callbacks callbacks; + EXPECT_TRUE(restoreSession != nullptr); + auto err = restoreSession->Init(callbacks, errMsg, errCode); + EXPECT_EQ(err, nullptr); + + EXPECT_CALL(*proxy, InitRestoreSession(_, _)).WillOnce(Return(-1)).WillOnce(Return(0)); + ServiceProxy::serviceProxy_ = proxy; + err = restoreSession->Init(callbacks, errMsg, errCode); + EXPECT_EQ(err, nullptr); + err = restoreSession->Init(callbacks, errMsg, errCode); + EXPECT_NE(err, nullptr); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by RemoveExtConn."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2500"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.h b/tests/unittests/backup_sa/session/service_proxy_mock.h index bf0537b8f..a59dca016 100644 --- a/tests/unittests/backup_sa/session/service_proxy_mock.h +++ b/tests/unittests/backup_sa/session/service_proxy_mock.h @@ -29,6 +29,7 @@ public: MOCK_METHOD1(InitRestoreSession, ErrCode(sptr remote)); MOCK_METHOD2(InitRestoreSession, ErrCode(sptr remote, std::string &errMsg)); MOCK_METHOD1(InitBackupSession, ErrCode(sptr remote)); + MOCK_METHOD2(InitBackupSession, ErrCode(sptr remote, std::string &errMsg)); MOCK_METHOD0(Start, ErrCode()); MOCK_METHOD0(AsObject, sptr()); MOCK_METHOD0(GetLocalCapabilities, UniqueFd()); @@ -49,6 +50,7 @@ public: MOCK_METHOD2(Cancel, ErrCode(std::string bundleName, int32_t &result)); MOCK_METHOD1(GetLocalCapabilitiesIncremental, UniqueFd(const std::vector &bundleNames)); MOCK_METHOD1(InitIncrementalBackupSession, ErrCode(sptr remote)); + MOCK_METHOD2(InitIncrementalBackupSession, ErrCode(sptr remote, std::string &errMsg)); MOCK_METHOD1(AppendBundlesIncrementalBackupSession, ErrCode(const std::vector &bundlesToBackup)); MOCK_METHOD2(AppendBundlesIncrementalBackupSession, ErrCode(const std::vector &bundlesToBackup, const std::vector &infos)); -- Gitee