1 /*
2 * Copyright (c) 2023 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 use std::fs;
17
18 use asset_common::CallingInfo;
19 use asset_definition::{DataType, Extension, Value};
20
21 use crate::{
22 database::Database,
23 statement::Statement,
24 table::Table,
25 types::{ColumnInfo, DbMap, SQLITE_DONE, SQLITE_ROW},
26 };
27
28 #[test]
create_delete_table()29 fn create_delete_table() {
30 fs::create_dir_all("/data/asset_test/0").unwrap();
31 let columns = &[
32 ColumnInfo { name: "id", is_primary_key: true, not_null: true, data_type: DataType::Number },
33 ColumnInfo { name: "alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
34 ];
35 let calling_info = CallingInfo::new_self();
36 let mut db = Database::build(&calling_info, false).unwrap();
37 let table = Table::new("table_name", &db);
38 assert!(!table.exist().unwrap());
39 assert!(table.create(columns).is_ok());
40 assert!(table.exist().unwrap());
41 table.delete().unwrap();
42 db.close_db();
43 fs::remove_dir_all("/data/asset_test/0").unwrap();
44 }
45
46 #[test]
table_restore()47 fn table_restore() {
48 fs::create_dir_all("/data/asset_test/0").unwrap();
49 let calling_info = CallingInfo::new_self();
50 let mut db = Database::build(&calling_info, false).unwrap();
51 let table = Table::new("table_name", &db);
52 table
53 .create(&[ColumnInfo { name: "Id", data_type: DataType::Number, is_primary_key: true, not_null: true }])
54 .unwrap();
55 let count = table.insert_row(&DbMap::from([("Id", Value::Number(1))])).unwrap();
56 assert_eq!(count, 1);
57 fs::copy(
58 "/data/asset_test/0/Native_asset_service_8100.db",
59 "/data/asset_test/0/Native_asset_service_8100.db.backup",
60 )
61 .unwrap();
62 db.close_db();
63
64 fs::remove_file("/data/asset_test/0/Native_asset_service_8100.db").unwrap();
65 fs::copy(
66 "/data/asset_test/0/Native_asset_service_8100.db.backup",
67 "/data/asset_test/0/Native_asset_service_8100.db",
68 )
69 .unwrap();
70 db.open().unwrap();
71 let table = Table::new("table_name", &db);
72 let count = table.count_datas(&DbMap::new(), false).unwrap();
73 assert_eq!(count, 1);
74 db.close_db();
75 fs::remove_dir_all("/data/asset_test/0").unwrap();
76 }
77
78 #[cfg(test)]
insert_test_data() -> Database79 fn insert_test_data() -> Database {
80 fs::create_dir_all("/data/asset_test/0").unwrap();
81 let calling_info = CallingInfo::new_self();
82 let db = Database::build(&calling_info, false).unwrap();
83 let columns = &[
84 ColumnInfo { name: "Id", is_primary_key: true, not_null: true, data_type: DataType::Number },
85 ColumnInfo { name: "Owner", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
86 ColumnInfo { name: "Alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
87 ColumnInfo { name: "value", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
88 ];
89 let table = Table::new("table_name", &db);
90 table.create(columns).unwrap();
91
92 let mut datas = DbMap::new();
93 datas.insert_attr("Owner", b"owner1".to_vec());
94 datas.insert_attr("Alias", b"alias1".to_vec());
95 datas.insert_attr("value", b"aaaa".to_vec());
96 assert_eq!(1, table.insert_row(&datas).unwrap());
97
98 datas.insert_attr("Owner", b"owner2".to_vec());
99 datas.insert_attr("Alias", b"alias2".to_vec());
100 datas.insert_attr("value", b"bbbb".to_vec());
101 assert_eq!(1, table.insert_row(&datas).unwrap());
102
103 datas.insert_attr("Owner", b"owner2".to_vec());
104 datas.insert_attr("Alias", b"alias3".to_vec());
105 datas.insert_attr("value", b"cccc".to_vec());
106 assert_eq!(1, table.insert_row(&datas).unwrap());
107 db
108 }
109
110 #[test]
execute_sql()111 fn execute_sql() {
112 fs::create_dir_all("/data/asset_test/0").unwrap();
113 let db = insert_test_data();
114 let sql = "select Owner,Alias from table_name where Id>?";
115 let stmt = Statement::prepare(sql, &db).unwrap();
116 assert!(stmt.bind_data(1, &Value::Number(1)).is_ok());
117
118 let mut count = 0;
119 while stmt.step().unwrap() == SQLITE_ROW {
120 count += 1;
121 }
122 assert_eq!(count, 2);
123 fs::remove_dir_all("/data/asset_test/0").unwrap();
124 }
125
126 #[test]
data_life_circle()127 fn data_life_circle() {
128 fs::create_dir_all("/data/asset_test/0").unwrap();
129 let db = insert_test_data();
130 let mut datas = DbMap::new();
131 datas.insert_attr("Owner", b"owner1".to_vec());
132 datas.insert_attr("Alias", b"alias1".to_vec());
133 let table = Table::new("table_name", &db);
134 assert!(table.is_data_exists(&datas, false).unwrap());
135
136 datas.insert_attr("Owner", b"owner1".to_vec());
137 datas.insert_attr("Alias", b"alias2".to_vec());
138 assert!(!table.is_data_exists(&datas, false).unwrap());
139
140 datas.insert_attr("Owner", b"owner2".to_vec());
141 datas.insert_attr("Alias", b"alias3".to_vec());
142 assert_eq!(1, table.update_row(&datas, false, &DbMap::from([("value", Value::Bytes(b"dddd".to_vec()))])).unwrap());
143 assert_eq!(1, table.delete_row(&datas, None, false).unwrap());
144 fs::remove_dir_all("/data/asset_test/0").unwrap();
145 }
146
147 #[test]
single_data()148 fn single_data() {
149 fs::create_dir_all("/data/asset_test/0").unwrap();
150 let calling_info = CallingInfo::new_self();
151 let db = Database::build(&calling_info, false).unwrap();
152 let table = Table::new("table_name", &db);
153 let columns = &[
154 ColumnInfo { name: "id", is_primary_key: true, not_null: true, data_type: DataType::Number },
155 ColumnInfo { name: "alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
156 ];
157 table.create(columns).unwrap();
158 db.exec("insert into table_name values(1, 'test')").unwrap();
159
160 let stmt = Statement::prepare("select id,alias from table_name where id < ?", &db).unwrap();
161 stmt.bind_data(1, &Value::Number(1000)).unwrap();
162
163 while stmt.step().unwrap() == SQLITE_ROW {
164 let count = stmt.data_count();
165 assert_eq!(2, count);
166
167 assert_eq!("id", stmt.query_column_name(0).unwrap());
168 assert_eq!("alias", stmt.query_column_name(1).unwrap());
169
170 let id = stmt.query_column_int(0);
171 let alias = stmt.query_column_blob(1);
172 assert_eq!(1, id);
173 assert_eq!("test".as_bytes(), alias);
174 }
175 drop(stmt);
176 fs::remove_dir_all("/data/asset_test/0").unwrap();
177 }
178
179 #[test]
multiple_data()180 fn multiple_data() {
181 fs::create_dir_all("/data/asset_test/0").unwrap();
182 let calling_info = CallingInfo::new_self();
183 let db = Database::build(&calling_info, false).unwrap();
184 let table = Table::new("table_name", &db);
185 let columns = &[
186 ColumnInfo { name: "id", is_primary_key: true, not_null: true, data_type: DataType::Number },
187 ColumnInfo { name: "alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
188 ];
189 table.create(columns).unwrap();
190 let data_set = &[
191 [Value::Number(2), Value::Bytes(b"test2".to_vec())],
192 [Value::Number(3), Value::Bytes(b"test3".to_vec())],
193 [Value::Number(4), Value::Bytes(b"test4".to_vec())],
194 ];
195 let stmt = Statement::prepare("insert into table_name values(?, ?)", &db).unwrap();
196 for data in data_set {
197 stmt.reset().unwrap();
198 stmt.bind_data(1, &data[0]).unwrap();
199 stmt.bind_data(2, &data[1]).unwrap();
200 assert_eq!(SQLITE_DONE, stmt.step().unwrap());
201 }
202
203 let stmt = Statement::prepare("select id,alias from table_name where id < ?", &db).unwrap();
204 stmt.bind_data(1, &Value::Number(1000)).unwrap();
205 let mut index = 0;
206 while stmt.step().unwrap() == SQLITE_ROW {
207 let data_count = stmt.data_count();
208 assert_eq!(data_count, 2);
209
210 let id = stmt.query_column_int(0);
211 let alias = stmt.query_column_blob(1);
212 assert_eq!(data_set[index][0], Value::Number(id));
213 assert_eq!(data_set[index][1], Value::Bytes(alias.to_vec()));
214 index += 1;
215 }
216 assert!(table.delete().is_ok());
217 fs::remove_dir_all("/data/asset_test/0").unwrap();
218 }
219
220 #[test]
insert_query_row()221 fn insert_query_row() {
222 fs::create_dir_all("/data/asset_test/0").unwrap();
223 let calling_info = CallingInfo::new_self();
224 let db = Database::build(&calling_info, false).unwrap();
225 let table = Table::new("table_name", &db);
226
227 let columns = &[
228 ColumnInfo { name: "id", is_primary_key: true, not_null: true, data_type: DataType::Number },
229 ColumnInfo { name: "alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
230 ];
231 table.create(columns).unwrap();
232
233 let datas = DbMap::from([("id", Value::Number(3)), ("alias", Value::Bytes(b"alias1".to_vec()))]);
234 assert_eq!(table.insert_row(&datas).unwrap(), 1);
235 let datas = DbMap::from([("alias", Value::Bytes(b"alias1".to_vec()))]);
236 assert_eq!(table.insert_row(&datas).unwrap(), 1);
237
238 let result_set = table.query_row(&vec![], &DbMap::new(), None, false, columns).unwrap();
239 assert_eq!(result_set.len(), 2);
240
241 let count = table.count_datas(&DbMap::new(), false).unwrap();
242 assert_eq!(count, 2);
243 let count = table.count_datas(&DbMap::from([("id", Value::Number(3))]), false).unwrap();
244 assert_eq!(count, 1);
245
246 fs::remove_dir_all("/data/asset_test/0").unwrap();
247 }
248
249 #[test]
update_delete_row()250 fn update_delete_row() {
251 fs::create_dir_all("/data/asset_test/0").unwrap();
252 let calling_info = CallingInfo::new_self();
253 let db = Database::build(&calling_info, false).unwrap();
254 let table = Table::new("table_name", &db);
255
256 let columns = &[
257 ColumnInfo { name: "id", is_primary_key: true, not_null: true, data_type: DataType::Number },
258 ColumnInfo { name: "alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
259 ];
260 table.create(columns).unwrap();
261 let datas = DbMap::from([("id", Value::Number(1)), ("alias", Value::Bytes(b"alias1".to_vec()))]);
262 assert_eq!(table.insert_row(&datas).unwrap(), 1);
263 let datas = DbMap::from([("id", Value::Number(2)), ("alias", Value::Bytes(b"alias2".to_vec()))]);
264 assert_eq!(table.insert_row(&datas).unwrap(), 1);
265
266 let conditions = DbMap::from([("id", Value::Number(2))]);
267 let datas = DbMap::from([("alias", Value::Bytes(b"test_update".to_vec()))]);
268 assert_eq!(table.update_row(&conditions, false, &datas).unwrap(), 1);
269 assert!(table.is_data_exists(&datas, false).unwrap());
270 assert_eq!(table.delete_row(&conditions, None, false).unwrap(), 1);
271 assert!(!table.is_data_exists(&conditions, false).unwrap());
272
273 fs::remove_dir_all("/data/asset_test/0").unwrap();
274 }
275
276 #[test]
upgrade_table()277 fn upgrade_table() {
278 fs::create_dir_all("/data/asset_test/0").unwrap();
279 let calling_info = CallingInfo::new_self();
280 let db = Database::build(&calling_info, false).unwrap();
281 let table = Table::new("table_name", &db);
282
283 let columns = &[
284 ColumnInfo { name: "id", is_primary_key: true, not_null: true, data_type: DataType::Number },
285 ColumnInfo { name: "alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
286 ];
287 table.create(columns).unwrap();
288 assert!(table
289 .add_column(
290 &ColumnInfo { name: "value", is_primary_key: false, not_null: false, data_type: DataType::Bytes },
291 &None
292 )
293 .is_ok());
294 assert!(table
295 .add_column(
296 &ColumnInfo { name: "value1", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
297 &None
298 )
299 .is_err());
300 assert!(table
301 .add_column(
302 &ColumnInfo { name: "value2", is_primary_key: true, not_null: true, data_type: DataType::Number },
303 &None
304 )
305 .is_err());
306 assert!(table
307 .add_column(
308 &ColumnInfo { name: "value3", is_primary_key: false, not_null: true, data_type: DataType::Number },
309 &Some(Value::Number(1))
310 )
311 .is_ok());
312 fs::remove_dir_all("/data/asset_test/0").unwrap();
313 }
314
315 #[test]
replace_datas()316 fn replace_datas() {
317 fs::create_dir_all("/data/asset_test/0").unwrap();
318 let calling_info = CallingInfo::new_self();
319 let db = Database::build(&calling_info, false).unwrap();
320 let table = Table::new("table_name", &db);
321
322 let columns = &[
323 ColumnInfo { name: "id", is_primary_key: true, not_null: true, data_type: DataType::Number },
324 ColumnInfo { name: "alias", is_primary_key: false, not_null: true, data_type: DataType::Bytes },
325 ];
326 table.create(columns).unwrap();
327 let datas = DbMap::from([("id", Value::Number(1)), ("alias", Value::Bytes(b"alias1".to_vec()))]);
328 assert_eq!(table.insert_row(&datas).unwrap(), 1);
329 let datas = DbMap::from([("id", Value::Number(2)), ("alias", Value::Bytes(b"alias2".to_vec()))]);
330 assert_eq!(table.insert_row(&datas).unwrap(), 1);
331
332 let conditions = DbMap::from([("id", Value::Number(2))]);
333 let datas = DbMap::from([("id", Value::Number(3)), ("alias", Value::Bytes(b"alias3".to_vec()))]);
334 table.replace_row(&conditions, false, &datas).unwrap();
335 assert!(table.is_data_exists(&datas, false).unwrap());
336
337 assert_eq!(table.count_datas(&conditions, false).unwrap(), 0);
338 fs::remove_dir_all("/data/asset_test/0").unwrap();
339 }
340