1 /*
2  * Copyright (C) 2024 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 "ringtone_datashare_extension_test.h"
17 
18 #include "ability_handler.h"
19 #include "ability_info.h"
20 #include "datashare_ext_ability.h"
21 #include "get_self_permissions.h"
22 #include "ohos_application.h"
23 #define private public
24 #include "ringtone_datashare_stub_impl.h"
25 #undef private
26 #include "ringtone_db_const.h"
27 #include "ringtone_errno.h"
28 #include "ringtone_file_utils.h"
29 #include "ringtone_type.h"
30 #include "runtime.h"
31 
32 
33 using namespace std;
34 using namespace OHOS;
35 using namespace testing::ext;
36 
37 namespace OHOS {
38 namespace Media {
39 
SetUpTestCase()40 void RingtoneDataShareExtensionTest::SetUpTestCase()
41 {
42     vector<string> perms;
43     perms.push_back("ohos.permission.WRITE_RINGTONE");
44 
45     uint64_t tokenId = 0;
46     RingtonePermissionUtilsUnitTest::SetAccessTokenPermission("RingtoneDataManagerUnitTest", perms, tokenId);
47     ASSERT_TRUE(tokenId != 0);
48 }
TearDownTestCase()49 void RingtoneDataShareExtensionTest::TearDownTestCase() {}
50 
51 // SetUp:Execute before each test case
SetUp()52 void RingtoneDataShareExtensionTest::SetUp() {}
53 
TearDown()54 void RingtoneDataShareExtensionTest::TearDown() {}
55 
56 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_OnConnect_test_001, TestSize.Level0)
57 {
58     const std::unique_ptr<AbilityRuntime::Runtime> runtime;
59     AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
60     AbilityRuntime::DataShareExtAbility::Create(runtime);
61     mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
62     ASSERT_TRUE(mediaDataShare != nullptr);
63 
64     std::shared_ptr<AppExecFwk::AbilityLocalRecord> record = nullptr;
65     const std::shared_ptr<AppExecFwk::OHOSApplication> application = nullptr;
66     std::shared_ptr<AppExecFwk::AbilityHandler> handler = nullptr;
67     const sptr<IRemoteObject> token = nullptr;
68     mediaDataShare->Init(record, application, handler, token);
69 
70     std::shared_ptr<AbilityRuntime::AbilityInfo> info = std::make_shared<AbilityRuntime::AbilityInfo>();
71     info->name = "start";
72     napi_env env = nullptr;
73     shared_ptr<DataShare::RingtoneDataShareExtension> extension(mediaDataShare);
74     sptr<DataShare::RingtoneDataShareStubImpl> remoteObject =
75         new DataShare::RingtoneDataShareStubImpl(extension, env);
76     std::shared_ptr<AppExecFwk::AbilityLocalRecord> recordTwo =
77         std::make_shared<AppExecFwk::AbilityLocalRecord>(info, token);
78     mediaDataShare->Init(recordTwo, application, handler, token);
79     std::shared_ptr<AppExecFwk::OHOSApplication> applicationTwo = std::make_shared<AppExecFwk::OHOSApplication>();
80     mediaDataShare->Init(recordTwo, applicationTwo, handler, token);
81     std::shared_ptr<AbilityRuntime::EventRunner> runner = nullptr;
82     std::shared_ptr<AppExecFwk::AbilityHandler> handlerTwo = make_shared<AppExecFwk::AbilityHandler>(runner);
83     mediaDataShare->Init(recordTwo, applicationTwo, handlerTwo, token);
84     const sptr<IRemoteObject> tokenTwo = remoteObject->AsObject();
85     mediaDataShare->Init(recordTwo, applicationTwo, handlerTwo, tokenTwo);
86     AAFwk::Want want;
87     auto ret = mediaDataShare->OnConnect(want);
88     EXPECT_EQ((ret != nullptr), true);
89     mediaDataShare->OnStart(want);
90     mediaDataShare->OnStop();
91     ret = mediaDataShare->OnConnect(want);
92     EXPECT_EQ((ret != nullptr), true);
93 }
94 
95 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Update_test_001, TestSize.Level0)
96 {
97     const std::unique_ptr<AbilityRuntime::Runtime> runtime;
98     AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
99     mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
100     EXPECT_EQ(mediaDataShare != nullptr, true);
101 
102     Uri uri(RINGTONE_PATH_URI);
103     const AbilityRuntime::DataSharePredicates predicates;
104     AbilityRuntime::DataShareValuesBucket values;
105     auto ret = mediaDataShare->Update(uri, predicates, values);
106     EXPECT_EQ(ret, E_COMMON_START);
107 
108     Uri uriError(RINGTONE_URI);
109     ret = mediaDataShare->Update(uriError, predicates, values);
110     EXPECT_EQ(ret, E_INVALID_URI);
111 }
112 
113 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_Query_test_001, TestSize.Level0)
114 {
115     const std::unique_ptr<AbilityRuntime::Runtime> runtime;
116     AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
117     mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
118     EXPECT_EQ(mediaDataShare != nullptr, true);
119 
120     Uri uri(RINGTONE_PATH_URI);
121     vector<string> columns;
122     const AbilityRuntime::DataSharePredicates predicates;
123     AbilityRuntime::DatashareBusinessError businessError;
124     auto ret = mediaDataShare->Query(uri, predicates, columns, businessError);
125     EXPECT_EQ(ret, nullptr);
126 
127     Uri uriError(RINGTONE_URI);
128     ret = mediaDataShare->Query(uriError, predicates, columns, businessError);
129     EXPECT_EQ(ret, nullptr);
130 }
131 
132 HWTEST_F(RingtoneDataShareExtensionTest, dataShareExtension_DumpDataShareValueBucket_test_001, TestSize.Level0)
133 {
134     const std::unique_ptr<AbilityRuntime::Runtime> runtime;
135     AbilityRuntime::RingtoneDataShareExtension *mediaDataShare;
136     mediaDataShare = AbilityRuntime::RingtoneDataShareExtension::Create(runtime);
137     EXPECT_EQ(mediaDataShare != nullptr, true);
138 
139     const string ringtoneUintType = "uint_type";
140     const string ringtoneBoolType = "bool_type";
141     const string ringtoneDoubleType = "double_type";
142     const string ringtoneVectorType = "vector_type";
143     const int64_t addedTime = 1559276453;
144     const double doubleSize = 155.9276457;
145     std::vector<string> tabFields;
146     std::vector<uint8_t> ringtoneVec;
147     ringtoneVec.push_back(1);
148     tabFields.push_back(ringtoneUintType);
149     tabFields.push_back(RINGTONE_COLUMN_DATE_ADDED);
150     tabFields.push_back(RINGTONE_COLUMN_MIME_TYPE);
151     tabFields.push_back(ringtoneBoolType);
152     tabFields.push_back(ringtoneDoubleType);
153     tabFields.push_back(ringtoneVectorType);
154     AbilityRuntime::DataShareValuesBucket value;
155     value.Put(ringtoneUintType, static_cast<uint8_t>(1));
156     value.Put(RINGTONE_COLUMN_DATE_ADDED, static_cast<int64_t>(addedTime));
157     value.Put(RINGTONE_COLUMN_MIME_TYPE, static_cast<string>(RINGTONE_CONTAINER_TYPE_OGG));
158     value.Put(ringtoneBoolType, static_cast<bool>(true));
159     value.Put(ringtoneDoubleType, static_cast<double>(doubleSize));
160     value.Put(ringtoneVectorType, static_cast<std::vector<uint8_t>>(ringtoneVec));
161     mediaDataShare->DumpDataShareValueBucket(tabFields, value);
162     EXPECT_EQ(mediaDataShare != nullptr, true);
163 }
164 } // namespace Media
165 } // namespace OHOS
166