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_fetch_result_test.h"
17 
18 #include "ability_context_impl.h"
19 #include "datashare_helper.h"
20 #include "iservice_registry.h"
21 #include "ringtone_asset.h"
22 #include "ringtone_data_manager.h"
23 #include "ringtone_errno.h"
24 #define private public
25 #include "ringtone_fetch_result.h"
26 #undef private
27 #include "ringtone_type.h"
28 #include "ringtone_log.h"
29 
30 
31 using namespace std;
32 using namespace OHOS;
33 using namespace testing::ext;
34 
35 namespace OHOS {
36 namespace Media {
37 const string RINGTONE_LIBRARY_PATH = "/storage/cloud/files/Ringtone";
38 const string MTP_FORMAT_MP3 = ".mp3"; // MP3 audio files
39 const string TEST_INSERT_RINGTONE_LIBRARY = "test_insert_ringtone_library";
40 const int TEST_RINGTONE_COLUMN_SIZE = 1022;
41 const int TEST_RINGTONE_COLUMN_TONE_TYPE = 2;
42 const string SLASH_STR = "/";
43 const string MP3 = "mp3";
44 shared_ptr<RingtoneFetchResult<RingtoneAsset>> g_fetchResult;
SetUpTestCase()45 void RingtoneFetchResultTest::SetUpTestCase()
46 {
47     auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
48     auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
49     abilityContextImpl->SetStageContext(stageContext);
50     auto ret = RingtoneDataManager::GetInstance()->Init(abilityContextImpl);
51     CHECK_AND_RETURN_LOG(ret == E_OK, "InitMediaLibraryMgr failed, ret: %{public}d", ret);
52     std::shared_ptr<DataShare::DataShareResultSet> dataShare = make_shared<DataShare::DataShareResultSet>();
53     g_fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>(dataShare);
54     EXPECT_NE(g_fetchResult, nullptr);
55     system("rm -rf /storage/cloud/files/");
56     system("mkdir /storage/cloud/files");
57     system("mkdir /storage/cloud/files/Ringtone");
58 }
59 
TearDownTestCase()60 void RingtoneFetchResultTest::TearDownTestCase()
61 {
62     system("rm -rf /storage/cloud/files/");
63     auto dataManager = RingtoneDataManager::GetInstance();
64     EXPECT_NE(dataManager, nullptr);
65     dataManager->ClearRingtoneDataMgr();
66 }
67 
68 // SetUp:Execute before each test case
SetUp()69 void RingtoneFetchResultTest::SetUp() {}
70 
TearDown(void)71 void RingtoneFetchResultTest::TearDown(void) {}
72 
73 HWTEST_F(RingtoneFetchResultTest, fetchResult_IsAtLastRow_test_001, TestSize.Level0)
74 {
75     auto ringtoneAsset = g_fetchResult->GetFirstObject();
76     EXPECT_EQ(ringtoneAsset, nullptr);
77     bool ret = g_fetchResult->IsAtLastRow();
78     EXPECT_EQ(ret, false);
79     shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
80     ret = fetchResult->IsAtLastRow();
81     EXPECT_EQ(ret, false);
82 }
83 
84 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetRowValFromColumn_test_001, TestSize.Level0)
85 {
86     auto ringtoneAsset = g_fetchResult->GetNextObject();
87     EXPECT_EQ(ringtoneAsset, nullptr);
88     string columnName;
89     RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_STRING;
90     shared_ptr<NativeRdb::ResultSet> resultSet = nullptr;
91     auto ret = g_fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
92     variant<int32_t, int64_t, string, double> cellValue = "";
93     EXPECT_EQ(ret, cellValue);
94     shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
95     dataType = RingtoneResultSetDataType::DATA_TYPE_INT64;
96     ret = fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
97     variant<int32_t, int64_t, string, double> longVal = static_cast<int64_t>(0);
98     EXPECT_EQ(ret, longVal);
99     dataType = RingtoneResultSetDataType::DATA_TYPE_DOUBLE;
100     ret = fetchResult->GetRowValFromColumn(columnName, dataType, resultSet);
101     variant<int32_t, int64_t, string, double> doubleVal = 0;
102     EXPECT_EQ(ret, doubleVal);
103     fetchResult->Close();
104 }
105 
106 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetValByIndex_test_001, TestSize.Level0)
107 {
108     auto ringtoneAsset = g_fetchResult->GetLastObject();
109     EXPECT_EQ(ringtoneAsset, nullptr);
110     int32_t index = 0;
111     RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_STRING;
112     shared_ptr<NativeRdb::ResultSet> resultSet;
113     auto ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
114     variant<int32_t, int64_t, string, double> stringVal = "";
115     EXPECT_EQ(ret, stringVal);
116     dataType = RingtoneResultSetDataType::DATA_TYPE_INT32;
117     ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
118     variant<int32_t, int64_t, string, double> integerVal = 0;
119     EXPECT_EQ(ret, integerVal);
120     dataType = RingtoneResultSetDataType::DATA_TYPE_INT64;
121     ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
122     variant<int32_t, int64_t, string, double> longVal = static_cast<int64_t>(0);
123     EXPECT_EQ(ret, longVal);
124     dataType = RingtoneResultSetDataType::DATA_TYPE_DOUBLE;
125     ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
126     variant<int32_t, int64_t, string, double> doubleVal = 0.0;
127     EXPECT_EQ(ret, doubleVal);
128     dataType = RingtoneResultSetDataType::DATA_TYPE_NULL;
129     ret = g_fetchResult->GetValByIndex(index, dataType, resultSet);
130     variant<int32_t, int64_t, string, double> cellValue ;
131     EXPECT_EQ(ret, cellValue);
132     shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
133     shared_ptr<NativeRdb::ResultSet> nativeRdbResultSet = nullptr;
134     fetchResult->GetValByIndex(index, dataType, nativeRdbResultSet);
135     EXPECT_EQ(ret, cellValue);
136 }
137 
138 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectFromRdb_test_001, TestSize.Level0)
139 {
140     int32_t index = 0;
141     shared_ptr<NativeRdb::ResultSet> resultSet;
142     auto ringtoneAsset = g_fetchResult->GetObjectFromRdb(resultSet, index);
143     EXPECT_EQ(ringtoneAsset, nullptr);
144     auto ringtoneObject = g_fetchResult->GetObject();
145     EXPECT_NE(ringtoneObject, nullptr);
146     shared_ptr<RingtoneFetchResult<RingtoneAsset>> fetchResult = make_shared<RingtoneFetchResult<RingtoneAsset>>();
147     unique_ptr<RingtoneAsset> asset = nullptr;
148     shared_ptr<NativeRdb::ResultSet> nativeRdbResultSet = nullptr;
149     fetchResult->SetRingtoneAsset(asset, nativeRdbResultSet);
150     ringtoneAsset = fetchResult->GetObjectFromRdb(resultSet, index);
151     EXPECT_EQ(ringtoneAsset, nullptr);
152 }
153 
154 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetObjectAtPosition_test_001, TestSize.Level0)
155 {
156     int32_t index = 0;
157     auto ringtoneObject = g_fetchResult->GetObjectAtPosition(index);
158     EXPECT_EQ(ringtoneObject, nullptr);
159     auto resultSet = g_fetchResult->GetDataShareResultSet();
160     EXPECT_NE(resultSet, nullptr);
161 }
162 
163 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetRowValFromColumn_test_002, TestSize.Level0)
164 {
165     Uri uri(RINGTONE_PATH_URI);
166     DataShare::DataShareValuesBucket valuesBucket;
167     valuesBucket.Put(RINGTONE_COLUMN_DATA,
168         static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
169         TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
170     valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
171     valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
172     valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3); // todo construct by us
173     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
174     auto dataManager = RingtoneDataManager::GetInstance();
175     EXPECT_NE(dataManager, nullptr);
176     auto retVal = dataManager->Insert(cmd, valuesBucket);
177     EXPECT_EQ((retVal > 0), true);
178 
179     int errCode = 0;
180     RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
181     DataShare::DataSharePredicates queryPredicates;
182     queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
183     vector<string> columns = { { RINGTONE_COLUMN_TONE_ID }, { RINGTONE_COLUMN_DATA }, { RINGTONE_COLUMN_SIZE } };
184     auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
185     EXPECT_NE((queryResultSet == nullptr), true);
186     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
187         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
188     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
189     cout << "query count = " << to_string(results->GetCount()) << endl;
190     RingtoneResultSetDataType dataType = RingtoneResultSetDataType::DATA_TYPE_DOUBLE;
191     shared_ptr<NativeRdb::ResultSet> nativeRdbResultSet;
192     results->GetRowValFromColumn(RINGTONE_COLUMN_DATA, dataType, nativeRdbResultSet);
193     int32_t index = 0;
194     auto ringtoneObject = results->GetObjectAtPosition(index);
195     EXPECT_NE(ringtoneObject, nullptr);
196     results->Close();
197 
198     DataShare::DataSharePredicates predicates;
199     RingtoneDataCommand cmdDelete(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
200     EXPECT_NE(dataManager, nullptr);
201     retVal = dataManager->Delete(cmdDelete, predicates);
202     EXPECT_EQ((retVal > 0), true);
203 }
204 
205 HWTEST_F(RingtoneFetchResultTest, fetchResult_GetNextObject_test_001, TestSize.Level0)
206 {
207     Uri uri(RINGTONE_PATH_URI);
208     DataShare::DataShareValuesBucket valuesBucket;
209     valuesBucket.Put(RINGTONE_COLUMN_DATA,
210         static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
211         TEST_INSERT_RINGTONE_LIBRARY + to_string(0) + MTP_FORMAT_MP3));
212     valuesBucket.Put(RINGTONE_COLUMN_SIZE, static_cast<int64_t>(TEST_RINGTONE_COLUMN_SIZE));
213     valuesBucket.Put(RINGTONE_COLUMN_TONE_TYPE, static_cast<int>(TEST_RINGTONE_COLUMN_TONE_TYPE));
214     valuesBucket.Put(RINGTONE_COLUMN_MIME_TYPE, MP3); // todo construct by us
215     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
216     auto dataManager = RingtoneDataManager::GetInstance();
217     EXPECT_NE(dataManager, nullptr);
218     auto retVal = dataManager->Insert(cmd, valuesBucket);
219     EXPECT_EQ((retVal > 0), true);
220     DataShare::DataShareValuesBucket valuesBucketInsert;
221     valuesBucketInsert.Put(RINGTONE_COLUMN_DATA,
222         static_cast<string>(RINGTONE_LIBRARY_PATH + SLASH_STR +
223         TEST_INSERT_RINGTONE_LIBRARY + to_string(1) + MTP_FORMAT_MP3));
224     retVal = dataManager->Insert(cmd, valuesBucketInsert);
225     EXPECT_EQ((retVal > 0), true);
226 
227     int errCode = 0;
228     RingtoneDataCommand cmdQuery(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
229     DataShare::DataSharePredicates queryPredicates;
230     queryPredicates.EqualTo(RINGTONE_COLUMN_MIME_TYPE, MP3);
231     vector<string> columns = { { RINGTONE_COLUMN_DATA } };
232     auto queryResultSet = dataManager->Query(cmdQuery, columns, queryPredicates, errCode);
233     EXPECT_NE((queryResultSet == nullptr), true);
234     shared_ptr<AbilityRuntime::DataShareResultSet> resultSet =
235         make_shared<AbilityRuntime::DataShareResultSet>(queryResultSet);
236     auto results = make_unique<RingtoneFetchResult<RingtoneAsset>>(move(resultSet));
237     cout << "query count = " << to_string(results->GetCount()) << endl;
238     auto ringtoneObject = results->GetNextObject();
239     EXPECT_NE(ringtoneObject, nullptr);
240     ringtoneObject = results->GetFirstObject();
241     EXPECT_NE(ringtoneObject, nullptr);
242     ringtoneObject = results->GetLastObject();
243     EXPECT_NE(ringtoneObject, nullptr);
244     results->Close();
245 
246     DataShare::DataSharePredicates predicates;
247     RingtoneDataCommand cmdDelete(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
248     retVal = dataManager->Delete(cmdDelete, predicates);
249     EXPECT_EQ((retVal > 0), true);
250 }
251 } // namespace Media
252 } // namespace OHOS