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