ISAR/rusqlite
2
0
Fork 0
mirror of https://github.com/isar/rusqlite.git synced 2025-12-21 19:02:23 +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

93
src/cache.rs
View File

@@ -175,7 +175,7 @@ impl StatementCache {
#[cfg(test)]
mod test {
use super::StatementCache;
use crate::Connection;
use crate::{Connection, Result};
use fallible_iterator::FallibleIterator;
impl StatementCache {
@@ -193,8 +193,8 @@ mod test {
}
#[test]
fn test_cache() {
let db = Connection::open_in_memory().unwrap();
fn test_cache() -> Result<()> {
let db = Connection::open_in_memory()?;
let cache = &db.cache;
let initial_capacity = cache.capacity();
assert_eq!(0, cache.len());
@@ -202,34 +202,35 @@ mod test {
let sql = "PRAGMA schema_version";
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
}
assert_eq!(1, cache.len());
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
}
assert_eq!(1, cache.len());
cache.clear();
assert_eq!(0, cache.len());
assert_eq!(initial_capacity, cache.capacity());
Ok(())
}
#[test]
fn test_set_capacity() {
let db = Connection::open_in_memory().unwrap();
fn test_set_capacity() -> Result<()> {
let db = Connection::open_in_memory()?;
let cache = &db.cache;
let sql = "PRAGMA schema_version";
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
}
assert_eq!(1, cache.len());
@@ -237,55 +238,53 @@ mod test {
assert_eq!(0, cache.len());
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
}
assert_eq!(0, cache.len());
db.set_prepared_statement_cache_capacity(8);
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
}
assert_eq!(1, cache.len());
Ok(())
}
#[test]
fn test_discard() {
let db = Connection::open_in_memory().unwrap();
fn test_discard() -> Result<()> {
let db = Connection::open_in_memory()?;
let cache = &db.cache;
let sql = "PRAGMA schema_version";
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
stmt.discard();
}
assert_eq!(0, cache.len());
Ok(())
}
#[test]
fn test_ddl() {
let db = Connection::open_in_memory().unwrap();
fn test_ddl() -> Result<()> {
let db = Connection::open_in_memory()?;
db.execute_batch(
r#"
CREATE TABLE foo (x INT);
INSERT INTO foo VALUES (1);
"#,
)
.unwrap();
)?;
let sql = "SELECT * FROM foo";
{
let mut stmt = db.prepare_cached(sql).unwrap();
assert_eq!(
Ok(Some(1i32)),
stmt.query([]).unwrap().map(|r| r.get(0)).next()
);
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(Ok(Some(1i32)), stmt.query([])?.map(|r| r.get(0)).next());
}
db.execute_batch(
@@ -293,55 +292,55 @@ mod test {
ALTER TABLE foo ADD COLUMN y INT;
UPDATE foo SET y = 2;
"#,
)
.unwrap();
)?;
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(
Ok(Some((1i32, 2i32))),
stmt.query([])
.unwrap()
.map(|r| Ok((r.get(0)?, r.get(1)?)))
.next()
stmt.query([])?.map(|r| Ok((r.get(0)?, r.get(1)?))).next()
);
}
Ok(())
}
#[test]
fn test_connection_close() {
let conn = Connection::open_in_memory().unwrap();
conn.prepare_cached("SELECT * FROM sqlite_master;").unwrap();
fn test_connection_close() -> Result<()> {
let conn = Connection::open_in_memory()?;
conn.prepare_cached("SELECT * FROM sqlite_master;")?;
conn.close().expect("connection not closed");
Ok(())
}
#[test]
fn test_cache_key() {
let db = Connection::open_in_memory().unwrap();
fn test_cache_key() -> Result<()> {
let db = Connection::open_in_memory()?;
let cache = &db.cache;
assert_eq!(0, cache.len());
//let sql = " PRAGMA schema_version; -- comment";
let sql = "PRAGMA schema_version; ";
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
}
assert_eq!(1, cache.len());
{
let mut stmt = db.prepare_cached(sql).unwrap();
let mut stmt = db.prepare_cached(sql)?;
assert_eq!(0, cache.len());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0)).unwrap());
assert_eq!(0, stmt.query_row([], |r| r.get::<_, i64>(0))?);
}
assert_eq!(1, cache.len());
Ok(())
}
#[test]
fn test_empty_stmt() {
let conn = Connection::open_in_memory().unwrap();
conn.prepare_cached("").unwrap();
fn test_empty_stmt() -> Result<()> {
let conn = Connection::open_in_memory()?;
conn.prepare_cached("")?;
Ok(())
}
}