ISAR/rusqlite
3
0
Fork 0
mirror of https://github.com/isar/rusqlite.git synced 2025-08-21 05:41:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

Make tests return Result

Browse Source
This commit is contained in:
gwenn
2020-11-05 22:14:00 +01:00
parent 65c38bf813
commit da94f8eba6
30 changed files with 1040 additions and 1179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
src/types/chrono.rs
View File

@@ -137,114 +137,109 @@ mod test {
use crate::{Connection, Result};
use chrono::{DateTime, Duration, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT, b BLOB)")
.unwrap();
db
fn checked_memory_handle() -> Result<Connection> {
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT, b BLOB)")?;
Ok(db)
}
#[test]
fn test_naive_date() {
let db = checked_memory_handle();
fn test_naive_date() -> Result<()> {
let db = checked_memory_handle()?;
let date = NaiveDate::from_ymd(2016, 2, 23);
db.execute("INSERT INTO foo (t) VALUES (?)", &[&date])
.unwrap();
db.execute("INSERT INTO foo (t) VALUES (?)", &[&date])?;
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!("2016-02-23", s);
let t: NaiveDate = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let t: NaiveDate = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(date, t);
Ok(())
}
#[test]
fn test_naive_time() {
let db = checked_memory_handle();
fn test_naive_time() -> Result<()> {
let db = checked_memory_handle()?;
let time = NaiveTime::from_hms(23, 56, 4);
db.execute("INSERT INTO foo (t) VALUES (?)", &[&time])
.unwrap();
db.execute("INSERT INTO foo (t) VALUES (?)", &[&time])?;
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!("23:56:04", s);
let v: NaiveTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let v: NaiveTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(time, v);
Ok(())
}
#[test]
fn test_naive_date_time() {
let db = checked_memory_handle();
fn test_naive_date_time() -> Result<()> {
let db = checked_memory_handle()?;
let date = NaiveDate::from_ymd(2016, 2, 23);
let time = NaiveTime::from_hms(23, 56, 4);
let dt = NaiveDateTime::new(date, time);
db.execute("INSERT INTO foo (t) VALUES (?)", &[&dt])
.unwrap();
db.execute("INSERT INTO foo (t) VALUES (?)", &[&dt])?;
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!("2016-02-23T23:56:04", s);
let v: NaiveDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let v: NaiveDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(dt, v);
db.execute("UPDATE foo set b = datetime(t)", []).unwrap(); // "YYYY-MM-DD HH:MM:SS"
let hms: NaiveDateTime = db.query_row("SELECT b FROM foo", [], |r| r.get(0)).unwrap();
db.execute("UPDATE foo set b = datetime(t)", [])?; // "YYYY-MM-DD HH:MM:SS"
let hms: NaiveDateTime = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
assert_eq!(dt, hms);
Ok(())
}
#[test]
fn test_date_time_utc() {
let db = checked_memory_handle();
fn test_date_time_utc() -> Result<()> {
let db = checked_memory_handle()?;
let date = NaiveDate::from_ymd(2016, 2, 23);
let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
let dt = NaiveDateTime::new(date, time);
let utc = Utc.from_utc_datetime(&dt);
db.execute("INSERT INTO foo (t) VALUES (?)", &[&utc])
.unwrap();
db.execute("INSERT INTO foo (t) VALUES (?)", &[&utc])?;
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!("2016-02-23T23:56:04.789+00:00", s);
let v1: DateTime<Utc> = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let v1: DateTime<Utc> = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(utc, v1);
let v2: DateTime<Utc> = db
.query_row("SELECT '2016-02-23 23:56:04.789'", [], |r| r.get(0))
.unwrap();
let v2: DateTime<Utc> =
db.query_row("SELECT '2016-02-23 23:56:04.789'", [], |r| r.get(0))?;
assert_eq!(utc, v2);
let v3: DateTime<Utc> = db
.query_row("SELECT '2016-02-23 23:56:04'", [], |r| r.get(0))
.unwrap();
let v3: DateTime<Utc> = db.query_row("SELECT '2016-02-23 23:56:04'", [], |r| r.get(0))?;
assert_eq!(utc - Duration::milliseconds(789), v3);
let v4: DateTime<Utc> = db
.query_row("SELECT '2016-02-23 23:56:04.789+00:00'", [], |r| r.get(0))
.unwrap();
let v4: DateTime<Utc> =
db.query_row("SELECT '2016-02-23 23:56:04.789+00:00'", [], |r| r.get(0))?;
assert_eq!(utc, v4);
Ok(())
}
#[test]
fn test_date_time_local() {
let db = checked_memory_handle();
fn test_date_time_local() -> Result<()> {
let db = checked_memory_handle()?;
let date = NaiveDate::from_ymd(2016, 2, 23);
let time = NaiveTime::from_hms_milli(23, 56, 4, 789);
let dt = NaiveDateTime::new(date, time);
let local = Local.from_local_datetime(&dt).single().unwrap();
db.execute("INSERT INTO foo (t) VALUES (?)", &[&local])
.unwrap();
db.execute("INSERT INTO foo (t) VALUES (?)", &[&local])?;
// Stored string should be in UTC
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let s: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert!(s.ends_with("+00:00"));
let v: DateTime<Local> = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let v: DateTime<Local> = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(local, v);
Ok(())
}
#[test]
fn test_sqlite_functions() {
let db = checked_memory_handle();
fn test_sqlite_functions() -> Result<()> {
let db = checked_memory_handle()?;
let result: Result<NaiveTime> = db.query_row("SELECT CURRENT_TIME", [], |r| r.get(0));
assert!(result.is_ok());
let result: Result<NaiveDate> = db.query_row("SELECT CURRENT_DATE", [], |r| r.get(0));
@@ -255,5 +250,6 @@ mod test {
let result: Result<DateTime<Utc>> =
db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0));
assert!(result.is_ok());
Ok(())
}
}

11
src/types/from_sql.rs
View File

@@ -235,15 +235,11 @@ impl FromSql for Value {
#[cfg(test)]
mod test {
use super::FromSql;
use crate::{Connection, Error};
fn checked_memory_handle() -> Connection {
Connection::open_in_memory().unwrap()
}
use crate::{Connection, Error, Result};
#[test]
fn test_integral_ranges() {
let db = checked_memory_handle();
fn test_integral_ranges() -> Result<()> {
let db = Connection::open_in_memory()?;
fn check_ranges<T>(db: &Connection, out_of_range: &[i64], in_range: &[i64])
where
@@ -278,5 +274,6 @@ mod test {
check_ranges::<u8>(&db, &[-2, -1, 256], &[0, 1, 255]);
check_ranges::<u16>(&db, &[-2, -1, 65536], &[0, 1, 65535]);
check_ranges::<u32>(&db, &[-2, -1, 4_294_967_296], &[0, 1, 4_294_967_295]);
Ok(())
}
}

164
src/types/mod.rs
View File

@@ -131,95 +131,92 @@ impl fmt::Display for Type {
#[cfg(test)]
mod test {
use super::Value;
use crate::{params, Connection, Error, Statement};
use crate::{params, Connection, Error, Result, Statement};
use std::f64::EPSILON;
use std::os::raw::{c_double, c_int};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (b BLOB, t TEXT, i INTEGER, f FLOAT, n)")
.unwrap();
db
fn checked_memory_handle() -> Result<Connection> {
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE foo (b BLOB, t TEXT, i INTEGER, f FLOAT, n)")?;
Ok(db)
}
#[test]
fn test_blob() {
let db = checked_memory_handle();
fn test_blob() -> Result<()> {
let db = checked_memory_handle()?;
let v1234 = vec![1u8, 2, 3, 4];
db.execute("INSERT INTO foo(b) VALUES (?)", &[&v1234])
.unwrap();
db.execute("INSERT INTO foo(b) VALUES (?)", &[&v1234])?;
let v: Vec<u8> = db.query_row("SELECT b FROM foo", [], |r| r.get(0)).unwrap();
let v: Vec<u8> = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
assert_eq!(v, v1234);
Ok(())
}
#[test]
fn test_empty_blob() {
let db = checked_memory_handle();
fn test_empty_blob() -> Result<()> {
let db = checked_memory_handle()?;
let empty = vec![];
db.execute("INSERT INTO foo(b) VALUES (?)", &[&empty])
.unwrap();
db.execute("INSERT INTO foo(b) VALUES (?)", &[&empty])?;
let v: Vec<u8> = db.query_row("SELECT b FROM foo", [], |r| r.get(0)).unwrap();
let v: Vec<u8> = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
assert_eq!(v, empty);
Ok(())
}
#[test]
fn test_str() {
let db = checked_memory_handle();
fn test_str() -> Result<()> {
let db = checked_memory_handle()?;
let s = "hello, world!";
db.execute("INSERT INTO foo(t) VALUES (?)", &[&s]).unwrap();
db.execute("INSERT INTO foo(t) VALUES (?)", &[&s])?;
let from: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let from: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(from, s);
Ok(())
}
#[test]
fn test_string() {
let db = checked_memory_handle();
fn test_string() -> Result<()> {
let db = checked_memory_handle()?;
let s = "hello, world!";
db.execute("INSERT INTO foo(t) VALUES (?)", [s.to_owned()])
.unwrap();
db.execute("INSERT INTO foo(t) VALUES (?)", [s.to_owned()])?;
let from: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let from: String = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(from, s);
Ok(())
}
#[test]
fn test_value() {
let db = checked_memory_handle();
fn test_value() -> Result<()> {
let db = checked_memory_handle()?;
db.execute("INSERT INTO foo(i) VALUES (?)", [Value::Integer(10)])
.unwrap();
db.execute("INSERT INTO foo(i) VALUES (?)", [Value::Integer(10)])?;
assert_eq!(
10i64,
db.query_row::<i64, _, _>("SELECT i FROM foo", [], |r| r.get(0))
.unwrap()
db.query_row::<i64, _, _>("SELECT i FROM foo", [], |r| r.get(0))?
);
Ok(())
}
#[test]
fn test_option() {
let db = checked_memory_handle();
fn test_option() -> Result<()> {
let db = checked_memory_handle()?;
let s = Some("hello, world!");
let b = Some(vec![1u8, 2, 3, 4]);
db.execute("INSERT INTO foo(t) VALUES (?)", &[&s]).unwrap();
db.execute("INSERT INTO foo(b) VALUES (?)", &[&b]).unwrap();
db.execute("INSERT INTO foo(t) VALUES (?)", &[&s])?;
db.execute("INSERT INTO foo(b) VALUES (?)", &[&b])?;
let mut stmt = db
.prepare("SELECT t, b FROM foo ORDER BY ROWID ASC")
.unwrap();
let mut rows = stmt.query([]).unwrap();
let mut stmt = db.prepare("SELECT t, b FROM foo ORDER BY ROWID ASC")?;
let mut rows = stmt.query([])?;
{
let row1 = rows.next().unwrap().unwrap();
let row1 = rows.next()?.unwrap();
let s1: Option<String> = row1.get_unwrap(0);
let b1: Option<Vec<u8>> = row1.get_unwrap(1);
assert_eq!(s.unwrap(), s1.unwrap());
@@ -227,42 +224,42 @@ mod test {
}
{
let row2 = rows.next().unwrap().unwrap();
let row2 = rows.next()?.unwrap();
let s2: Option<String> = row2.get_unwrap(0);
let b2: Option<Vec<u8>> = row2.get_unwrap(1);
assert!(s2.is_none());
assert_eq!(b, b2);
}
Ok(())
}
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_mismatched_types() {
fn test_mismatched_types() -> Result<()> {
fn is_invalid_column_type(err: Error) -> bool {
matches!(err, Error::InvalidColumnType(..))
}
let db = checked_memory_handle();
let db = checked_memory_handle()?;
db.execute(
"INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
[],
)
.unwrap();
)?;
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo").unwrap();
let mut rows = stmt.query([]).unwrap();
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo")?;
let mut rows = stmt.query([])?;
let row = rows.next().unwrap().unwrap();
let row = rows.next()?.unwrap();
// check the correct types come back as expected
assert_eq!(vec![1, 2], row.get::<_, Vec<u8>>(0).unwrap());
assert_eq!("text", row.get::<_, String>(1).unwrap());
assert_eq!(1, row.get::<_, c_int>(2).unwrap());
assert!((1.5 - row.get::<_, c_double>(3).unwrap()).abs() < EPSILON);
assert_eq!(row.get::<_, Option<c_int>>(4).unwrap(), None);
assert_eq!(row.get::<_, Option<c_double>>(4).unwrap(), None);
assert_eq!(row.get::<_, Option<String>>(4).unwrap(), None);
assert_eq!(vec![1, 2], row.get::<_, Vec<u8>>(0)?);
assert_eq!("text", row.get::<_, String>(1)?);
assert_eq!(1, row.get::<_, c_int>(2)?);
assert!((1.5 - row.get::<_, c_double>(3)?).abs() < EPSILON);
assert_eq!(row.get::<_, Option<c_int>>(4)?, None);
assert_eq!(row.get::<_, Option<c_double>>(4)?, None);
assert_eq!(row.get::<_, Option<String>>(4)?, None);
// check some invalid types
@@ -347,58 +344,50 @@ mod test {
assert!(is_invalid_column_type(
row.get::<_, time::OffsetDateTime>(4).err().unwrap()
));
Ok(())
}
#[test]
fn test_dynamic_type() {
fn test_dynamic_type() -> Result<()> {
use super::Value;
let db = checked_memory_handle();
let db = checked_memory_handle()?;
db.execute(
"INSERT INTO foo(b, t, i, f) VALUES (X'0102', 'text', 1, 1.5)",
[],
)
.unwrap();
)?;
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo").unwrap();
let mut rows = stmt.query([]).unwrap();
let mut stmt = db.prepare("SELECT b, t, i, f, n FROM foo")?;
let mut rows = stmt.query([])?;
let row = rows.next().unwrap().unwrap();
assert_eq!(Value::Blob(vec![1, 2]), row.get::<_, Value>(0).unwrap());
assert_eq!(
Value::Text(String::from("text")),
row.get::<_, Value>(1).unwrap()
);
assert_eq!(Value::Integer(1), row.get::<_, Value>(2).unwrap());
match row.get::<_, Value>(3).unwrap() {
let row = rows.next()?.unwrap();
assert_eq!(Value::Blob(vec![1, 2]), row.get::<_, Value>(0)?);
assert_eq!(Value::Text(String::from("text")), row.get::<_, Value>(1)?);
assert_eq!(Value::Integer(1), row.get::<_, Value>(2)?);
match row.get::<_, Value>(3)? {
Value::Real(val) => assert!((1.5 - val).abs() < EPSILON),
x => panic!("Invalid Value {:?}", x),
}
assert_eq!(Value::Null, row.get::<_, Value>(4).unwrap());
assert_eq!(Value::Null, row.get::<_, Value>(4)?);
Ok(())
}
macro_rules! test_conversion {
($db_etc:ident, $insert_value:expr, $get_type:ty,expect $expected_value:expr) => {
$db_etc
.insert_statement
.execute(params![$insert_value])
.unwrap();
$db_etc.insert_statement.execute(params![$insert_value])?;
let res = $db_etc
.query_statement
.query_row([], |row| row.get::<_, $get_type>(0));
assert_eq!(res.unwrap(), $expected_value);
$db_etc.delete_statement.execute([]).unwrap();
assert_eq!(res?, $expected_value);
$db_etc.delete_statement.execute([])?;
};
($db_etc:ident, $insert_value:expr, $get_type:ty,expect_from_sql_error) => {
$db_etc
.insert_statement
.execute(params![$insert_value])
.unwrap();
$db_etc.insert_statement.execute(params![$insert_value])?;
let res = $db_etc
.query_statement
.query_row([], |row| row.get::<_, $get_type>(0));
res.unwrap_err();
$db_etc.delete_statement.execute([]).unwrap();
$db_etc.delete_statement.execute([])?;
};
($db_etc:ident, $insert_value:expr, $get_type:ty,expect_to_sql_error) => {
$db_etc
@@ -409,12 +398,12 @@ mod test {
}
#[test]
fn test_numeric_conversions() {
fn test_numeric_conversions() -> Result<()> {
#![allow(clippy::float_cmp)]
// Test what happens when we store an f32 and retrieve an i32 etc.
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (x)").unwrap();
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE foo (x)")?;
// SQLite actually ignores the column types, so we just need to test
// different numeric values.
@@ -426,9 +415,9 @@ mod test {
}
let mut db_etc = DbEtc {
insert_statement: db.prepare("INSERT INTO foo VALUES (?1)").unwrap(),
query_statement: db.prepare("SELECT x FROM foo").unwrap(),
delete_statement: db.prepare("DELETE FROM foo").unwrap(),
insert_statement: db.prepare("INSERT INTO foo VALUES (?1)")?,
query_statement: db.prepare("SELECT x FROM foo")?,
delete_statement: db.prepare("DELETE FROM foo")?,
};
// Basic non-converting test.
@@ -466,5 +455,6 @@ mod test {
// FromSql float to int conversion, never works even if the actual value
// is an integer.
test_conversion!(db_etc, 0f64, i64, expect_from_sql_error);
Ok(())
}
}

23
src/types/serde_json.rs
View File

@@ -29,30 +29,29 @@ impl FromSql for Value {
#[cfg(test)]
mod test {
use crate::types::ToSql;
use crate::Connection;
use crate::{Connection, Result};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (t TEXT, b BLOB)")
.unwrap();
db
fn checked_memory_handle() -> Result<Connection> {
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE foo (t TEXT, b BLOB)")?;
Ok(db)
}
#[test]
fn test_json_value() {
let db = checked_memory_handle();
fn test_json_value() -> Result<()> {
let db = checked_memory_handle()?;
let json = r#"{"foo": 13, "bar": "baz"}"#;
let data: serde_json::Value = serde_json::from_str(json).unwrap();
db.execute(
"INSERT INTO foo (t, b) VALUES (?, ?)",
&[&data as &dyn ToSql, &json.as_bytes()],
)
.unwrap();
)?;
let t: serde_json::Value = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let t: serde_json::Value = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
assert_eq!(data, t);
let b: serde_json::Value = db.query_row("SELECT b FROM foo", [], |r| r.get(0)).unwrap();
let b: serde_json::Value = db.query_row("SELECT b FROM foo", [], |r| r.get(0))?;
assert_eq!(data, b);
Ok(())
}
}

25
src/types/time.rs
View File

@@ -37,16 +37,15 @@ mod test {
use std::time::Duration;
use time::OffsetDateTime;
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT)")
.unwrap();
db
fn checked_memory_handle() -> Result<Connection> {
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE foo (t TEXT, i INTEGER, f FLOAT)")?;
Ok(db)
}
#[test]
fn test_offset_date_time() {
let db = checked_memory_handle();
fn test_offset_date_time() -> Result<()> {
let db = checked_memory_handle()?;
let mut ts_vec = vec![];
@@ -61,21 +60,23 @@ mod test {
ts_vec.push(make_datetime(10_000_000_000, 0)); //November 20, 2286
for ts in ts_vec {
db.execute("INSERT INTO foo(t) VALUES (?)", &[&ts]).unwrap();
db.execute("INSERT INTO foo(t) VALUES (?)", &[&ts])?;
let from: OffsetDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0)).unwrap();
let from: OffsetDateTime = db.query_row("SELECT t FROM foo", [], |r| r.get(0))?;
db.execute("DELETE FROM foo", []).unwrap();
db.execute("DELETE FROM foo", [])?;
assert_eq!(from, ts);
}
Ok(())
}
#[test]
fn test_sqlite_functions() {
let db = checked_memory_handle();
fn test_sqlite_functions() -> Result<()> {
let db = checked_memory_handle()?;
let result: Result<OffsetDateTime> =
db.query_row("SELECT CURRENT_TIMESTAMP", [], |r| r.get(0));
assert!(result.is_ok());
Ok(())
}
}

41
src/types/to_sql.rs
View File

@@ -245,6 +245,7 @@ impl<T: ToSql> ToSql for Option<T> {
#[cfg(test)]
mod test {
use super::ToSql;
use crate::Result;
fn is_to_sql<T: ToSql>() {}
@@ -339,12 +340,11 @@ mod test {
#[cfg(feature = "i128_blob")]
#[test]
fn test_i128() {
fn test_i128() -> Result<()> {
use crate::Connection;
use std::i128;
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (i128 BLOB, desc TEXT)")
.unwrap();
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE foo (i128 BLOB, desc TEXT)")?;
db.execute(
"
INSERT INTO foo(i128, desc) VALUES
@@ -353,20 +353,15 @@ mod test {
(?, 'pos one'), (?, 'pos two'),
(?, 'min'), (?, 'max')",
[0i128, -1i128, -2i128, 1i128, 2i128, i128::MIN, i128::MAX],
)
.unwrap();
)?;
let mut stmt = db
.prepare("SELECT i128, desc FROM foo ORDER BY i128 ASC")
.unwrap();
let mut stmt = db.prepare("SELECT i128, desc FROM foo ORDER BY i128 ASC")?;
let res = stmt
.query_map([], |row| {
Ok((row.get::<_, i128>(0)?, row.get::<_, String>(1)?))
})
.unwrap()
.collect::<Result<Vec<_>, _>>()
.unwrap();
})?
.collect::<Result<Vec<_>, _>>()?;
assert_eq!(
res,
@@ -380,37 +375,35 @@ mod test {
(i128::MAX, "max".to_owned()),
]
);
Ok(())
}
#[cfg(feature = "uuid")]
#[test]
fn test_uuid() {
fn test_uuid() -> Result<()> {
use crate::{params, Connection};
use uuid::Uuid;
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE foo (id BLOB CHECK(length(id) = 16), label TEXT);")
.unwrap();
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE foo (id BLOB CHECK(length(id) = 16), label TEXT);")?;
let id = Uuid::new_v4();
db.execute(
"INSERT INTO foo (id, label) VALUES (?, ?)",
params![id, "target"],
)
.unwrap();
)?;
let mut stmt = db
.prepare("SELECT id, label FROM foo WHERE id = ?")
.unwrap();
let mut stmt = db.prepare("SELECT id, label FROM foo WHERE id = ?")?;
let mut rows = stmt.query(params![id]).unwrap();
let row = rows.next().unwrap().unwrap();
let mut rows = stmt.query(params![id])?;
let row = rows.next()?.unwrap();
let found_id: Uuid = row.get_unwrap(0);
let found_label: String = row.get_unwrap(1);
assert_eq!(found_id, id);
assert_eq!(found_label, "target");
Ok(())
}
}

23
src/types/url.rs
View File

@@ -30,11 +30,10 @@ mod test {
use crate::{params, Connection, Error, Result};
use url::{ParseError, Url};
fn checked_memory_handle() -> Connection {
let db = Connection::open_in_memory().unwrap();
db.execute_batch("CREATE TABLE urls (i INTEGER, v TEXT)")
.unwrap();
db
fn checked_memory_handle() -> Result<Connection> {
let db = Connection::open_in_memory()?;
db.execute_batch("CREATE TABLE urls (i INTEGER, v TEXT)")?;
Ok(db)
}
fn get_url(db: &Connection, id: i64) -> Result<Url> {
@@ -42,8 +41,8 @@ mod test {
}
#[test]
fn test_sql_url() {
let db = &checked_memory_handle();
fn test_sql_url() -> Result<()> {
let db = &checked_memory_handle()?;
let url0 = Url::parse("http://www.example1.com").unwrap();
let url1 = Url::parse("http://www.example1.com/👌").unwrap();
@@ -54,16 +53,15 @@ mod test {
// also insert a non-hex encoded url (which might be present if it was
// inserted separately)
params![url0, url1, url2, "illegal"],
)
.unwrap();
)?;
assert_eq!(get_url(db, 0).unwrap(), url0);
assert_eq!(get_url(db, 0)?, url0);
assert_eq!(get_url(db, 1).unwrap(), url1);
assert_eq!(get_url(db, 1)?, url1);
// Should successfully read it, even though it wasn't inserted as an
// escaped url.
let out_url2: Url = get_url(db, 2).unwrap();
let out_url2: Url = get_url(db, 2)?;
assert_eq!(out_url2, Url::parse(url2).unwrap());
// Make sure the conversion error comes through correctly.
@@ -79,5 +77,6 @@ mod test {
panic!("Expected conversion failure, got {}", e);
}
}
Ok(())
}
}